sábado, 26 de enero de 2013

WCF ChannelFactory<T>. Cómo simplificar la creación de clientes WCF.

En el artículo anterior vimos como usar

ChannelFactory

para crear un cliente

WCF

, hoy veremos un ejemplo sobre como crear nuestra clase "proxy" que podría servirnos para simplificar la creación de clientes

WCF

y no complicar la vida a los miembros del equipo que trabajen en presentación.

En el mismo proyecto AreaTIC.Client crearemos un clase AreaTicWCFProxy que implemente la interfaz

ICommunicationObject

y que en el constructor simplemente obligue a pasar el nombre del servicio al creador, dentro ya implementaríamos todo el tema de bindings, seguridad y demás aspectos configurables del cliente. Veamos un ejemplo que se podría ir complicando en función de las características de cada arquitectura.
using System.ServiceModel;

namespace AreaTIC.Shared
{
 public class AreaTicWCFProxy:ICommunicationObject
 {
   private ChannelFactory mfactory = null;

   public AreaTicWCFProxy(string Address)
   {
     //definimos binding.
     WSHttpBinding binding = new WSHttpBinding(SecurityMode.None);

     //definimos endpoint 
     EndpointAddress endPoint = new EndpointAddress(string.Format("http://localhost:8080/Services/{0}",Address));

     //definimos factory y creamos canal.
     mfactory = new ChannelFactory(binding, endPoint);

     mfactory.Open();
    }

    public T client 
    {
      get { return mfactory.CreateChannel(); }
    }

    void ICommunicationObject.Abort()
    {
      mfactory.Abort();
    }

    IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
    {
      throw new NotImplementedException();
    }

    IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
    {
       throw new NotImplementedException();
    }

    IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
    {
       throw new NotImplementedException();
    }

    IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
    {
       throw new NotImplementedException();
    }

    void ICommunicationObject.Close(TimeSpan timeout)
    {
       mfactory.Close(timeout);
    }

    void ICommunicationObject.Close()
    {
       mfactory.Close();
    }

    event EventHandler ICommunicationObject.Closed
    {
       add { throw new NotImplementedException(); }
       remove { throw new NotImplementedException(); }
    }

    event EventHandler ICommunicationObject.Closing
    {
       add { throw new NotImplementedException(); }
       remove { throw new NotImplementedException(); }
    }

    void ICommunicationObject.EndClose(IAsyncResult result)
    {
       throw new NotImplementedException();
    }

    void ICommunicationObject.EndOpen(IAsyncResult result)
    {
       throw new NotImplementedException();
    }

    event EventHandler ICommunicationObject.Faulted
    {
       add { throw new NotImplementedException(); }
       remove { throw new NotImplementedException(); }
    }

    void ICommunicationObject.Open(TimeSpan timeout)
    {
       mfactory.Open(timeout);
    }

    void ICommunicationObject.Open()
    {
       mfactory.Open();
    }

    event EventHandler ICommunicationObject.Opened
    {
       add { throw new NotImplementedException(); }
       remove { throw new NotImplementedException(); }
    }

    event EventHandler ICommunicationObject.Opening
    {
       add { throw new NotImplementedException(); }
       remove { throw new NotImplementedException(); }
    }

    CommunicationState ICommunicationObject.State
    {
       get { return mfactory.State; }
    }
  }
}
Si os fijáis en fragmento de código hemos definido un atributo privado

ChannelFactory

y a partir de los parámetro que recibimos en el constructor de nuestra clase configuraríamos el canal.

El resto son métodos que obliga a implementar la interfaz

ICommunicationObject

, en este caso no he implementado el tema de asíncronos ni los eventos... Implementamos los básicos Open, Close (...) para gestionar el canal.

Para conectar al servicio que levantamos en el artículo anterior el código sería tan simple como esto:
using AreaTIC.Shared.ServiceContracts;
using AreaTIC.Shared.DataContracts;
using AreaTIC.Shared;

namespace AreaTIC.Client
{
 class Program
 {
   static void Main(string[] args)
   {
    string result = new AreaTicWCFProxy("EjemploAreaTIC").client.FuncionEjemplo(new Tipo1());
    Console.Write(result);
    Console.ReadLine();
   }
 }
}
Si queremos conectar con otro servicio y disponemos de la interfaz simplemente tendríamos que sustituir la interfaz en la llamada de modo que la misma clase proxy nos serviría para conectar a todos los servicios que tengamos en nuestro servidor de negocio.

Ya de cara al siguiente artículo veríamos como implementar el tema de asíncronos. Recordaros que podéis seguir

areaTIC

en las redes sociales, esperamos vuestra participación!


No hay comentarios:

Publicar un comentario en la entrada