Si trabajamos con .NET, una tarea con la casi seguro que nos encontraremos habitualmente es con la de construir un servicio web que exponga una serie de datos. Esto es muy sencillo de hacer en .NET, y vamos a ver como se hace.
Antecedentes
Supongamos que vamos a realizar un webservice que se conecte a una base de datos SQL Server para lanzarle consultas y devolver los resultados. Esto será válido para la mayoría de casos con que nos encontramos, independientemente de que después debamos ampliar el servicio con otros métodos (como por ejemplo incluir seguridad, encriptación, etc).
Lo primero que se nos puede ocurrir, es crear una serie de métodos en el WebService de forma que cada uno reciba sus parámetros, monte las consultas, y las lance contra la base de datos para terminar devolviendo los resultados. Esto es correcto, pero vamos a crear una técnica más potente.
En vez de hacer un método por cada consulta a lanzar, vamos a tener un sólo método. Este, recibirá un nombre de opción a ejecutar, y según esa opción, lanzará una u otra consulta. Es más, no tendremos que tener las consultas dentro del propio WebService, sino que nos basaremos para configurarlas en un fichero XML. Esto nos va a permitir disponer de un código muy limpio y claro, con muy poco mantenimiento posterior, y configuraremos las posibles opciones y sus consultas relacionadas en un fichero XML, de forma que para crear, modificar, o eliminar nuevos métodos, no modificaremos el servicio web, sino únicamente el XML. Veamos cómo.
Fichero de configuración
Vamos a crear un fichero XML de configuración que contendrá los métodos de que dispondrá el servicio web. Posteriormente, dicho servicio recibirá el método a ejecutar, su lista de parámetros, y devolverá los resultados.
El fichero podría ser el siguiente:
<?xml version="1.0" encoding="utf-8" ?>
<OpcionesDisponibles>
<opcion>
<nombre>GetPaises</nombre>
<SQL>SELECT cod_pais,pais FROM paises order by pais</SQL>
</opcion>
<opcion>
<nombre>GetPais</nombre>
<SQL>SELECT cod_pais,pais FROM paises WHERE cod_pais='#PARAMETRO_1#'</SQL>
</opcion>
</OpcionesDisponibles>
Como se puede ver, es extremadamente simple, y nos permitirá ampliar, modificar, o reducir el servicio web sin tener que modificarlo.
El WebService: La clase mágica
Una vez que sabemos lo que queremos, y que tenemos nuestro fichero de configuración de métodos definido, sólo nos queda crear el servicio web.
Nuestro servicio recibirá tres parámetros: la opción a ejecutar, la lista de parámetros relativas a esa función, y el formato de resultado que deseamos. Así pues, manos a la obra:
using System;
using System.Data;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Xml;
public class WS_Clase
{
static string ficheroOpciones = HttpContext.Current.Server.MapPath("~/") + "\\opciones.xml";
/// <summary>
/// Ejecutar y devolver un XML resultado de ejecutar una sentencia SQL configurada en un fichero XML.
/// </summary>
/// <param name="nombre"></param>
/// <param name="listaParametros"></param>
/// <returns></returns>
public static XmlDocument GetOpcion(string nombre, string listaParametros)
{
try
{
// Buscar opcion en el fichero de parametros para obtener la SQL a ejecutar
DataSet ds = new DataSet();
ds.ReadXml(ficheroOpciones);
DataTable dt = new DataTable();
dt = ds.Tables[0];
string SQL = string.Empty;
for (int i = 0; i < dt.Rows.Count; i++)
{
if (Convert.ToString(dt.Rows[i]["nombre"]).ToUpper() == nombre.ToUpper())
{
SQL = Convert.ToString(dt.Rows[i]["SQL"]);
break;
}
}
if (SQL == string.Empty)
throw new Exception("Opción no disponible: " + nombre);
// Asignar parametros
string[] parametros;
parametros = listaParametros.Split('|');
for (int i = 0; i < parametros.Length; i++)
{
SQL = SQL.Replace("#PARAMETRO_" + Convert.ToString(i + 1) + "#", parametros[i]);
}
// Ejecutar SQL
dt = AccesoDatos.GetDataTable(SQL);
System.Xml.XmlDocument x = DataTableToXmlDocument(dt);
dt.Dispose();
ds.Dispose();
return x;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public static int SetOpcion(string nombre, string listaParametros)
{
try
{
// Buscar opcion en el fichero de parametros para obtener la SQL a ejecutar
DataSet ds = new DataSet();
ds.ReadXml(ficheroOpciones);
DataTable dt = new DataTable();
dt = ds.Tables[0];
string SQL = string.Empty;
for (int i = 0; i < dt.Rows.Count; i++)
{
if (Convert.ToString(dt.Rows[i]["nombre"]).ToUpper() == nombre.ToUpper())
{
SQL = Convert.ToString(dt.Rows[i]["SQL"]);
break;
}
}
if (SQL == string.Empty)
throw new Exception("Opción no disponible: " + nombre);
// Asignar parametros
string[] parametros;
parametros = listaParametros.Split('|');
for (int i = 0; i < parametros.Length; i++)
{
SQL = SQL.Replace("#PARAMETRO_" + Convert.ToString(i + 1) + "#", parametros[i]);
}
// Ejecutar SQL
int resul = AccesoDatos.ExecuteSQL(SQL);
// Devolver resultado
dt.Dispose();
ds.Dispose();
return resul;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// GetOpcion en formato JSON
/// </summary>
/// <param name="nombre"></param>
/// <param name="listaParametros"></param>
/// <returns></returns>
public static String GetOpcionJSON(string nombre, string listaParametros)
{
try
{
// Buscar opcion en el fichero de parametros para obtener la SQL a ejecutar
DataSet ds = new DataSet();
ds.ReadXml(ficheroOpciones);
DataTable dt = new DataTable();
dt = ds.Tables[0];
string SQL = string.Empty;
for (int i = 0; i < dt.Rows.Count; i++)
{
if (Convert.ToString(dt.Rows[i]["nombre"]).ToUpper() == nombre.ToUpper())
{
SQL = Convert.ToString(dt.Rows[i]["SQL"]);
break;
}
}
if (SQL == string.Empty)
throw new Exception("Opción no disponible: " + nombre);
// Asignar parametros
string[] parametros;
parametros = listaParametros.Split('|');
for (int i = 0; i < parametros.Length; i++)
{
SQL = SQL.Replace("#PARAMETRO_" + Convert.ToString(i + 1) + "#", parametros[i]);
}
// Ejecutar SQL
dt = AccesoDatos.GetDataTable(SQL);
string x = DataTableToJSONDocument(dt);
dt.Dispose();
ds.Dispose();
return x;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
#region " Métodos privados "
/// <summary>
/// Configurar DataTable con nomenclatura estandar para hacer mas fácil la lectura desde aplicaciones cliente (siempre mismos campos).
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
private static DataTable DataTableToStandard(DataTable dt)
{
try
{
DataTable dtResultado = new DataTable(dt.TableName);
dtResultado.Columns.Add("campo", typeof(System.String));
dtResultado.Columns.Add("valor", typeof(System.String));
DataRow dr;
for (int i = 0; i < dt.Rows.Count; i++)
{
dr = dtResultado.NewRow();
dr["campo"] = dt.Rows[i][0];
dr["valor"] = dt.Rows[i][1];
dtResultado.Rows.Add(dr);
}
return dtResultado;
}
catch (Exception ex)
{
throw ex;
}
}
private static String DataTableToJSONDocument(DataTable dt)
{
string[] StrDc = new string[dt.Columns.Count];
string HeadStr = string.Empty;
for (int i = 0; i < dt.Columns.Count; i++)
{
StrDc[i] = dt.Columns[i].Caption;
HeadStr += "\"" + StrDc[i] + "\":\"" + StrDc[i] + i.ToString() + "¾" + "\",";
}
HeadStr = HeadStr.Substring(0, HeadStr.Length - 1);
StringBuilder Sb = new StringBuilder();
Sb.Append("[");
for (int i = 0; i < dt.Rows.Count; i++)
{
string TempStr = HeadStr;
for (int j = 0; j < dt.Columns.Count; j++)
{
TempStr = TempStr.Replace(dt.Columns[j] + j.ToString() + "¾", dt.Rows[i][j].ToString().Trim());
}
//Sb.AppendFormat("{{{0}}},",TempStr);
Sb.Append("{" + TempStr + "},");
}
Sb = new StringBuilder(Sb.ToString().Substring(0, Sb.ToString().Length - 1));
if (Sb.ToString().Length > 0)
Sb.Append("]");
return StripControlChars(Sb.ToString());
}
public static string StripControlChars(string s)
{
return Regex.Replace(s, @"[^\x20-\x7F]", "");
}
/// <summary>
/// Pasar DataTable a XML estandarizado para su devolución por el WebService.
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
private static XmlDocument DataTableToXmlDocument(DataTable dt)
{
XmlDocument xml = new XmlDocument();
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append("<?xml version='1.0' encoding='utf-8' ?>");
sb.Append("<DocumentElement>");
foreach (DataRow dr in dt.Rows)
{
sb.Append("<Dato>");
foreach (DataColumn dc in dt.Columns)
{
sb.Append("<" + dc.ColumnName + ">" + dr[dc].ToString() + "</" + dc.ColumnName + ">");
}
//foreach (DataColumn dc in dt.Columns)
// sb.Append("<" + dc.ColumnName + ">" + dr[dc].ToString() + "</" + dc.ColumnName + ">");
sb.Append("</Dato>");
}
sb.Append("</DocumentElement>");
xml.LoadXml(sb.ToString());
return xml;
}
#endregion
}
El WebService: La interfaz
Una vez hemos definido la clase que hace lo que deseamos, simplemente exponemos el webservice:
using WS_Clase; // Nuestra clase creada antes
using System.Web;
using System.Web.Script.Services;
using System.Web.Services;
using System.Xml;
namespace eCliente_WebService
{
/// <summary>
/// Servicio web para el acceso a datos de la web de eCliente
/// </summary>
[WebService(Namespace = "http://nuestra_url")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[System.ComponentModel.ToolboxItem(false)]
// Para permitir que se llame a este servicio web desde un script, usando ASP.NET AJAX, quite la marca de comentario de la línea siguiente.
// [System.Web.Script.Services.ScriptService]
public class eCliente_WebService : System.Web.Services.WebService
{
[WebMethod]
public string Test()
{
return "Hola desde el WebService de eCliente.";
}
[WebMethod]
public XmlDocument GetOpcion(string nombre, string listaParametros)
{
return WS_Clases.GetOpcion(nombre, listaParametros);
}
[WebMethod]
public int SetOpcion(string nombre, string listaParametros)
{
return WS_Clases.SetOpcion(nombre, listaParametros);
}
[WebMethod]
[ScriptMethod(ResponseFormat = ResponseFormat.Json)]
public void GetOpcionJSON(string nombre, string listaParametros)
{
HttpContext.Current.Response.Write(WS_Clases.GetOpcionJSON(nombre, listaParametros));
}
[WebMethod]
[ScriptMethod(UseHttpGet = true, ResponseFormat = ResponseFormat.Json)]
public void GetOpcionJSONAjax(string nombre, string listaParametros, string callback = "")
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
if (callback != "")
{
sb.Append(callback + "(");
sb.Append(WS_Clases.GetOpcionJSON(nombre, listaParametros));
sb.Append(");");
}
else
sb.Append(WS_Clases.GetOpcionJSON(nombre, listaParametros));
Context.Response.Clear();
Context.Response.ContentType = "application/json";
Context.Response.Write(sb.ToString());
Context.Response.End();
}
}
}
Y eso es todo. Potente, ¿verdad?. Ahora sólo debemos modificar el fichero XML a nuestro gusto para adaptarlo a nuestras necesidades (ojo, recordar introducir algún sistema de seguridad, y a ser posible, excluir el fichero XML en el fichero robots.txt de nuestro servidor para que no sea indexado).
En otra entrada veremos como consumir un webservice.
Entradas
