Return(GiS); : WCF

Could not load type 'System.ServiceModel.Activation.HttpModule' from assembly 'System.ServiceModel, Version=3.0.0.0 [...]

Gisela — Tue, 27 Apr 2010 06:55:00 GMT

Uno de los incidentes que nos podemos encontrar al tener instalado el nuevo Framework 4.0 es que nuestras aplicaciones con WCF anteriores dejen de funcionar por el siguiente motivo:

Para solucionarlo, debemos acceder al servidor de aplicaciones (IIS), nos posicionamos en el sitio que nos está fallando y accedemos al apartado de Módulos:

Una vez allí, quitamos la versión 3.0 de ServiceModel, quedando únicamente la versión 4.0.

Espero que sea de utilidad.

¡Saludos!

InstanceContextMode en WCF

Gisela — Sat, 19 Dec 2009 21:47:00 GMT

Cuando creamos un servicio con Windows Communication Foundation, debemos conocer el comportamiento que queremos que tenga en cuanto a sus instancias se refiere. Para controlar el tiempo de vida del contexto disponemos de los siguientes modos:

PerCall: Cada cliente creará una nueva instancia por llamada al servicio.
PerSession: Se genera una instancia por sesión.
Single: Se utiliza la misma instancia para todas las peticiones independientemente del cliente.

Como he encontrado mucha literatura al respecto y los ejemplos han sido prácticamente el mismo en todos los sitios, he creado uno personalizado donde se realiza el envío de tweets e intento recuperar los mismos utilizando los distintos modos.
Creo un proyecto de tipo WCF Service Library:

Elimino tanto la clase y la interfaz generada por la plantilla y creo una clase Tweet.cs con el rol de DataContract.

using System.Runtime.Serialization;

namespace InstanceContextModeWCF
{
    [DataContract]
    public class Tweet
    {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string User { get; set; }
        [DataMember]
        public string Message { get; set; }
    }
}

Una interfaz como ServiceContract

using System.Collections.Generic;
using System.ServiceModel;

namespace InstanceContextModeWCF
{
    [ServiceContract]
    public interface ITwitter
    {
        [OperationContract]
        void SendTweet(Tweet tweet);

        [OperationContract]
        List<Tweet> GetMyTweets();
    }
}

Y por último la clase que implementa nuestro contrato.

using System.Collections.Generic;
using System.ServiceModel;

namespace InstanceContextModeWCF
{
    //[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    //[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    //[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class Twitter : ITwitter
    {
        private readonly List<Tweet> _tweets = new List<Tweet>();

        public void SendTweet(Tweet tweet)
        {
            _tweets.Add(tweet);
        }

        public List<Tweet> GetMyTweets()
        {
            return _tweets;
        }
    }
}

En la clase Twitter he dejado comentadas las tres posibilidades. ¡Veamos cada una de ellas!

PER CALL

Cuando activamos el modo PerCall nuestro servicio se comportará de la siguiente manera: Creará una instancia para realizar la llamada al método solicitado y, una vez que haya finalizado la llamada, destruirá la instancia creada.

Para este primer ejemplo he activado la primera línea comentada y he seguido los pasos en el orden que señalo en la imagen. Como podemos ver, he creado una conexión con el programa que está actuando como servidor, he rellenado el apartado de mensaje y he enviado el mismo. En este caso, no ha sido posible recuperar el tweet al realizar una nueva llamada con PerCall.

PER SESSION

Con PerSession vamos a utilizar la misma instancia hasta que la sesión finalice. Es decir, un cliente crea un canal y tiene la posibilidad de realizar distintas llamadas a distintos métodos dentro del mismo contexto. Siguiendo el mismo ejemplo, habilitando la segunda línea y deshabilitando la primera, realizamos las mismas acciones desde el cliente.

Como la instancia permanece con vida durante toda la sesión, el cliente es capaz de poder enviar un tweet y después recuperarlo. Sin embargo, si nosotros pulsamos sobre Disconnect e intentamos recuperar el tweet enviado a través del botón Get All!, la información ya habrá desaparecido al haber creado una nueva sesión.

private void btnConnect_Click(object sender, EventArgs e)
{
    _channel = new ChannelFactory<ITwitter>("TwitterService");
    _client = _channel.CreateChannel();
    lblState.Text = "Connected!";
    lblState.ForeColor = System.Drawing.Color.Blue;
}

private void btnDisconnect_Click(object sender, EventArgs e)
{
    _channel.Close();
    lblState.Text = "Disconnected!";
    lblState.ForeColor = System.Drawing.Color.Red;
}

SINGLE

El modo Single se utiliza para mantener una misma instancia desde la primera petición de un cliente cualquiera hasta que el servicio se ha parado completamente.

Si habilitamos el último modo comentado en el código, y deshabilitamos el anterior, podemos realizar los siguientes pasos:

Si cerramos y abrimos de nuevo el cliente, sin cerrar el programa servidor, y pulsamos de nuevo en Get All! descubrimos que nuestro tweet sigue con vida ;)

Adjunto el ejemplo completo, con el servicio, cliente y servidor. Están los tres proyectos en una misma solución. En cualquier caso, podemos abrir los .exe ubicados en el bin de cada proyecto como administrador o abrir dos Visual Studio con credenciales de administrador para poder debuggear en Vista o Windows 7 =)

¡Saludos!

Cliente JSON para WCF

Gisela — Fri, 30 Oct 2009 08:26:00 GMT

En un post anterior, mostré como crear un servicio web con Windows Communication Foundation. Para consumir el mismo, vamos a crear un pequeño cliente JSON con JQuery.
Creamos un proyecto ASP.NET Web Application:

Antes de comenzar con nuestro código, necesitamos la librería de JQuery, la cual podemos obtenerla en este enlace. Una vez descargada, agregamos el archivo a nuestra solución.
Por otro lado, vamos a crear un nuevo archivo JScript, llamado JSON.js, donde implementaremos la funcionalidad que llamará a nuestro servicio y recogerá el resultado. Nuestro proyecto quedaría de la siguiente manera:

He utilizado la página Default.aspx para mostrar dos textbox para recoger los valores y dos botones con los que llamaremos al servicio.

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="ClienteJSON._Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
  <title>Cliente JSON</title>
</head>
<body>
  <div id="Calculos">
    <div>
      <div>
        <label id="lblNumeroUno">
          Introduce número:</label>
        <input type="text" id="txtNumUno" />
      </div>
      <div>
        <label id="lblNumeroDos">
          Introduce otro número:</label>
        <input type="text" id="txtNumDos" />
      </div>
      <div>
        <input type="button" id="btnSumar" value="Sumar" />
        <input type="button" id="btnRestar" value="Restar" />
      </div>
    </div>
  </div>

  <script type="text/javascript" src="jquery-1.3.2.js"></script>  <script type="text/javascript" src="JSON.js"></script>


</body>
</html>

Por último, sólo nos quedaría llamar a nuestro servicio web y mostrar el resultado que nos aporta, en función de si queremos Sumar o Restar los número que introducimos a través de la interfaz. Abrimos el archivo JSON.js e introducimos lo siguiente:

$("#btnSumar").bind("click", function(e) {
 
  var params = { "a": $('#txtNumUno').val(), "b": $('#txtNumDos').val() };

  $.ajax({
      type: "GET",
      url: "http://localhost/WCF/Service.svc/json/Suma",
      data: params,
      contentType: "application/json; charset=utf-8",
      dataType: "json",
      success: function(msg) {
          alert("Resultado Suma: " + msg.d.Result);
      }
   });
});


$("#btnRestar").bind("click", function(e) {

  var params = { "a": $('#txtNumUno').val(), "b": $('#txtNumDos').val() };

  $.ajax({
      type: "GET",
      url: "http://localhost/WCF/Service.svc/json/Resta",
      data: params,
      contentType: "application/json; charset=utf-8",
      dataType: "json",
      success: function(msg) {
          alert("Resultado Resta: " + msg.d.Result);
      }
  });
});

La verdad es que, teniendo JQuery, es bastante simple realizar este tipo de funcionalidad. He utilizado el método Bind, para asignarles el evento a cada uno de nuestros botones. De esta manera, no tenemos que introducir ningún código de javascript en nuestro aspx. Más adelante me gustaría enfocarme más en la manera de funcionar de esta librería.

En el mismo sitio donde bindeamos el evento click a nuestro botón, creamos la función que se va a ejecutar.
Utilizamos la variable params para montar nuestra cadena de parámetros. Hay que tener en cuenta que el nombre de cada parámetro se debe corresponder con el que tienen en el servicio web (en este caso a y b).
Creamos un objeto ajax con los atributos type (el tipo de HTTP Verb que vamos a utilizar), la url donde se aloja nuestro servicio, seguido del método que vamos a invocar, en data le pasamos los parámetros necesarios para el cálculo solicitado, contentType indica cómo va a evaluar JQuery la respuesta y cómo nos la va a devolver (En el caso de JSON evalúa la respuesta como tal y nos retorna un objeto javascript), dataType es el formato en el que estamos pasando nuestro parámetros y en la parte success se adjunta la función que se lanzará cuando haya terminado el proceso en caso de éxito. En un principio, esto es lo mínimo que debemos usar.

Si arrancamos la aplicación, ya tenemos nuestra Suma y nuestra Resta funcionando con un servicio web en WCF y su cliente en JSON.

¡Saludos!

Actualización 31/10/2009: En el archivo JSON.js, he modificado la forma de recuperar el valor de los textbox por .val(), que sería la forma correcta con JQuery. De la otra manera, $('#textbox')[0].value, era un híbrido que funciona exactamente igual, pero creo que queda más elegante con .val(). ¡Saludos!

Creando un Web Service con WCF

Gisela — Tue, 27 Oct 2009 08:41:00 GMT

Windows Communication Foundation fue una de las novedades de .NET Framework 3.0, la cual permite la creación de sistemas distribuidos orientados a servicios.
Con Visual Studio 2008, disponemos de una plantilla que nos genera todo lo necesario para empezar a trabajar con ello. No obstante, en esta ocasión, dejaremos de lado la misma para poder visualizar claramente qué es lo necesario para que WCF funcione.

CREACIÓN DEL PROYECTO

Creamos un nuevo proyecto de tipo librería:

Incluimos las librerías System.ServiceModel y System.Runtime.Serialization.

EL CONTRATO (CONTRACT)

Lo primero que debemos crear es una interfaz que tendrá como misión ser el Contrato del servicio web. Lo que nos indica el mismo es qué funcionalidades tiene operativas el servicio de cara a las aplicaciones que lo van a consumir.
Creamos una interfaz llamada IService.cs y codificamos las siguientes funcionalidades:

using System.ServiceModel;
using System.ServiceModel.Web;
using System.Runtime.Serialization;

namespace WCF
{
    [ServiceContract]
    public interface IService
    {
        [OperationContract]
        [WebGet]
        Resultado Suma(int a, int b);

        [OperationContract]
        [WebGet]
        Resultado Resta(int a, int b);
    }
   [DataContract]
    public class Resultado
   {
       [DataMember]
       public int Result { get; set; }
   }
}

Tenemos los siguientes atributos:

ServiceContract, el cual indica que nuestra interfaz va a hacer las veces de contrato.
OperationContract por cada método que queramos exponer.
Por último, dentro del mismo archivo (No es recomendable) hemos creado una pequeña clase con el atributo DataContract que será el objeto serializado que viajará como respuesta a las peticiones tanto de la Suma como la Resta. Por cada miembro dentro del contrato de datos, contiene un DataMember.

Es una clase perfectamente normal que contiene los métodos que definimos en el contrato. Si creamos código adicional, para realizar cualquier otra operación, no sería visible al no estar definido en la interfaz del servicio.

EL ARCHIVO SVC

Un archivo importante a tener muy en cuenta es el archivo con extensión svc, el cual erá de utilidad a IIS cuando publiquemos el servicio. Añadimos un documento en blanco, llamado Service.svc, con el siguiente contenido:

<%@ ServiceHost Service="WCF.Service" %>

Le indicamos el namespace de la implementación del contrato como valor de Service para que pueda localizarlo.

DLL FUERA DE DEBUG Y RELEASE

Para que IIS pueda localizar correctamente las librerías del servicio web, debemos cambiar las propiedades de Build en nuestro proyecto y dejar nuestro "Output path" de la siguiente forma:

Por último, quizás la parte más compleja, necesitamos configurar el archivo web.config con los endpoints necesarios para aceptar peticiones. Dependiendo de los distintos tipos de comunicacion que tengamos, deberemos implementar más o menos endpoints.

¿Qué es un Endpoint?

Un endpoint está compuesto por tres valores: Address (¿Dónde?), Binding (¿Cómo?) y Contract (¿Qué?). La suma de ellos genera una serie de requisitos para poder establecer una conexión con nuestro servidor. Un servicio con WCF puede disponder de varios endpoints distintos, por lo que el número de clientes de diferentes características pueden consumirlo.

Creamos pues un archivo Web.config y eliminamos el contenido. En este post, voy a crear un endpoint para un cliente JSON.

<?xml version="1.0"?>
<configuration>
<system.serviceModel>
    <bindings>
      <webHttpBinding>
        <binding name="webBinding">
        </binding>
      </webHttpBinding>
    </bindings>
    <services>
      <service name="WCF.Service"
               behaviorConfiguration="MiBehavior">
        <endpoint address="json"
                  binding="webHttpBinding"
                  bindingConfiguration="webBinding"
                  behaviorConfiguration="jsonBehavior"
                  contract="WCF.IService"/>
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="jsonBehavior">
          <enableWebScript/>
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="MiBehavior">
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="True"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
</system.serviceModel>
</configuration>

Dentro de la sección system.serviceModel tenemos:

Por un lado, la sección de los bidings disponibles, que en este caso sólo tenemos el necesario para una configuración de JSON; services donde indicamos el address, el nombre de nuestro binding, el behavior (indicado más abajo) y el nombre del contrato que queremos utilizar.

Llegados a este punto, podemos crear una aplicación que tenga hosteado el servicio que acabamos de crear o bien utilizar IIS, configurando como documento de inicio Service.svc.

IMPLEMENTACIÓN DEL CONTRATO

El siguiente paso es crear una clase que implemente el contrato que acabamos de definir.

namespace WCF
{
    public class Service : IService
    {
        public Resultado Suma(int a, int b)
        {
            var resultado = new Resultado {Result = a + b};
            return resultado;
        }

        public Resultado Resta(int a, int b)
        {
            var resultado = new Resultado {Result = a - b};
            return resultado;
        }
    }

}

Si accedemos a las dos direcciones que indico abajo a través del explorador, debería devolvernos un archivo en formato JSON por cada petición.

http://localhost/WCF/Service.svc/json/Suma

http://localhost/WCF/Service.svc/json/Resta

Ambas devolverían cero porque no se les está pasando ningún parámetro.
En el siguiente post de WCF, crearé un cliente que realice y reciba la respuesta con JSON para poder acceder a nuestro servicio web y pasarle los parámetros necesarios.

¡Saludos!