THE .NET WAY » WebServices – – The .Net Way

Cambiar el “element name” del tipo devuelto en los servicios web

Emilio Torrens — Thu, 10 Nov 2011 12:18:10 +0000

Los servicios web de ASP.NET tienen eso, que cuando quieres devolver tu objeto Person te lo renombran al nombre del método + result y te lo meten dentro de un método + response, así este código:

public class Person
{
    public string Name { get; set; }
}
 
[WebService(Namespace = "http://tempuri.org/")]
public class Service : System.Web.Services.WebService
{
    public Service () {
    }
 
    [WebMethod]
    public Person Get() {
        return new Person { Name = "Pepito" };
    }
    
}

Te generara esto:

Sin embargo usando atributos de Serializacion en la clase Person, definiéndole el nombre y el tipo, y de Soap en la clase Service conseguiremos que nos devuelva el objeto como lo hemos definido.

Así que este código:

[System.Xml.Serialization.XmlRootAttribute(ElementName = "Person", DataType = "Person")]
public class Person
{
    public string Name { get; set; }
}
 
[SoapDocumentService(Use=SoapBindingUse.Literal, ParameterStyle=SoapParameterStyle.Bare), WebService(Namespace = "http://tempuri.org/")]
public class Service : System.Web.Services.WebService
{
    public Service () {
    }
 
    [WebMethod]
    public Person Get() {
        return new Person { Name = "Pepito" };
    }
    
}

Te genera esto:

Rest Services JSON y XML con ASP.NET MVC

Emilio Torrens — Thu, 19 May 2011 12:38:43 +0000

Aquí dejo un ejemplo de como usar MVC para hacer servicios rest utilizando diferentes formatos para transportar los datos, para la serializacion Json utilizo la librería Json.NET, es la única dependencia.

Las url de los servicios de este ejemplo serán estas:

http://localhost/RestServices/MyClass/All.json
http://localhost/RestServices/MyClass/All.xml
http://localhost/RestServices/MyClass/Get/1.json
http://localhost/RestServices/MyClass/Get/1.xml
http://localhost/RestServices/MyClass/GetByName/Nombre%201.json
http://localhost/RestServices/MyClass/GetByName/Nombre%201.xml
http://localhost/RestServices/MyClass/Put.json
http://localhost/RestServices/MyClass/Put.xml
http://localhost/RestServices/MyClass/Delete.json
http://localhost/RestServices/MyClass/Delete.xml

Lo único que tienes que hacer es crear un nuevo proyecto MVC, modificar el Global.asax con las rutas y añadir el controlador.

El código de ejemplo:

Esta clase es de ayuda para el ejemplo, nada especial

public class MyClassHelper
{
    private static List DataList = null;
 
    public class MyClass
    {
        public string Id { get; set; }
        public string Name { get; set; }
    }
 
    public static List Data 
    {
        get 
        {
            if (DataList == null)
            {
                DataList = new List();
                for (int i = 0; i < 10; i++)
                {
                    DataList.Add(new MyClass { Id = i.ToString(), Name = "Nombre " + i });
                }
            }
            return DataList;
        }
    }
 
    public static string MyClassToXml(MyClass c)
    {
        XmlSerializer ser = new XmlSerializer(typeof(MyClass));
        StringWriter sw = new StringWriter();
 
        ser.Serialize(sw, c);
 
        sw.Flush();
        sw.Close();
        return sw.ToString();
    }
 
    public static string MyClassToXml(List c)
    {
        XmlSerializer ser = new XmlSerializer(typeof(List));
        StringWriter sw = new StringWriter();
 
        ser.Serialize(sw, c);
 
        sw.Flush();
        sw.Close();
        return sw.ToString();
    }
 
    public static MyClass XmlToMyClass(string xml)
    {
        StringReader sr = new StringReader(xml);
        XmlSerializer ser = new XmlSerializer(typeof(MyClass));
        return (MyClass)ser.Deserialize(sr);
    }
 
    public static string MyClassToJson(MyClass c)
    {
        return JsonConvert.SerializeObject(c);
    }
 
    public static string MyClassToJson(List c)
    {
        return JsonConvert.SerializeObject(c);
    }
 
    public static MyClass JsonToMyClass(string Json)
    {
        return JsonConvert.DeserializeObject(Json);
    }
 
}

Esta es la clase del Global.asax, aquí es donde se definen las rutas, veas que hay dos, una para el All, Put y Delete y otra para el Get y GetByName, con el id

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
 
    routes.MapRoute(
       "Default", // Route name
       "{controller}/{action}.{format}", // URL with parameters
       new { controller = "Home", action = "Index", format = UrlParameter.Optional } // Parameter defaults
   );
 
    routes.MapRoute(
        "WithID", // Route name
        "{controller}/{action}/{id}.{format}", // URL with parameters
        new { controller = "Home", action = "Index", id = UrlParameter.Optional, format = UrlParameter.Optional } // Parameter defaults
    );
 
}

Este es el controlador, aquí definimos los metodos que reciben los parámetros que hemos definido en el Global.asax

public class MyClassController : Controller
{
 
    public string All(string format)
    {
        List result = MyClassHelper.Data;
        if (format.ToLower() == "xml")
        {
            return MyClassHelper.MyClassToXml(result);
        }
        else
        {
            return MyClassHelper.MyClassToJson(result);
        }
        
    }
 
    public string Get(string id, string format)
    {
        MyClassHelper.MyClass result = MyClassHelper.Data.Where(c => c.Id == id).FirstOrDefault();
        if (format.ToLower() == "xml")
        {
            return MyClassHelper.MyClassToXml(result);
        }
        else
        {
            return MyClassHelper.MyClassToJson(result);
        }
 
 
    }
 
    public string GetByName(string id, string format)
    {
        List result = MyClassHelper.Data.Where(c => c.Name == id).ToList();
        if (format.ToLower() == "xml")
        {
            return MyClassHelper.MyClassToXml(result);
        }
        else
        {
            return MyClassHelper.MyClassToJson(result);
        }
    }
 
    public string Put(string format)
    {
        MyClassHelper.MyClass c;
        using (var reader = new StreamReader(Request.InputStream))
        {
            if (format.ToLower() == "xml")
            {
                c = MyClassHelper.XmlToMyClass(reader.ReadToEnd());
            }
            else
            {
               c = MyClassHelper.JsonToMyClass(reader.ReadToEnd());
            }
        }
 
        var v = from myc in MyClassHelper.Data where myc.Id == c.Id select myc;
 
        if (v.Count() == 0)
            MyClassHelper.Data.Add(c);
        else
            v.First().Name = c.Name;
 
        return "OK";
 
    }
 
    public string Delete(string format)
    {
        MyClassHelper.MyClass c;
        using (var reader = new StreamReader(Request.InputStream))
        {
            if (format.ToLower() == "xml")
            {
                c = MyClassHelper.XmlToMyClass(reader.ReadToEnd());
            }
            else
            {
                c = MyClassHelper.JsonToMyClass(reader.ReadToEnd());
            }
        }
 
        MyClassHelper.Data.Remove(c);
 
        return "OK";
 
    }
 
}

Y listo, eso es todo

XFire y Eclipse

Emilio Torrens — Tue, 16 Feb 2010 09:23:04 +0000

XFire te permite generar el código necesario para un cliente de webservice a partir de su WSDL

Para usarlo con Eclipse debes instalar el Plugin, para eso vas al menú Help/Install New Software le das a Add en Name le pones XFire y en location le pones esta dirección “http://dist.codehaus.org/xfire/update/”, Ok, Finish y ya lo tienes instalado.

Para usarlo vas al proyecto, New/Other, buscas el Wizard de XFire y allí solo tienes que poner la dirección del WSDL y donde quieres que te genere el código y listo.

Con estos pocos pasos ya tienes todas las clases necesarias para acatar el servicio, además con XFire no he tenido problemas con los WSDL de ningún servicio.

Es importante que añadas commons-httpclient-3.0.jar y commons-codec.jar al proyecto ya que XFire las necesita.

SoapHeader, SoapExtensions y Herencia

Emilio Torrens — Thu, 03 Dec 2009 10:31:37 +0000

Hace unos días Jordi escribió sobre las SoapExtensions y yo sobre las SoapHeaders, hoy le añadimos herencia y vemos como ahorrarnos bastante código y trabajo en una capa de servicios.

La idea es que todos los métodos de todos los servicios web de la aplicación se autentifiquen en el mismo sitio y no tener que poner el código de autentificación en cada método, además no queremos usar cookies ni mantenimiento de sesión.

Para esto usaremos una Cabecera Soap donde el cliente nos enviara Usuario y Contraseña, debemos crear la clase cabecera:

public class SoapHeaderCredentials : SoapHeader
{
public string Password = "";
public string UserName = "";
}

Cada servicio web tiene que tener una propiedad con la Cabecera, para ahorrarnos el escribirlo cada vez, creamos una clase que herede de WebService, que contenga la propiedad y heredamos los servicios web de esa clase:

public class MyWebService : System.Web.Services.WebService
{
    public SoapHeaderCredentials soapHeaderCredentials;
}

public class Service : MyWebService

Después creamos una Extensión Soap de autentificación (en este caso la llamamos AuthenticationExtension), Jordi ya explica aquí como crearlas así que solo pongo el código que nos interesa, que es donde buscamos la Cabecera Soap en el Método ProcessMessage:

case SoapMessageStage.AfterDeserialize:
{
    var o = from h in message.Headers.Cast<SoapHeader>()
            where h.GetType() == typeof(SoapHeaderCredentials)
            select h ;
    SoapHeaderCredentials soapHeaderCredentials =
        (SoapHeaderCredentials) o.First();
    AuthenticateUser(
        new Credentials()
        {
          UserName = soapHeaderCredentials.UserName,
          Password = soapHeaderCredentials.Password,
        },

      );
    break;
}

Después solo queda añadir los dos atributos [SoapHeader("soapHeaderCredentials")] y [AuthenticationExtension()] a nuestros WebMethods, eso hará que los métodos tengan la cabecera de usuario y contraseña y que ejecuten el código de autentificación al recibir un mensaje:

[WebMethod]
[SoapHeader("soapHeaderCredentials")]
[AuthenticationExtension()]
public string HelloWorld()
{
    return "Hello World";
}

Y listo

Cabeceras en mensajes SOAP

Emilio Torrens — Fri, 27 Nov 2009 12:38:14 +0000

Añadir cabeceras personalizadas a los mensajes de nuestros servicios web es realmente sencillo, en esas cabeceras podemos transportar cualquier dato que nos interese tokens, usuario y contraseña, lo que sea..

Hay que hacer lo siguiente:

1- Crear la clase con los datos que herede de SoapHeader

public class SoapHeaderData: SoapHeader
{
    public string Data1;
    public string Data2;
    public string Data3;
}

2- Crear una propiedad en el servicio web con esa clase y la etiqueta SoapHeader con el nombre de la propiedad al método web, en esa propiedad tendremos los datos

[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class Service : System.Web.Services.WebService
{
    public SoapHeaderData HeaderData;

    [WebMethod]
    [SoapHeader("HeaderData")]
    public string HelloWorld() {
        return "Hello World " + HeaderData.Data1 + ", " +
                                HeaderData.Data2 + ", " +
                                HeaderData.Data3;
    }
}

Solo haciendo esto ya tenemos la cabecera en nuestra petición SOAP:

Generando clases en Java desde WSDL autogenerados (asmx)

Emilio Torrens — Tue, 14 Apr 2009 15:05:30 +0000

Tenemos un par de Clientes que usan Java y tienen que consumir los servicios web de nuestras aplicaciones (asmx), hemos tenido muchos problemas generando las clases desde Eclipse o el Intellij IDEA desde el wsdl autogenerado de los asmx.

Al final hemos encontrado la solución, usar el XFIRE, usando ese framework de Java no hemos tenido problemas

Aquí hay un quickstart de cómo utilizar el plugin en el Eclipse:

http://xfire.codehaus.org/Eclipse+Plugin

Documentación:

http://xfire.codehaus.org/User’s+Guide

Hay una nueva versión que se llama CXF

http://cxf.apache.org/

Aunque no la hemos probado, así que para ir sobre seguro usa o recomienda usar XFIRE

Pasar Credenciales en Http Header Authorization

Emilio Torrens — Thu, 27 Nov 2008 08:29:00 +0000

Me he estado volviendo medio loco estos días intentando conectar con el servicio de un tercero, la documentación no era todo lo clara que uno espera…

Intente pasarle las Credenciales como NetworkCredentials en el HttpRequest y nada, añadiendo cabeceras de autentificación al mensaje SOAP y nada, al final las espera en una cabecera Http.

¿Como se pasan allí? pues así:

HttpWebRequest req = (HttpWebRequest)WebRequest.Create("la url del servicio");

req.Headers.Add("SOAPAction", "la accion");
req.ContentType = "application/soap+xml";
req.Accept = "text/xml";
req.Method = "POST";
byte[] authBytes = Encoding.UTF8.GetBytes(("Usuario:Pass").ToCharArray());
req.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(authBytes));

Cliente SOAP para servicios PHP o Java AXIS

Emilio Torrens — Mon, 14 Apr 2008 14:08:00 +0000

Aquí dejo una clase para consumir servicios web vía SOAP en los que no tengamos el WSDL o que el Wizard nos de problemas:

using System;
using System.Text;
using System.IO;
using System.Net;
using System.Xml;

namespace Test
    {
    class SOAPClient
        {

        public static XmlDocument SendMsg(XmlDocument xmlRQ)
            {
                byte[] byte1;
                Stream myStream;
                StreamReader readStream;

                HttpWebRequest wr =
                    (HttpWebRequest)WebRequest.
                    Create("http://laurl.com/ws.php");

                byte1 =
                Encoding.GetEncoding(1252).GetBytes(xmlRQ.OuterXml);
                wr.Method = "POST";
                wr.Headers.Add("SOAPAction", "");
                wr.ContentType = "text/xml; charset=\"utf-8\"";
                wr.Accept = "text/xml";

                myStream = wr.GetRequestStream();
                myStream.Write(byte1, 0, byte1.Length);
                myStream.Close();

                myStream = wr.GetResponse().GetResponseStream();
                readStream = new StreamReader(myStream);
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(readStream);
                myStream.Close();

                return getSOAPPayload(xmlDoc, "body");
            }

          private static XmlDocument getSOAPPayload(XmlDocument rs,
                                                    string Tag)
            {

                XmlNode xmlNode =
                    rs.GetElementsByTagName(Tag)[0].FirstChild;
                XmlDocument xmlResult = new XmlDocument();
                xmlResult.LoadXml(xmlNode.Value);
                return xmlResult;
            }

        }
    }

ASP.NET Servicios Web y CacheDuration (de paso como activar POST y GET en nuestros servicios web)

Emilio Torrens — Thu, 08 Nov 2007 08:32:00 +0000

CacheDuration es un atributo de WebMethod con el que podemos implementar de manera muy sencilla un sistema de chache basado en el tiempo, cuando le indicamos la duración del Cache (en segundos) el servidor guarda los parámetros del request y la respuesta, así mientras no caduque el cache para parámetros iguales el código de nuestro método no se ejecutara y devolverá el resultado desde el cache.

Podéis probar con este código, la primera vez tardara 5 segundos, pero durante el siguiente minuto, para el mismo Texto, será instantáneo:

WebMethod(CacheDuration=60)]
 public int CountChars(string Text)
 {
     System.Threading.Thread.Sleep(5000);
     return String.IsNullOrEmpty(Text) ? 0 : Text.Length;
 }

Ojo que las peticiones vía POST no se guardan en el cache y la pagina de pruebas de los servicios web funciona con POST, así que debes probarlo o bien por SOAP o bien por GET.

Por defecto los servicios web llevan el GET y el POST desactivado, para activarlos solo tenéis que añadir esto dentro de en el Web.config:

<webServices>
   <protocols>
      <add name="HttpGet"/>
      <add name="HttpPost"/>
   protocols>
webServices>