WCF - 5. Primer Ejemplo (Reserva de vuelos)

Este primer ejemplo consiste en crear parte de un sistema de reserva típico donde el cliente hace una búsqueda de vuelo y procede a efectuar la reserva, registrándose previamente. Este ejemplo se compone de varios componentes que iremos desarrollando a medida que haga falta. Sin embargo, para empezar, lo primero que necesitamos ofrecer al cliente, es un sistema de búsqueda de vuelo.

Nuestro primer objetivo es obtener los aeropuertos que intervienen en el vuelo. Es necesario crear un procedimiento que dado el nombre de una ciudad, devuelva el aeropuerto de dicha ciudad. Teniendo estos aeropuertos, podremos proceder a la búsqueda de vuelos disponibles mas adelante.

Como se explicó anteriormente, un servicio web se compone de 3 valores, donde, como y que. Estos valores se identifican con Address, Binding y Contract y la unión de estos componen el Endpoint.

Definición del contrato (Contract)

Lo primero que debemos definir claramente es lo que se va a ofrecer y las condiciones bajos las cuales se va a llevar a cabo. La mejor manera de definir esto es mediante interfaces, ya que una interfaz es una serie de condiciones que una clase que la implementa debe cumplir, es decir, un contrato.

En un proyecto de librería de clases, vamos a manejar todas las interfaces que necesitemos.

using System.ServiceModel;
 
namespace WebServices.Interfaces
{
    [ServiceContract]
    public interface IReservaVuelos
    {
        [OperationContract]
        string ObtenerCodigoAeropuerto(string ciudad, string pais);
    }
}

El proyecto debe contar con la referencia a System.ServiceModel. Esto es el espacio de nombre para aplicaciones que hacen uso de WCF. Se pueden observar 2 atributos, ServiceContract y OperationContract. El primero indica que la interfaz que se define es el contrato de servicio que se va a implementar. El segundo indica que el procedimiento que decora es una operación que el servicio ofrece.

Implementación del servicio

Teniendo el contrato definido, el siguiente paso es implementarlo. Para esto creamos otro proyecto de librería de clases y le adicionamos la referencia a System.ServiceModel y a nuestro proyecto de interfaces. La clase que va a implementar la interface es la siguiente:

using WebServices.Interfaces;
 
namespace WebServices.Implementacion
{
    public class ReservaVuelos : IReservaVuelos
    {
        public string ObtenerCodigoAeropuerto(string ciudad, string pais)
        {
            string strRespuesta = string.Empty;
 
            if (pais.Equals("Colombia"))
            {
                switch (ciudad)
                {
                    case "Medellin":
                        strRespuesta = "EOH";
                        break;
                    case "Bogota":
                        strRespuesta = "BOG";
                        break;
                    case "Cali":
                        strRespuesta = "CLO";
                        break;
                    default:
                        strRespuesta = "Desconocido";
                        break;
                }
            }
            else
            {
                strRespuesta = "País desconocido";
            }
 
            return strRespuesta;
        }
    }
}

Hospedando el servicio (Address).

Para poder exponer un servicio, hay que hospedarlo dentro de un proceso, que puede ser cualquier aplicación de Windows, ya sea consola, una aplicación de escritorio, un servicio windows o incluso dentro de IIS. Para ello, es necesario crear lo que se denomina un ServiceHost, que es la clase que se encarga de hospedar el servicio. Vamos a optar por una aplicación de consola.

El constructor de ServiceHost toma dos parámetros, el tipo de servicio implementado y una dirección base. La dirección base indica en que dirección IP y puerto estará escuchando el servicio. Además se puede incluir de manera opcional, una ruta permitiendo de eta forma tener mas de un servicio hospedado en la misma combinación de puerto y dirección IP.

Después de realizar los dos pasos anteriores, tenemos dos proyectos: la definición del contrato y una implementación. Sin embargo esto no es suficiente para poder exponer el servicio para su consumo por los clientes. En este punto sólo tenemos el que y el donde, es necesario definir el como para poder exponer dicho servicio. 

Bindign

A parte de definir lo que vamos a ofrecer (contract) y donde esta definido(address), falta una pieza para completar el Endpoint: el binding, que indica las condiciones bajo las cuales el servidor y el cliente se van a comunicar. Entre muchos de los aspectos que define, una de ellas es el protocolo de transporte. Para nuestro caso el servicio se va a exponer utilizando el protocolo Http. WCF define varios bindings que utilizan este protocolo, siendo el más simple BasicHttpBinding.

Teniendo los parámetros anteriores, procedemos a crear el ServiceHost, asociarle una dirección, un protocolo y archivarlo.

using System;
using System.ServiceModel;
using System.ServiceModel.Description;
 
using WebServices.Interfaces;
using WebServices.Implementacion;
 
namespace WebServices.Host.Console
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri objUri = new Uri("http://localhost:8080/ServicioReservaVuelos");
            ServiceHost objHost = new ServiceHost(typeof(ReservaVuelos), objUri);
            BasicHttpBinding objBinding = new BasicHttpBinding();
 
            objHost.AddServiceEndpoint(typeof(IReservaVuelos), objBinding, "");
 
            try
            {
                /// Esto se utiliza para mostrar la metadata del servicio.
                ServiceMetadataBehavior objMetadata = new ServiceMetadataBehavior();
                objMetadata.HttpGetEnabled = true;
                objHost.Description.Behaviors.Add(objMetadata);
 
                objHost.Open();
 
                System.Console.WriteLine("El servicio de reservas esta activo en: \n" + objUri.AbsoluteUri);
                System.Console.WriteLine("\n\nPulse [ENTER] para detener el servicio.");
                System.Console.ReadLine();
            }
            catch (Exception ex)
            {
 
            }
            finally
            {
                objHost.Close();
            }
        }
    }
}

Una vez que se ha definido el ServiceHost, se procede a activarlo llamando al método Open(). Este método lanzará una hebra secundaria para procesar las peticiones y devolverá el flujo del programa a la siguiente instrucción, donde se escribe información sobre el servicio.

Al estar utilizando Http como protocolo de comunicación, se puede utilizar el navegador para comprobar que el servicio esta activo. Introduciendo la dirección correspondiente en el navegador, saldrá el siguiente mensaje.

Podemos ver la descripción del servicio dando clic sobre la url. Veamos parte de lo que se obtiene.

Estos contenidos se publican bajo una licencia de Creative Commons