{ WillyXoft .NET }

WCF bajo Contrato (4/4)

vbpuntonet — Sat, 05 Jul 2008 16:03:49 GMT

Contrato de Fallo

Cualquier operación petición/respuesta devuelve dos posibles mensajes: su mensaje de respuesta normal, o bien un mensaje de error. Para enviar un mensaje de error (un "SOAP Fault" en términos de servicios web) se lanza una FaultException en la implementación del servicio, tal y como se ha ejemplificado hasta ahora.

Pero además se pueden especificar formalmente los mensajes de error utilizando tipos personalizados con un contrato de datos adecuado, dado que se serializarán mediante el DataContractSerializer. El tipo a utilizar en el mensaje de error se especifica contractualmente en la firma de la operación utilizando el atributo FaultContract, mientras que en la implementación de la operación se genera mediante una FaultException del tipo especificado en el FaultContract.

Como ejemplo suponga que deseamos especificar un mensaje de error, que nos informe sobre un error en el parámetro de la petición, utilizando el siguiente tipo con su contrato de datos:

Listado de HelloData.cs (fragmento)

[DataContract(Namespace="http://hello/data/")]
public class InvalidRequest
{
  private int id;
  private string message;
  private string notes;

  [DataMember()]
  public int ID
  {
    get { return id; }
    set { id = value; }
  }

  [DataMember()]
  public string Message
  {
    get { return message; }
    set { message = value; }
  }				

  [DataMember()]
  public string Notes
  {
    get { return notes; }
    set { notes = value; }
  }				
}

El fragmento de código se agrega al archivo HelloData.cs, tras lo cual lo compilamos.

Para especificar el uso del tipo InvalidRequest como tipo de fallo sobre la operación, aplicamos el atributo FaultContract a la firma de la operación:

Listado de Hello.cs (fragmento)

[ServiceContract(Namespace="http://hello/", Name="Hello")]
interface IHello
{
  [OperationContract()]
  [FaultContract(typeof(InvalidRequest))]
  SayHelloResponse SayHello(SayHelloRequest request);
}

Después en la clase de implementación del servicio se lanzan las excepciones correspondientes:

Listado de Hello.cs (fragmento)

  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")]
  public class Hello : IHello
  {
    private StringBuilder message = new StringBuilder("¡Hola ");

    private void ValidateRequest(SayHelloRequest request)
    {
      if (request.PersonParameter == null)
      {
        InvalidRequest fault = new InvalidRequest();
        fault.ID = 1;
        fault.Message = "Parámetro Person inválido";
        fault.Notes = "El objeto Person no puede ser nulo...";
        throw new FaultException<InvalidRequest>(fault, "Parámetro inválido.");
      }
      else if (request.PersonParameter.FirstName == null ||
        request.PersonParameter.FirstName.Length == 0)
      {
        InvalidRequest fault = new InvalidRequest();
        fault.ID = 2;
        fault.Message = "Miembro FirstName inválido";
        fault.Notes = "El miembro FirstName del objeto Person no puede ser nulo o vacío...";
        throw new FaultException<InvalidRequest>(fault, "Parámetro inválido.");
      }
    }

    public SayHelloResponse SayHello(SayHelloRequest request)
    {
      ValidateRequest(request);

      message.Append(request.PersonParameter.FirstName + "!");
      string msg = message.ToString();
      SayHelloResponse response = new SayHelloResponse();
      HelloCard card = new HelloCard();
      card.Greeting = msg;
      response.HelloCardResult = card;
      System.Console.WriteLine(msg);
      return response;
    }
  }

Nótese que hemos extraído el código de validación del request en un método privado, en el cual se crea una instancia de InvalidRequest, se establece la información pertinente, y se lanza un FaultException con dicha instancia. Note además que se hace el uso de la versión "genérica" de FaultException para ello.

Compilamos Hello.cs, y para terminar del lado del servicio sólo ejecutamos la aplicación host.

Para el cliente una vez más se regeneran los artefactos cliente con svcutil.exe.

Después, aunque el código de la aplicación cliente podría funcionar sin cambios, para poder consumir los mensajes adicionales de error (de tipo InvalidRequest) ahora agregaremos un catch para "atrapar" el FaultException de tipo InvalidRequest. El listado de Client.cs queda de la siguiente manera:

Listado de Client.cs

using System;
using System.ServiceModel;

public class Client
{
  static void Main(string[] args)
  {
    String arg = null;
    String result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anónimo";
    }
    try {
      hello.Hello service = new hello.HelloClient();
      hello.data.Person person = new hello.data.Person();
      person.FirstName = arg;
      hello.SayHelloRequest request = new hello.SayHelloRequest();
      request.Person = person;
      hello.SayHelloResponse response = service.SayHello(request);
      result = response.HelloCard.Greeting;
    }
    catch (FaultException<hello.data.InvalidRequest> helloFault)
    {
      result = String.Format("{0}\nID: {1}\nMensaje: {2}\nNotas: {3}",
                helloFault.Message,
                helloFault.Detail.ID,
                helloFault.Detail.Message,
                helloFault.Detail.Notes);
    }
    catch (FaultException fault) {
      result = "Fault: " + fault.Message;
    }
    catch (Exception ex) {
      result = "Error: " + ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Observe que para acceder a los miembros de la instancia de InvalidRequest enviada utilizamos la propiedad Detail de la instancia de FaultException helloFault.

Compilamos el proxy y el cliente, y ejecutamos Client.exe. Pruebe las excepciones modificando el código de la aplicación cliente, ya sea estableciendo a nulo el valor del miembro FirstName o el parámetro Person, y volviendo a compilar y ejecutar...

Epílogo

Con los ejemplos vistos en la presente serie se han explorado brevemente los diferentes tipos de contratos de WCF: contrato de servicio, contrato de datos, contrato de mensajes y contrato de fallo. Los mismos se definen aplicando ciertos atributos a clases y sus miembros. Los atributos permiten parámetros por nombre, tales como el Namespace y Name, para una mejor definición del elemento al cual se aplica. Queda como tarea para el lector que indague sobre dichos parámetros, ya que existen muchos otros en cada uno de los distintos atributos.

Quedan pendientes entonces varias cosas, además del nuevo cliente Java, mismas que espero abordar en futuras ocasiones. ¡Hasta entonces!

WCF bajo Contrato (3/4)

vbpuntonet — Fri, 04 Jul 2008 20:01:04 GMT

Contrato de Mensajes

Hasta ahora se ha redefinido el contrato de servicio utilizando una interfaz, así como empleado tipos personalizados con contrato de datos definidos, lo cual es suficiente en la mayoría de los casos.

Pero cuando se desea tener mayor control sobre la estructura de los mensajes SOAP debemos crear un contrato de mensajes el cual permite utilizar un tipo para el parámetro y el valor devuelto que se serialicen en los mensajes SOAP de solicitud y respuesta que se necesiten.

A éste estilo de modelado de las operaciones se le conoce como estilo de mensajería, en contraposición al estilo de llamada de procedimiento remoto (RPC). Las firmas de las operaciones de estilo de mensajería tienen hasta un parámetro y un valor de retorno y ambos deben ser tipos de mensaje que se serializan directamente en una estructura del mensaje SOAP especificado.

Para definir el contrato de mensajes debemos aplicar el atributo MessageContract a las clases que vayan ser los tipos de mensaje. Así también debemos aplicar el atributo MessageBodyMember a sus miembros (que pueden ser campos, propiedades o eventos) que serán los elementos del cuerpo del mensaje SOAP, o bien el atributo MessageHeader para especificar el encabezado del mensaje.

Podriamos haber empleado el contrato de mensajes desde la versión del servicio que empleaba tipos simples, en cuyo caso podría ser algo como:

[MessageContract()]
public class SayHelloRequest
{
  [MessageBodyMember()]
  public string name
}

[MessageContract()]
public class SayHelloResponse
{
  [MessageBodyMember()]
  public string greeting
}

Pero continuando con nuestro ejemplo, los contratos de mensaje para la operación SayHello quedan de la siguiente forma:

Listado de Hello.cs (fragmento)

using hello.data;

  [MessageContract()]
  public class SayHelloRequest
  {
    private Person person;

    [MessageBodyMember(Name="Person")]
    public Person PersonParameter
    {
      get { return person; }
      set { person = value; }
    }
  }

  [MessageContract()]
  public class SayHelloResponse
  {
    private HelloCard helloCard;

    [MessageBodyMember(Name="HelloCard")]
    public HelloCard HelloCardResult
    {
      get { return helloCard; }
      set { helloCard = value; }
    }
  }

Nótese que se trata de clases "planas" con atributos, y que los elementos del cuerpo de los mensajes son los tipos personalizados con contratos de datos definidos anteriormente en HelloData.cs.

Para utilizar los tipos de mensaje ahora la firma del contrato de servicio debe redefinirse como sigue:

Listado de Hello.cs (fragmento)

[ServiceContract(Namespace="http://hello/", Name="Hello")]
interface IHello
{
  [OperationContract()]
  SayHelloResponse SayHello(SayHelloRequest request);
}

Por lo que también debemos reescribir su implementación. El listado completo de Hello.cs queda entonces de la siguiente forma:

Listado de Hello.cs

using System;
using System.Text;
using System.ServiceModel;
using hello.data;

namespace hello
{

  [MessageContract()]
  public class SayHelloRequest
  {
    private Person person;

    [MessageBodyMember(Name="Person")]
    public Person PersonParameter
    {
      get { return person; }
      set { person = value; }
    }
  }

  [MessageContract()]
  public class SayHelloResponse
  {
    private HelloCard helloCard;

    [MessageBodyMember(Name="HelloCard")]
    public HelloCard HelloCardResult
    {
      get { return helloCard; }
      set { helloCard = value; }
    }
  }
  
  [ServiceContract(Namespace="http://hello/", Name="Hello")]
  interface IHello
  {
    [OperationContract()]
    SayHelloResponse SayHello(SayHelloRequest request);
  }

  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")]
  public class Hello : IHello
  {
    private StringBuilder message = new StringBuilder("¡Hola ");

    public SayHelloResponse SayHello(SayHelloRequest request)
    {
      if (request.PersonParameter == null ||
          request.PersonParameter.FirstName == null ||
          request.PersonParameter.FirstName.Length == 0)
        throw new FaultException(
            "Parámetro Person inválido.");

      message.Append(request.PersonParameter.FirstName + "!");
      string msg = message.ToString();
      SayHelloResponse response = new SayHelloResponse();
      HelloCard card = new HelloCard();
      card.Greeting = msg;
      response.HelloCardResult = card;
      System.Console.WriteLine(msg);      
      return response;
    }
  }
}

Las clases de los archivos HelloData.cs y HelloHost.cs permanecen sin cambios. Por lo que del lado del servicio únicamente compilamos el archivo Hello.cs:

>csc /t:library Hello.cs /r:System.ServiceModel.dll,HelloData.dll

...y ejecutamos la aplicación host.

Continuemos con el cliente. Primero debemos (una vez más) regenerar los artefactos cliente con svcutil.exe, y después modificar el código de Client.cs como se muestra a continuación:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    String arg = null;
    String result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anónimo";
    }
    try {
      hello.Hello service = new hello.HelloClient();         
      hello.data.Person person = new hello.data.Person();
      person.FirstName = arg;
      hello.SayHelloRequest request = new hello.SayHelloRequest();
      request.Person = person;
      hello.SayHelloResponse response = service.SayHello(request);
      result = response.HelloCard.Greeting;
    }
    catch (System.ServiceModel.FaultException fault)
    {
      result = "Fault: " + fault.Message;
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Nótese que antes del llamado al método SayHello se deben crear una instancia del tipo de mensaje SayHelloRequest, así como el tipo Person para su miembro correspondiente. La invocación retorna una instancia del tipo de mensaje SayHelloResponse mediante la cual se recupera el mensaje a desplegar. Note también que los elementos de los mensajes tienen los nombres especificados en el argumento por nombre "Name" del atributo MessageBodyMember correspondiente.

Para finalizar compilamos el proxy y la aplicación cliente, y ejecutamos Client.exe como hasta ahora.

Dado que en el presente ejemplo no hemos empleado el contrato de mensajes para nada extraordinario, el uso del mismo pareciera una sobrecarga innecesaria. Pero tenga presente que es útil para aquellos casos en los cuales se requiere tener control sobre los elementos o cabecera del mensaje, tales como la resolución de problemas de seguridad del mensaje o problemas de interoperabilidad.

WCF bajo contrato (2/4)

vbpuntonet — Thu, 03 Jul 2008 16:01:00 GMT

Contrato de Datos

WCF emplea, de forma predeterminada, a la clase DataContractSerializer como mecanismo de serialización de datos .NET desde y hacia XML, el cual requiere que los tipos tengan un contrato de datos definido.

Hasta ahora el servicio utiliza tipos simples (string) para el intercambio de datos (en el parámetro de entrada y el valor devuelto) sin ninguna preparación. Esto se debe a que ciertos tipos del .NET Framework, entre ellos los "primitivos", tienen contratos de datos predeterminados. Si lo desea puede consultar la lista de los tipos admitidos por el DataContractSerializer.

En caso que deseáramos utilizar nuestros propios tipos de datos, necesitamos definir tipos complejos. Para ello debemos crear tipos que tengan un contrato de datos definido, lo cual conseguimos aplicando el atributo DataContract a las clases, estructuras y/o enumeraciones a ser serializables por el DataContractSerializer. Además de lo anterior debemos aplicar el atributo DataMember a los miembros que deseemos sean serializables, sin que importe su modificador de acceso.

Continuando con nuestro ejemplo, supongamos que ahora deseamos utilizar los siguientes tipos para el intercambio de datos:

Listado de HelloData.cs

using System;
using System.Runtime.Serialization;

namespace hello.data
{
    [DataContract(Namespace="http://hello/data/")]
    public class Person
    {
        private string firstName;
        private string lastName;

        [DataMember()]
        public string FirstName
        {
            get { return firstName; }
            set { firstName = value; }
        }

        [DataMember()]
        public string LastName
        {
            get { return lastName; }
            set { lastName = value; }
        }
    }

    [DataContract(Namespace="http://hello/data/")]
    public class HelloCard
    {
        private string greeting;
        private int serial;

        [DataMember()]
        public string Greeting
        {
            get { return greeting; }
            set { greeting = value; }
        }

        public int Serial
        {
            get { return serial; }
            set { serial = value; }
        }
    }
}

Nótese que son clases "planas" con los atributos que definen el contrato de datos. Observe también la declaración del espacio de nombre del .NET Framework: System.Runtime.Serialization, a cuyo ensamblado debemos referenciar para compilar HelloData.cs:

>csc /t:library HelloData.cs /r:System.Runtime.Serialization.dll

Una vez definidos los tipos personalizados, ahora definimos el nuevo contrato de servicio, y reescribimos su implementación, como se lista a continuación:

Listado de Hello.cs

using System;
using System.Text;
using System.ServiceModel;
using hello.data;

namespace hello
{
  [ServiceContract(Namespace="http://hello/")]
  interface IHello
  {
    [OperationContract()]
    public HelloCard SayHello(Person person);
  }

  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")] 
  public class Hello : IHello
  {
    private StringBuilder message = new StringBuilder("Hola ");
  
    [OperationContract(Namespace="http://hello/")]
    public HelloCard SayHello(Person person)
    {      
      if (person == null ||
      person.FirstName == null || 
      person.FirstName.Length == 0)
        throw new FaultException("Objeto Person inválido.");
      message.Append(person.FirstName + "!");
     string msg = message.ToString();
     HelloCard card = new HelloCard();
     card.Greeting = msg;
     System.Console.WriteLine(msg);
     return card;
    }
  }
}

Nota: En el código se altera la interfaz del contrato del servicio, cuando en la práctica se debe definir una nueva interfaz e implementarla. Se hizo así para simplicidad del ejemplo.

Ahora compilamos el servicio agregando la referencia al ensamblado generado previamente:

>csc /t:library Hello.cs /r:System.ServiceModel.dll,HelloData.dll

El host y su archivo de configuración permanecen sin cambios, por lo que solo resta ejecutar HelloHost.exe.

Ahora pasamos al cliente. Primero regeneramos los artefactos cliente con svcutil.exe como hasta ahora, y después modificamos el código de la aplicación cliente, tal como se aprecia a continuación:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    String arg = null;
    String result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anónimo";
    }
    try {
      hello.IHello service = new hello.HelloClient();
      hello.data.Person person = new hello.data.Person();
      person.FirstName = arg;
      hello.data.HelloCard card = service.SayHello(person);
      result = card.Greeting;
    }
    catch (System.ServiceModel.FaultException fault) 
    { 
      result = fault.Message; 
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Compilamos los archivos del proxy y el cliente, y ejecutamos Client.exe como hasta ahora.

Nota: Además de DataContractSerializer, WCF también admite (de forma excluyente) la clase XmlSerializer, que es el mismo mecanismo de serialización utilizado en Servicios Web ASP.NET (aka ASMX). Aunque XmlSerializer solo admite un conjunto reducido de tipos, permite un mayor control sobre el XML resultante y admite mejor la norma de XSD. Para más información consulte Utilización de XMLSerializer.

WCF bajo contrato (1/4)

vbpuntonet — Wed, 02 Jul 2008 21:01:18 GMT

Como continuación al artículo Servicios Web con WCF: Una sencilla introducción a Servicios Web con WCF, la presente serie abordará de manera sencilla los principales tipos de contratos que se emplean para definir los Servicios de WCF. La finalidad es dar una introducción práctica a los mismos, sin pretender ser exhaustivo. Así que partiendo del servicio Hello del artículo anterior, comencemos por el Contrato de Servicio.

Contrato de Servicio

Un contrato de servicio permite la comunicación con el mismo, al proporcionar la siguiente información:

Listado de las operaciones que ofrece y la ubicación de las mismas
Firma de las operaciones, en términos de intercambio de mensajes
Tipos de datos empleados en los mensajes.
Protocolos concretos y formatos de serialización.

Para esto se utilizan los documentos WSDL y XSD, que son lenguajes estándar para describir servicios web. No obstante WSDL y XSD son difíciles de utilizar, por ello las aplicaciones WCF utilizan atributos, interfaces y clases para definir la estructura de un servicio e implementar un servicio.

En el artículo anterior se define el contrato del servicio utilizando la clase de implementación del mismo. Sin embargo es recomendable utilizar una interfaz para ello, ya que, al igual que un contrato de servicios, las interfaces solo definen la agrupación de métodos (operaciones) con ciertas firmas sin especificar ningún detalle sobre su implementación. Además, todas las ventajas de las interfaces administradas se aplican a las interfaces de contrato de servicio:

Las interfaces pueden extender cualquier número de interfaces.
Una única clase puede implementar cualquier número de interfaces.
Puede modificar la implementación de una interfaz, mientras la interfaz siga siendo la misma.

Por lo que adicionalmente se puede controlar la versión del servicio implementando la interfaz antigua y la nueva. Los clientes antiguos se conectan a la versión original, mientras los clientes más nuevos pueden conectarse a la versión más nueva.

Así que, tras realizar refactoring al Servicio WCF Hello, el contrato y su implementación ahora quedan de la siguiente forma:

Listado de Hello.cs

using System;
using System.Text;
using System.ServiceModel;

namespace hello
{  

  [ServiceContract(Namespace="http://hello/")]
  interface IHello
  {
    [OperationContract()]
    string SayHello(string name);
  }
    
  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")]    
  public class Hello : IHello
  {
    private StringBuilder message = new StringBuilder("Hola ");

    public string SayHello(string name)
    {
      if (name == null || name.Length == 0)
        throw new FaultException("Parámetro 'name' nulo o vacío.");
      string msg = message.Append(name + "!").ToString();
      System.Console.WriteLine(msg);
      return msg;
    }
  }
}

Observe que ahora los atributos ServiceContract y OperationContract se aplican a la interfaz, y que a la clase de implementación sólo se la aplica el atributo ServiceBehavior. Recuerde que los dos primeros atributos definen el contrato del servicio y sus operaciones, mientras que el tercero define comportamientos concretos de la implementación. En el ejemplo los utilizamos para marcar las responsabilidades de cada una, así como el namespace a utilizar en la exportación hacia el WSDL.

Tras compilar el servicio:

>csc /t:library Hello.cs /r:System.ServiceModel.dll

Continuamos con el host. El código de HelloHost.cs permanece sin cambios, pero tenemos que hacer un ligero cambio al archivo de configuración HelloHost.exe.config, de modo ahora el atributo contract del endpoint señale a la interfaz:

Listado de HelloHost.exe.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="hello.Hello" behaviorConfiguration="enableMetadata">
        <endpoint contract="hello.IHello" binding="basicHttpBinding" address="" 
            bindingNamespace="http://hello/" name="HelloPort" />
        <endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="enableMetadata" >
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Tras ejecutar el host:

>HelloHost.exe

El Servicio Web Hello se esta ejecutando...
WSDL: http://localhost:8080/Hello?wsdl
Presione una tecla para cerrarlo.

Ahora vamos con el cliente. Primero debemos regenerar los artefactos cliente con svcutil:

>svcutil http://localhost:8080/hello?wsdl /out:Hello.cs /config:Client.exe.config /n:http://hello/,hello

Después modificamos una línea del código de la aplicación cliente:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    String arg = null;
    String result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anónimo";
    }
    try {      
      hello.IHello service = new hello.HelloClient();
      result = service.SayHello(arg);
    }
    catch (System.ServiceModel.FaultException fault) 
    { 
      result = fault.Message; 
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Compilamos tanto el proxy como la aplicación:

>csc /t:library Hello.cs /r:System.ServiceModel.dll

>csc /t:exe Client.cs /r:System.ServiceModel.dll,Hello.dll

Y la ejecución será la misma que la última vez:

>Client Willy

Hola Willy.

Creando clientes para el Servicio WCF

vbpuntonet — Sat, 21 Jun 2008 13:01:51 GMT

Creando un sencillo Cliente WCF

Como continuación de: Creando un sencillo Servicio Web WCF, crearemos —en un directorio/proyecto distinto— el cliente para nuestro Servicio Web el cual debe estar publicado y en ejecución.

Pero primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta svcutil (Herramienta de utilidad de metadatos de ServiceModel) incluida en el Windows SDK for .NET Framework 3.x, a la cual le pasamos como argumento la ubicación del documento WSDL:

>svcutil http://localhost:8080/hello?wsdl /out:Hello.cs /config:Client.exe.config /n:http://hello/,hello

Esto generará un archivo con la clases proxy las cuales encapsularán la invocación de las operaciones del Servicios Web. En nuestro caso se generará el archivo Hello.cs (con la clase HelloClient que utilizaremos directamente en la aplicación cliente) así como el archivo de configuración Client.exe.config, de modo que coincida con el nombre del ejecutable de la aplicación cliente.

Una vez generados los artefactos cliente (proxy) solo resta crear la aplicación cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.cs

using System;

public class Client
{
  static void Main(string[] args)
  {
    string arg = null;
    string result = null;
    if (args.Length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anónimo";
    }
    try {
      hello.HelloClient service = new hello.HelloClient(); 
      result = service.SayHello(arg);
    }
    catch (System.ServiceModel.FaultException fault) 
    { 
      result = fault.Message; 
    }
    catch (Exception ex) {
      result = ex.ToString();
    }
    finally{
      System.Console.WriteLine(result);
    }
  }
}

Nótese que para invocar la operación de nuestro Servicio Web primero creamos una instancia de la clase HelloClient (generada por svcutil) por medio de la cual después invocamos al método SayHello —y tras del cual se invoca la operación del Servicio Web, el cual a su vez invoca el método correspondiente de la clase Hello implementada al inicio del artículo...

Solo resta compilar tanto el proxy como la aplicación cliente:

>csc /t:library Hello.cs

>csc /t:exe Client.cs /r:Hello.dll

Después ejecute la aplicación cliente con algún argumento, su nombre por ejemplo, si no se especifica argumento alguno la salida será "Hola Anónimo":

>Client Willy

Hola Willy!

La misma salida se desplegará en la consola del servicio.

Creando un sencillo Cliente Java

Como ejercicio final crearemos un cliente Java (utilizando JAX-WS) para el Servicio Web, el cual es prácticamente el mismo cliente del artículo Servicios Web con Java SE 6.0.

Primero necesitamos generar los artefactos cliente. Para ello utilizaremos la herramienta wsimport incluida en Java SE 6.0, a la cual le pasamos como argumento la ubicación del documento WSDL:

>wsimport http://localhost:8080/hello?wsdl

Una vez generados los artefactos cliente solo resta crear el cliente en sí, nuevamente una simple aplicación de consola:

Listado de Client.java

public class Client {
  public static void main(String[] args) {
    String arg = null;
    String result = null;
    if (args.length > 0) {
      arg = args[0];
    }
    else {
      arg = "Anonimo";
    }
    try {
      hello.HelloService service = new hello.HelloService();
      hello.Hello port = service.getHelloPort();
      result = port.sayHello(arg);
    }
    catch (Exception ex) {
      result = ex.toString();
    }
    finally{
      System.out.println(result);
    }
  }
}

Tal como puede apreciarse, la razón para nombrar al servicio como HelloService y su endpoint como HelloPort fue para que coincidiera con el Servicio Web elaborado en Java en el artículo anteriorermte citado y así se pudiese reutilizar el código del cliente. No obstante de no haberlo hecho el código del cliente cambiaría en algo como:

hello.Hello_Service service = new hello.Hello_Service();
hello.Hello port = service.getBasicHttpBindingHello();

Finalmente compilamos y ejecutamos nuestro cliente con algún argumento:

>javac Client.java

>java Client Java

Hola Java!

La misma salida se desplegará en la consola del servicio.

Fuente: Servicios Web con WCF.

Creando un sencillo Servicio Web WCF

vbpuntonet — Sat, 21 Jun 2008 12:03:31 GMT

Para ilustrar la creación de Servicio con WCF emplearemos el clásico ejemplo de Hola Mundo, el cual luce así:

Listado de Hello.cs

using System;
using System.Text;
using System.ServiceModel;

namespace hello
{
  [ServiceContract(Namespace="http://hello/")]
  [ServiceBehavior(Namespace="http://hello/", Name="HelloService")]
  public class Hello
  {
    private StringBuilder message = new StringBuilder("Hola ");

    [OperationContract]
    public string SayHello(string name)
    {
      if (name == null || name.Length == 0)
        throw new FaultException("El parámetro 'name' es nulo o vacío.");
      string msg = message.Append(name + "!").ToString();
      System.Console.WriteLine(msg);
      return msg;
    }
  }
}

Nota: La parte del código en color oliva puede omitirse para simplicidad del ejemplo, no obstante sirve de introducción al tema de excepciones en servicios web.

Nótese que luce como una clase normal pero con algunas adiciones: En primer lugar declaramos la utilización del namespace System.ServiceModel dentro del cual se encuentran las clases atributo con las cuales marcamos la clase Hello como el contrato del servicio (atributo ServiceContract) y al método SayHellocomo una operación del mismo (atributo OperationContract). Con esto habilitamos la clase para que pueda ser consumida como un Servicio WCF el cual posteriormente publicaremos como un Servicio Web. Finalmente el atributo ServiceBehavior especifica el comportamiento de ejecución de una implementación del contrato de servicio, es éste caso sólo lo empleamos para especificar lo que será el "targetNamespace" y "name" del servicio para la exportación de la definición del mismo a través de WSDL.

Solo resta compilar la clase, asegurándonos de referenciar al ensamblado System.ServiceModel.dll:

>csc /t:library Hello.cs /r:System.ServiceModel.dll

Con lo anterior ya tenemos un sencillo Servicio WCF casi listo para ser alojado y desplegado como un Servicio Web dentro de un Sitio Web ASP.NET, no obstante podemos probarlo sin necesidad de recurrir a IIS (o Cassini) si creamos un Endpoint dentro de una aplicación de consola que actuará como host del servicio, tal como se ilustra en el siguiente código:

Nota: Para revisar otras opciones de "alojamiento" de servicios WCF consultar: Alojando Servicios.

Listado de HelloHost.cs

using System;
using System.ServiceModel;

class HelloHost
{
  static void Main(string[] args)
  {
    string endpointAddress = "http://localhost:8080/hello";
    ServiceHost myServiceHost = 
      new ServiceHost(typeof(hello.Hello), new Uri(endpointAddress));
    myServiceHost.Open();
    System.Console.WriteLine("El Servicio Web Hello se está ejecutando...");
    System.Console.WriteLine("WSDL: " + endpointAddress + "?wsdl");
    System.Console.WriteLine("Presione una tecla para cerrarlo.");
    System.Console.ReadKey();
    if (myServiceHost.State != CommunicationState.Closed)
      myServiceHost.Close();
  }
}

Nótese que se trata de una simple aplicación de consola que utiliza una instancia de la clase ServiceHost para crear un endpoint para un servicio de tipo HelloService.Hello en la dirección (Address) http://localhost:8080/Hello. Esto último gracias a que la clase ServiceHost utiliza la información proporcionada tanto en el código como en el archivo de configuración —que veremos a continuación— para crear y publicar un ServiceEndpoint.

Por lo que el siguiente paso es crear el archivo de configuración (que se vinculará al ejecutable de HelloHost) con el siguiente contenido:

Listado de HelloHost.exe.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="hello.Hello" behaviorConfiguration="enableMetadata">
        <endpoint contract="hello.Hello" binding="basicHttpBinding" 
                bindingNamespace="http://hello/" name="HelloPort" />
        <endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="enableMetadata" >
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Observe que en éste caso la clase hello.Hello sirve tanto para definir la clase de implementación del servicio como su contrato, es por ello que aparece tanto en el atributo name del elemento service, como en el atributo contract del elemento endpoint. En un artículo posterior veremos que esto se puede realizar de forma separada utilizando una interfaz como contrato.

Lo siguiente a destacar es la línea:

<endpoint contract="hello.Hello" binding="basicHttpBinding" ... />

En la cual se especifica tanto la clase/interfaz que define al servicio (Contract), así como la forma de enlace (Binding) con el endpoint, cuya ubicación en la red (Address) se definió en el código de HelloHost. Estos tres elementos: Address, Binding & Contract, constituyen el ABC de los Endpoints de WCF. Para más información al respecto consultar: Endpoints: Address, Bindings and Contracts.

El enlace de tipo basicHttpBinding representa la forma de enlace que el servicio WCF utiliza para configurar y exponer su correspondiente endpoint de modo que el servicio pueda comunicarse como un Servicio Web (basado en ASMX) que cumple con el WS-I Basic Profile 1.1.

Los atributos del endpoint bindingNamespace y name sirven para especificar el "targetNamespace" y "name" del enlace para la definición a través de WSDL.

Nota: El resto de la configuración (de color oliva) sirve para habilitar la exposición de los Metadatos del servicio, de modo que se pueda tener acceso al WSDL generado bajo demanda. No es necesaria para poder consumir el servicio, por lo que si se facilita el WSDL por otra vía bien podría omitirse dicha configuración extra.

Una vez elaborado el archivo de configuración solo resta compilar y ejecutar HelloHost, el cual mostrará unas líneas indicando que el servicio se está ejecutando, así como la ubicación del documento WSDL del mismo para cualquier cliente que desee consumirlo.

>csc /t:exe HelloHost.cs /r:System.ServiceModel.dll,Hello.dll

>HelloHost.exe

El Servicio Web Hello se esta ejecutando...
WSDL: http://localhost:8080/hello?wsdl
Presione una tecla para cerrarlo.

Nota: Se requiere de una cuenta con privilegios de Administrador para ejecutar el host, o bien para modificar los derechos de la reserva para una parte del espacio de nombres HTTP. Para más información consulte: Configuración de los elementos de enlace de transporte HTTP y HTTPS para WCF.

Lo siguiente a realizar, es crear un cliente que lo consuma...

Fuente: Servicios Web con WCF.

SQL Server 2008 RC

vbpuntonet — Fri, 13 Jun 2008 02:00:15 GMT

A comenzado la saga RC de SQL Server 2008, el RTM se acerca...

SQL Server 2008 Express RC0: edición funcional ideal para aprender y ejecutar aplicaciones de base de datos de escritorio y de servidor a pequeña escala. SQL Server 2008 Express admite 1 CPU, 1 GB de RAM y bases de datos de hasta 4 GB.

Ejecute el archivo de descarga para copiar los archivos de instalación en el directorio Temp. La instalación comenzará una vez se haya completado la extracción. No es necesario buscar e iniciar setup.exe manualmente.

SQL Server 2008 Express Advanced RC0: edición Express que además incluye una plataforma básica de informes y administración de datos con funcionalidad completa.

Tanto el formato de archivo de descarga como el inicio del proceso de instalación son idénticos para SQL Express.

SQL Server 2008 RC0: versión de prueba para crear y probar cualquier tipo de aplicación. Incluye toda la funcionalidad de SQL Server 2008 Enterprise, pero sólo está autorizado para el uso de desarrollo, prueba y demostración.

Ejecute el archivo de descarga. En el símbolo del sistema, seleccione un directorio y pulse Siguiente. Una vez finalizado el paso de extracción automática, busque y haga doble clic en Setup.exe en el directorio seleccionado para comenzar la instalación.

Además de SQL Server Evaluation, puede probar las ediciones Standard y Enterprise, para ello especifique la clave del producto correspondiente para desbloquear la edición que desea.

Más información en: SQL Server 2008 Release Candidate 0.

Silverlight 2 Beta 2

vbpuntonet — Sat, 07 Jun 2008 22:00:32 GMT

Microsoft ha liberado la segunda beta pública de Silverlight 2.

¿Que es Silverlight?

Silverlight (antes WPF/E) es una nueva tecnología de presentación Web propuesta por Microsoft, creada para su ejecución en distintos browser HTTP y en múltiples dispositivos y sistemas operativos de escritorio. Al igual que WPF (Windows Presentation Foundation), la tecnología de presentación en Microsoft .NET Framework 3.0: XAML (eXtensible Application Markup Language), constituye la base de la capacidad de presentación de Silverlight.
Parafraseado de Introducción a Silverlight.

Algunas características de Siverlight 2 Beta 2:

Soporte de lenguajes .NET: VB.NET, C#, Iron Python e IronRuby
Nuevo conjunto de controles (Button, ListBox, Slider, CheckBox, DataGrid, Calendar, TabPanel, etc.)
Edición de plantilla de controles
VSM (Visual State Manager)
Caching cliente
Soporte para WCF
Programación XML
LINQ to XML y LINQ to Objects
ADO.NET Data Services
Tecnología Deep Zoom

Descargas:

Mayor información:

Guía de Seguridad WCF (Beta)

vbpuntonet — Sat, 07 Jun 2008 21:35:04 GMT

El equipo de patterns & practices ha publicado la versión beta de su guía de seguridad en Servicios Web titulada:

Improving Web Services Security: Scenarios and Implementation Guidance for WCF

En la cual se muestra cómo mejorar la seguridad de WCF mediante escenarios, guías directivas, Preguntas & Respuestas, listados Como-Se-Hace, etc... La guía está relacionada con el proyecto de seguridad: WCF Security Guidance Project.

Mayor información y descarga de la guía en:

WCF Web Services Security Guide.

Velocidad de datos

vbpuntonet — Sat, 07 Jun 2008 21:30:22 GMT

El equipo de Datos de Microsoft se encuentra trabajando en un proyecto de caching llamado "Velocity" del cual ya ha publicado el primer CTP. Pretenden que el producto resultante del proyecto sea una plataforma de caché en memoria que proporcione a las aplicaciones .NET el acceso a datos a alta velocidad, de forma escalable y con alta disponibilidad.

Principales características:

Almacenamiento de cualquier objeto CLR serializable y acceso mediante APIs simples
Caché de alto desempeño para todas la aplicaciones de datos
Ejecución tanto como servicio de red como embebido en aplicaciones
Soporte para las configuraciones más comunes de caché
Escalamiento dinámico
Balanceo de carga automático
Compatibilidad con ASP.NET e IIS.
Alta disponibilidad al mantener copias de datos en múltiples nodos
Soporte de múltiples lenguajes del lado cliente (PHP, C#, C++, etc.)

Para mayor información visitar:

Liberados EntLib 4.0 y Unity AB 1.1

vbpuntonet — Sat, 17 May 2008 00:00:56 GMT

El grupo de patterns & practices de Microsoft acaba de liberar la versión final de Enterprise Library 4.0 ( Mayo 2008 ) el cual, además de la integración con VS2008 y algunas mejoras de los Application Block existentes en la versión previa, incorpora el nuevo Unity Application Block. Unity también puede descargarse de forma independiente del EntLib4 y utilizarse tanto con VS2005 como con VS2008 -a diferencia del EntLib4 que sólo funciona con VS2008.

¿Que es Enterprise Library?

Es una colección de componentes de software reutilizables (llamados "Applicaction Block") y guías de buenas prácticas, diseñados para asistir a los desarrolladores en los retos más comunes del desarrollo empresarial. Los AB son configurables (mediante archivos de configuración .config) y pueden funcionar de forma independiente o colaborando entre sí.

¿Que es Unity Application Block?

Es un Contenedor de Inyección de Dependencias ligero y extensible, el cual facilita la construcción de aplicaciones débilmente acopladas y proporciona a los desarrolladores las siguientes ventajas:

Simplifica la creación de objetos, especialmente con dependencias y estructuras jerárquicas.

Especificación de las dependencias en tiempo de ejecución o vía configuración.

Aplazamiento de la configuración de componentes en el contenedor.

Capacidad de localización de servicios.

Mayor información y descarga en:

Enterprise Library 4.0
Download Enterprise Library 4.0 (incluye Unity AB)
Unity Application Block 1.1
Download Unity Application Block 1.1

Heroes {On-Line}

vbpuntonet — Mon, 28 Apr 2008 05:00:00 GMT

El día de mañana Microsoft Latinoamérica llevará a cabo el evento On-Line Microsoft Technet & MSDN Briefing, Edición Especial de {Lanzamiento} de los productos: Windows Server 2008, SQL Server 2008 y Visual Studio 2008.

Extensibilidad de Visual Studio
C# 3 y LINQ
Clientes ricos y conectados
Desarrollo con Office
Silverlight 2.0
Sindication Integration WCF & WF
Desarrollo Web
QA con Team System
SQL Server 2008 Alta Disponibilidad
SQL Server 2008 Manageability
Virtualization Technologies
Window IT Pros Seguridad
Windows Server 2008 Overview
Windows Server and Vista Solid Enterprise
Windows Server Web

Registro en el sitio del evento:
www.microsoft.com/latam/lanzamientoedicionespecial2008/

HEROES

vbpuntonet — Sat, 05 Apr 2008 19:00:00 GMT

Como sabrán, el tema de la ola de lanzamientos 2008 de los productos Microsoft: Windows Server, SQL Server y Visual Studio, es el de HEROES —inspirado en una serie de ficción al estilo de Stan Lee, pero ahora sin trajes...

En Latinoamérica el tema se ha dirigido hacia los “héroes locales”, así pues el tema en México es la “Lucha Libre”, siendo el Hijo del Santo el invitado de honor al evento de lanzamiento, acompañado de un show de Lucha al final del mismo. La cita es el próximo 17 de abril en el WTC de la ciudad de México. Mayor información y registro en: HEROES {mexicanos}.

Al día siguiente se llevará a cabo un evento similar por parte de la Comunidad Ineta Puebla.NET, en el Tec de Monterrey campus Puebla. No habrá luchadores, mas la agenda del evento lo hace interesante: HEROES {Puebla.NET}.

Para finalizar, dejo el vínculo de la página donde se encuentran publicados los manuales para llevar a cabo los laboratorios de los eventos de lanzamiento: HEROES happen {here} – Hand On Labs Manuals.

Service Factory para VS2008

vbpuntonet — Fri, 29 Feb 2008 21:00:01 GMT

El equipo de p&p ha publicado el Service Factory para Visual Studio 2008.

El Web Service Software Factory: Modeling Edition (Fábrica de Software para Servicios Web: Edición de Modelado) —también conocida como Service Factory— es una colección integrada de recursos diseñada para ayudarnos a construir rápida y consistentemente Servicios Web WCF y ASMX que se adhieren a los bien-conocidos patrones de diseño y arquitectura. Estos recursos consistentes en modelos con generación de código en forma de herramientas que se integran con Visual Studio 2008 y temas sobre patrones y arquitectura en forma de guías directivas.

Service Factory contiene automatización y directivas integradas dentro de Visual Studio 2008 para la construcción de servicios. El núcleo de los componentes de automatización es un modelo de dominio para Servicios Web. Este modelo de dominio contiene elementos tales como los contratos de servicios, operaciones, mensajes y contratos de datos. Este modelo de dominio se manifiesta en la forma de tres lenguajes de específicos-al-dominio (DSLs) integrados que se utilizan para modelar servicios: Modelo de Contrato de Servicio, Modelo de Contrato de Datos, y el Modelo de Host.

Además de las facilidades de automatización en Visual Studio, Service Factory también contiene las directrices relevantes sobre la construcción de servicios Web —mucha de ésta documentación viene del release de Diciembre de 2006. Algunos de éstos temas incluyen arquitectura, diseño de mensajes, versionamiento, manejo de excepciones, y otros patrones útiles. Para ver la lista completa de temas que se incluyen, vea la sección Web Service Architecture en la documentación incluida con Service Factory.

Mayor información y descarga:

Para obtener más información sobre Service Factory, por favor, consulte la página oficial de Service Factory en MSDN, además de los recursos en el sitio de la comunidad
Para descargar la versión binaria, puede utilizar este enlace directo a la descarga del Service Factory
También puede descargar el código fuente del Service Factory desde MSDN
En el sitio de la comunidad también puede encontrar la versión que trabaja con Visual Studio 2005 liberada el año pasado

VS 2008 Web-Dev Hot-Fix

vbpuntonet — Sun, 10 Feb 2008 04:26:31 GMT

Microsoft a publicado un parche que corrige algunos problemas reportados en VS 2008 y VS 2008 Developer Express en escenarios Web.

Descargar disponible en connect.microsoft.com.

Para mayor información sobre el parche, incluyendo la lista de errores que corrige, leer: VS 2008 Web Development Hot-Fix Roll-Up Available.