Creación de Servicio Web SOAP

En esta ocasión, veremos cómo crear un servicio SOAP en .NET utilizando Hibernate para conectarnos a una base de datos SQL Server.

Lo primero que haremos será crear un nuevo proyecto, luego buscar la opción Visual C#, seleccionar WCF y luego escoger la opción “Aplicación de servicios WCF” y colocar un nombre tal como se muestra en la siguiente imagen:

Cambiar de nombre al servicio “Service1.svc” que se crea por defecto. Para este ejemplo colocaremos el nombre “Clientes.svc”. De igual manera cambiaremos “IService1.cs” por “IClientes.cs”.

Agregar al proyecto las carpetas “Dominio” y “Persistencia”. Adicionar a la solución la carpeta “Librerias” la cual contendrá los archivos “Iesi.Collections.dll” y “NHibernate.dll”. Usar el explorador de Windows para ir a la carpeta donde se encuentra nuestro proyecto y crear una carpeta llamada "Librerias" que contenga los archivos que incluiremos en la librería, luego arrastrarlos hacia la carpeta “Librerias” que se encuentra en nuestra solución. Deberíamos tener una estructura como se muestra en la siguiente imagen:

Luego dentro de nuestro proyecto dar clic derecho sobre la opción “References” y escoger la opción “Agregar Referencia”. Escoger la pestaña “Examinar” y seleccionar los archivos que colocamos en la carpeta “Librerias”.

Ahora crearemos nuestra base de datos, la cual llamaremos BD_Tienda. Debería quedar de la siguiente manera:

Ahora crearemos la clase “Conexión.cs” dentro de la carpeta “Persistencia”. Con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace ClientesService.Persistencia
{
    public class Conexion
    {
        public static string Cadena()
        {
            return "Data Source=(local);Initial Catalog=BD_Tienda;Integrated Security=SSPI;";
        }
    }
}

Luego la clase “NHibernateHelper.cs” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NHibernate;
using NHibernate.Cfg;

namespace ClientesService.Persistencia
{
    public class NHibernateHelper
    {
        private static ISessionFactory _Fabrica;

        private static ISessionFactory Fabrica
        {
            get
            {
                if (_Fabrica == null)
                {
                    var _Conf = new Configuration();
                    _Conf.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
                    _Conf.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
                    _Conf.SetProperty("connection.connection_string", Conexion.Cadena());
                    _Conf.SetProperty("adonet.batch_size", "10");
                    _Conf.SetProperty("show_sql", "true");
                    _Conf.SetProperty("dialect", "NHibernate.Dialect.MsSql2000Dialect");
                    _Conf.SetProperty("command_timeout", "60");
                    _Conf.SetProperty("query.substitutions", "true 1, false 0, yes 'Y', no 'N'");
                    _Conf.AddAssembly(typeof(NHibernateHelper).Assembly);
                    _Fabrica = _Conf.BuildSessionFactory();
                }
                return _Fabrica;
            }
        }

        public static ISession ObtenerSession()
        {
            return Fabrica.OpenSession();
        }

        public static void CerrarFabrica()
        {
            _Fabrica = null;
        }
    }
}

Luego crear la clase “BaseDAO” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NHibernate;

namespace ClientesService.Persistencia
{
    public class BaseDAO<Entidad, Id>
    {
        public Entidad Crear(Entidad entidad)
        {
            using (ISession session = NHibernateHelper.ObtenerSession())
            {
                session.Save(entidad);
                session.Flush();
            }
            return entidad;
        }

        public Entidad Obtener(Id id)
        {
            using (ISession session = NHibernateHelper.ObtenerSession())
            {
                return session.Get<Entidad>(id);
            }
        }

        public Entidad Modificar(Entidad entidad)
        {
            using (ISession session = NHibernateHelper.ObtenerSession())
            {
                session.Update(entidad);
                session.Flush();
            }
            return entidad;
        }

        public void Eliminar(Entidad entidad)
        {
            using (ISession session = NHibernateHelper.ObtenerSession())
            {
                session.Delete(entidad);
                session.Flush();
            }
        }

        public ICollection<Entidad> ListarTodos()
        {
            using (ISession session = NHibernateHelper.ObtenerSession())
            {
                ICriteria busqueda = session.CreateCriteria(typeof(Entidad));
                return busqueda.List<Entidad>();
            }
        }
    }
}

Ahora crearemos la clase “Distrito.cs” dentro de la carpeta “Dominio”, tal como sigue:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Serialization;

namespace ClientesService.Dominio
{
    [DataContract]
    public class Distrito
    {
        [DataMember]
        public int Co_Distrito { get; set; }
        [DataMember]
        public string No_Distrito { get; set; }
    }
}

Luego la clase “Cliente.cs” de la siguiente manera:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Serialization;

namespace ClientesService.Dominio
{
    [DataContract]
    public class Cliente
    {
        [DataMember]
        public int Co_Cliente { get; set; }
        [DataMember]
        public string No_Cliente { get; set; }
        [DataMember]
        public string Nu_Documento { get; set; }
        [DataMember]
        public string Tx_Direccion { get; set; }
        [DataMember]
        public Distrito Distrito { get; set; }
    }
}

Ahora crearemos dentro de la carpeta “Persistencia” la clase “ClienteDAO”, tal como se muestra a continuación:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ClientesService.Dominio;

namespace ClientesService.Persistencia
{
    public class ClienteDAO : BaseDAO<Cliente, int>
    {
    }
}

Y ahora “DistritoDAO”:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using ClientesService.Dominio;

namespace ClientesService.Persistencia
{
    public class DistritoDAO : BaseDAO<Distrito, int>
    {
    }
}

Ahora editar el archivo “Clientes.svc” y colocar el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using ClientesService.Persistencia;
using ClientesService.Dominio;

namespace ClientesService
{
    public class Clientes : IClientes
    {
        private ClienteDAO clienteDAO = null;
        private ClienteDAO ClienteDAO
        {
            get
            {
                if (clienteDAO == null)
                    clienteDAO = new ClienteDAO();
                return clienteDAO;
            }
        }

        private DistritoDAO distritoDAO = null;
        private DistritoDAO DistritoDAO
        {
            get
            {
                if (distritoDAO == null)
                    distritoDAO = new DistritoDAO();
                return distritoDAO;
            }
        }

        public Cliente CrearCliente(string NoCliente, string NuDocumento, string TxDireccion, int CoDistrito)
        {
            Distrito distritoExistente = DistritoDAO.Obtener(CoDistrito);
            Cliente clienteACrear = new Cliente()
            {
                No_Cliente = NoCliente,
                Nu_Documento = NuDocumento,
                Tx_Direccion = TxDireccion,
                Distrito = distritoExistente 
            };
            return ClienteDAO.Crear(clienteACrear);
        }

        public Cliente ObtenerCliente(int CoCliente)
        {
            return ClienteDAO.Obtener(CoCliente);
        }

        public Cliente ModificarCliente(int CoCliente, string NoCliente, string NuDocumento, string TxDireccion, int CoDistrito)
        {
            Distrito distritoExistente = DistritoDAO.Obtener(CoDistrito);
            Cliente clienteAModificar = new Cliente()
            {
                Co_Cliente = CoCliente,
                No_Cliente = NoCliente,
                Nu_Documento = NuDocumento,
                Tx_Direccion = TxDireccion,
                Distrito = distritoExistente
            };
            return ClienteDAO.Modificar(clienteAModificar);
        }

        public void EliminarCliente(int CoCliente)
        {
            Cliente clienteExistente = ClienteDAO.Obtener(CoCliente);
            ClienteDAO.Eliminar(clienteExistente);
        }

        public List<Cliente> ListarClientes()
        {
            return ClienteDAO.ListarTodos().ToList();
        }
    }
}

Luego editar el archivo “IClientes.cs” con el siguiente código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using ClientesService.Dominio;

namespace ClientesService
{
    [ServiceContract]
    public interface IClientes
    {
        [OperationContract]
        Cliente CrearCliente(string NoCliente, string NuDocumento, string TxDireccion, int CoDistrito);

        [OperationContract]
        Cliente ObtenerCliente(int CoCliente);

        [OperationContract]
        Cliente ModificarCliente(int CoCliente, string NoCliente, string NuDocumento, string TxDireccion, int CoDistrito);

        [OperationContract]
        void EliminarCliente(int CoCliente);

        [OperationContract]
        List<Cliente> ListarClientes();
    }
}

Por ultimo crearemos los archivos XML en la carpeta “Dominio”.
A continuación el archivo “Cliente.hbm.xml”:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
                   assembly="ClientesService"
                   namespace="ClientesService.Dominio"
                   default-lazy="false">
    <class name="Cliente" table="t_cliente">
        <id name="Co_Cliente" column="Co_Cliente">
            <generator class="increment" />
        </id>
        <property name="No_Cliente" column="No_Cliente" />
        <property name="Nu_Documento" column="Nu_Documento" />
        <property name="Tx_Direccion" column="Tx_Direccion" />
        <many-to-one name="Distrito" column=" Co_Distrito" />
    </class>
</hibernate-mapping>

Ahora el archivo “Distrito.hbm.xml”

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
                   assembly="ClientesService"
                   namespace="ClientesService.Dominio"
                   default-lazy="false">
    <class name="Distrito" table="t_distrito">
        <id name="Co_Distrito" column="Co_Distrito">
            <generator class="increment" />
        </id>
        <property name="No_Distrito" column="No_Distrito" />
    </class>
</hibernate-mapping>

Es importante escoger la opción de Contenido: “Recurso Incrustado” en las propiedades de ambos archivos, como se muestra en la siguiente figura

Ahora demos clic derecho sobre nuestro servicio “Clientes.svc” y escojamos la opción “Ver en el explorador”.

Nos deberia salir una pantalla similar a la que se muestra en la siguiente imagen:

El puerto puede variar, dependiendo de la configuración de las propiedades del proyecto que tengamos, a continuación se muestra como cambiar el puerto por defecto.

Eso es todo por ahora, espero que les haya servido el tema de hoy, mas adelante veremos como probar un Servicio Web SOAP siguiendo este mismo ejemplo.

Gracias !!!