Mostrando las entradas con la etiqueta WCF. Mostrar todas las entradas
Mostrando las entradas con la etiqueta WCF. Mostrar todas las entradas

viernes, 10 de junio de 2016

Conozca acerca de WCF y Construya una Aplicación

En siguiente articulo quiero compartirles los conceptos necesarios para implementar servicios WCF (Windows Communication Foundation). Además, conoceremos acerca de como crear y cuales con los proyectos de tipo WCF, publicación en el IIS (Internet Information Server) y como consumir dicho servicio ya publicado.

Requisitos para la implementación:
- Microsoft SQL Server Management Studio 2008.
- Microsoft Visual Studio Ultimate 2010 o 2012.
- Framework 4 y MCV 4.
- Enterprise Library 5.
- AngularJS v1.2.24.
- Y algo de sentencia SQL (para manipulación de datos desde base de datos).

Aquí dejo todos los pasos a seguir:
Introducción a WCF - Fase I
Conexión a datos WCF - Fase II
Publicar Servicios WCF - Fase III
Consumir servicio WCF - Fase IV

Pantalla de lo que se logrará al finalizar



Sugerencias y opiniones son bienvenidos o escríbanos a hadson1@gmail.com

viernes, 1 de mayo de 2015

Consumir servicio WCF - Fase IV

Siguiendo con los apartados de servicios WCF - ahora implementaremos una aplicación Asp.Net MVC para saber el cómo consumir un serivicio WCF.

Requisitos:
  • Visual Studio .Net 2010.
  • Framework 4.
  • Ajax, JQuery, JSON
  1. Iniciamos creando nuestro proyecto de tipo ASP.NET MVC 4 Web Application - desde la carpeta FrontEnd.



  2. Seleccionamos el template basic de MVC.

  3. Estructura de nuestro proyecto MCV - creado.

  4. Ahora creamos el controllers - con nombre Home.


    Determinamos el nombre
  5. Luego creamos el view - clic derecho en index de la clase del controller.


    En mi caso mantendré el mismo nombre que el controller

    Estructura de nuestro view creado
  6. Ahora iniciamos haciendo referencia al servicio que anteriormente se creo y publico - determinamos con nombre ServiceUbigeo.

  7. Ubicamos haciendo clic Discover - asignamos el nombre de ServiceUbigeo


    Servicio referenciado desde nuestro proyecto MCV
    1. Consideraciones: Al crear uno o varios servicios en nuestro archivo Web.config de manera automática se adicionara los endpoint que determinar la ruta para el compartimiento de información entre las parte involucradas en un servicio.
    
        
          
            
          
        
        
          
            
              
            
          
        
      
    
    
  8. Ahora adicionamos es nuestro modelo (ClassModelo.cs) los siguiente atributos.
    Favor de considerar los comentarios que están en el código fuente - color verte - partiendo desde este punto.

    public class UbiDepartamento //Cambiamos a UbiDepartamento (parecido a la entidad de la base de datos)
        {
            //Sólo adiciono los atributos que se manipulara
            public string CodDepartamento { get; set; }
            public string DesDepartamento { get; set; }
        }
    
  9. Ahora implementamos en nuestro controller el método que nos permitirá consumir el servicio a la cual hacemos referencia - el HttpPost y el JsonResult se entrará al detalle en otro apartado.
    [HttpPost]
            public JsonResult GetAllDepartamento()
            {
                try
                {
                    using (var client = new Service1Client())
                    {
                        List result = new List();//Invocamo a la entidad de nuestro modelo
                        var preResult = client.GetDepartamentoDataList();//Invocamos al método que es parte del servicio ubigeo
    
                        if (preResult != null && preResult.ToList().Count > 0)//validar la existencia de datos
                            foreach (var item in preResult) //recoremos los valores
                            {
                                result.Add(new UbiDepartamento //y vamos adicionando en nuestro modelo segun los atributos
                                {
                                    CodDepartamento = item.COD_DEPARTAMENTO.ToString(),
                                    DesDepartamento = item.DES_DEPARTAMENTO.ToString()
                                });
                            }
    
                        return Json(result, JsonRequestBehavior.AllowGet); //retornamos los valores recuperados
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
  10. Para este caso solo implementaremos la carga de datos en un HTML input de tipo select que haremos uso de Ajax y JQuery con tipo de dato JSON.
    $(document).ready(function () {
    
        $.ajax({
            url: "Home/GetAllDepartamento",
            type: "POST",
            dataType: "json",
            data: "{}",
            success: function (data) {
    
                if (data == null) {
                    alert('Disculpe, No hay departamentos que mostrar.');
                    return
                } else {
                    for (var i = 0; i < data.length; i++) {
                        $("#SltDepartamento").append("");
                    }
                }
            },
            error: function (jqXHR, status, error) {
                alert('Disculpe, existió un problema');
            }
        });
    
    });
    
  11. Y para finalizar implementamos HTLM en el _Layout.cshtml  para poder mostrar los datos que nos devuelve el servicio.

    Resultado del servicio que estamos consumiendo
Proyecto C#

domingo, 19 de abril de 2015

Publicar Servicios WCF - Fase III

En el siguiente apartado demostraré a través de imágenes y breves explicaciones la publicación de un servicio (siguiendo las fases de servicios WCF) en el IIS – Internet Information Sever, SO – Sistema Operativo Windows Seven - Edition Ultimate (para cualquiera de las ediciones se realiza casi todos los pasos).

Requisitos:
  • Visual Studio .Net 2010.
  • IIS – Internet Information Sever.
  • Framework 4.
  • Independientemente hay que considerar las dll's del Enterprise Library.
  1. Iniciamos haciendo referencia a los tres proyectos para que se asocien al de PyWcfService.
  2. Ahora desde el Visual Studio .Net usamos la opción de publicar (genera todas la dll's y archivos necesarios para poder hacer la publicación en el IIS).

  3. Ahora Seleccionamos sistemas de archivos en la opción de método de publicación, ubicamos la ruta donde se copiaran los archivos, activamos la opción eliminar ... para poder eliminar todos los archivos cada que se realiza la opción publicar des de VS.Net y para finalizar clic en Publicar.
  4. Bueno, lo recomendable sería revisar los archivos generados después de hacer la publicación (lo que en realidad hace es solo copiar los archivos que serán publicados en IIS) desde VS.Net.
     Revisamos las dll's que se encuentran en la carpeta bin (El proyecto de servicios debe contener - referencia - todas los proyectos y dll's necesarias - por ejemplo - yo estoy usando Enterprise Library).
  5. Ahora en adelante se realizará la publicación en el IIS.
     Ingresamos a través del comando inetmgr o desde el panel de control
  6. Desde la opción Ayuda y Acerca de Internet Information Sever - revisamos la edición.
  7. Ahora creamos la aplicación a publicar.

    Ingresamos los datos, tal cual esta en la imagen donde el ALIAS es el nombre asignado de la apliación, SELECCIONAR el framework necesario en mi caso es el 4 y para finalizar ubicar la RUTA DE ACCESO FÍSICA (es la ruta del punto 3 - donde está la carpeta bin).
  8. Habilitamos la opción para poder ver el listado de directorios.
    Clic en habilitar y aplicar
  9. Para ir finalizando clic en la aplicación creada y clic en Examinar *.80 (http)
  10. Y si todo esta bien - podremos visualizar la lista de archivos que ahora se encuentran publicados.
  11. Y para testear el servicio clic Service1.svc
En el siguiente apartado veremos sobre el cómo consumir el servicio que acabamos de publicar.

sábado, 28 de marzo de 2015

Conexión a datos WCF - Fase II

En el siguiente apartado pretendo implementar y demostrar que tipos de proyectos hay que agregar a nuestra solución para poder desarrollar servicios WCF y luego consumirlos desde una aplicación MVC que implementaré en la fase IV, ya que en la fase III publicaremos nuestro servicios en el IIS.

Los requisitos por ahora para este apartado son:
  • IDE – Visual Studio 2010.
  • SQL Sever 2008.
  • EnterpriseLibrary.
Antes de iniciar con la implementación, comenzaré con la identificación y creación de los tipos de proyectos que utilizaré.

En nuestra solución agregaré 2 proyectos de tipo biblioteca de clases y 2 de WCF una de biblioteca o clases de servicios WCF y otra de aplicación de servicios WCF, así como existe biblioteca de clases comunes o genéricas (las 2 primeras mencionadas) por así mencionarlos, son las  que más se suele usar al desarrollar proyectos en 3 o N capas o dependiendo de las necesidades del desarrollo, también existe para WCF con la diferencia que son para servicios, en lo cual te adiciona un archivo de configuración (App.config se adiciona de manera automática al crear el proyecto - biblioteca de clases de servicios WCF), entre otros detalles que describiré más adelante.

Para continuar adicionaremos los proyectos a nuestra solución, luego describiré las utilidades de cada uno de ellos:

Comencemos adicionando 2 proyecto de clases con nombre PyBusiness y PyEntity.


Ahora adicionamos el primer proyecto de tipo WCF que será el de biblioteca de servicios WCF con nombre PyWcfServiceLibrary.

Y por último adicionamos el segundo proyecto de tipo WCF que será el de aplicación de servicios WCF con nombre PyWcfService.

Una de las recomendaciones para poder identificar el tipo de proyecto son en las imágenes y recuadros seleccionados de color verte.

La estructura de los proyectos que acabamos de crear va quedando de esta siguiente manera (ver imagen)

Las carpetas BackEnd y FrontEnd son consideraciones de buenas prácticas al implementar una solución web, puede leer siguiente articulo.

Utilidades de los proyectos adicionados a la solución:
En los proyectos PyBusiness y PyEntity quizás no hay mucho por mencionar. Son muy usados casi en todo desarrollo de 3 a más capas.

PyBusiness en este caso almacenará una clase para nuestra conexión a datos y las demás clases serán para crear los métodos o funciones entre otros concernientes a la lógica del negocio que estemos desarrollando dicho proyecto.

PyEntity se encarga de almacenar las propiedades de nuestra entidades que son parte de la lógica del negocio.

PyWcfServiceLibrary proyecto de biblioteca de servicios que se encarga de incluye automáticamente los tres archivos siguientes:
  1. Archivo de contrato de servicio (IService1.cs).  Es una interfaz a la que se aplican los atributos de servicio WCF. Este archivo proporciona una definición de un servicio simple que muestra cómo definir los servicios, e incluye operaciones basadas en parámetros y un ejemplo de contrato de datos simple. Éste es el archivo predeterminado mostrado en el editor de código después de crear un proyecto de servicio WCF.
  2. Archivo de implementación de servicio (Service1.cs). Implementa el contrato definido en el archivo de contrato de servicio.
  3. Archivo de configuración de la aplicación (App.config). Poporciona los elementos básicos de un modelo de servicio WCF con un enlace HTTP seguro. Además incluye un extremo para el servicio y habilita el intercambio de metadatos.
PyWcfService proyecto de servicio de aplicación web, el encargado de ser parte de conformar la referencia de los demás proyecto, ya que este proyecto será el que publicaremos en nuestro ISS (aquí se encontraran los servicios que publicaremos). Además, incluye los tres archivos siguientes que luego iremos modificando:
  1. Archivo de host del servicio (Service1.svc).
  2. Archivo de contrato de servicio (IService1.cs).
  3. Archivo de configuración web (Web.config).
El contexto para la implementación será listar los registro de una tabla:

Consideración es para implementación:
Para este caso determinare 2 grupos el GRUPO A de las clases genéricas que casi siempre se implementa en un proyecto de 3 a N capas, y el GRUBO B que básicamente será para la implementación de nuestro servicios (la gran parte es hacer referencia a los métodos creados e ir )

EN EL GRUPO A:
  1. Crear la cadena de conexión
  2. Crear el método de la lógica de negocio (por ahora sólo usaremos un simple select)
  3. Crear nuestra entidad equivalente a la sentencia select
EN EL GRUPO B:
  1. Hacer referencia método creado que se realiza el GRUPO A.
  2. Luego se implementa la referencia del método o según otros contexto es hacer una copia al método creado que gracias a la Serialization se puede realizar la comunicación remota a pasar objetos por valor de un dominio de aplicación a otro.
Recordemos que la publicación de nuestro servicio será a través de la aplicación PyWcfService. Iniciare la implementación haciendo énfasis a las librerías a usar y a la cadena de conexión

En este caso haremos uso de Enterprise Library Versión 5.0.414.0. En el App.config del proyecto PyWcfServiceLibrary implementamos las siguiente líneas (haremos referencia a las librerías de Enterprise Library y la cadena de conexión)

  
    
Además debemos adicionar las librería del Enterprise Library en el proyecto PyWcfServiceLibrary  y los mismo haremos para el proyecto PyBusiness (no debemos confundir con adicionar e importar).

Ahora implementaremos en el proyecto PyEntity todo los dataMember que es hacer referencia a los nombres de las columnas de nuestra entidad (tabla), en mi caso solo quiero visualizar 2 de ellas. Además debemos importar la librería using System.Runtime.Serialization.
using System.Runtime.Serialization;//Importar la referencia

namespace PyEntity
{
    [DataContract]//Adicionamos el contrato de datos
    public class ClsDepartamentoEN
    {
        //Adicionamos los DataMember (columnas de uestra entidad Departamento)
        [DataMember(Name = "COD_DEPARTAMENTO")]
        public string COD_DEPARTAMENTO { get; set; }

        [DataMember(Name = "DES_DEPARTAMENTO")]
        public string DES_DEPARTAMENTO { get; set; }
    }
}
Siguiendo con la implementación:
Implementaremos en el proyecto PyBusiness nuestro método que nos devolverá la data según nuestro sentencia select.
  1. Adicionar una clase (en mi caso ClsDepartamentoBL.cs)
  2. Ahora si importamos las librerías necesarias y el proyecto PyEntity en la clase creado y creamos nuestro método GetDepartamentoList.
using PyEntity;//Hacemos referencia al proyecto donde estan los datamember del contrato de datos 
using System.Data;//Importamos el System.Data
using System.Data.SqlClient;//Importamos el provedor SqlClient para el acceso a datos

//Importamos la librería de Enterprise Library
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Sql;
using Microsoft.Practices.EnterpriseLibrary.Common;

namespace PyBusiness
{
    /* Modificamos la clase a publica */
    public class ClsDepartamentoBL
    {   
        /* Query Listar todos los departamentos */
        public static List GetDepartamentoList()
        {
            Database database = DatabaseFactory.CreateDatabase();
            //Database database = new DatabaseProviderFactory().Create("Cnx");
            string StrQuery = string.Format("SELECT COD_DEPARTAMENTO, " +
                                             "          DES_DEPARTAMENTO " +
                                             "FROM UBI_DEPARTAMENTO");

            SqlCommand cmd = (SqlCommand)(database.GetSqlStringCommand(StrQuery));

            IDataReader reader = database.ExecuteReader(cmd);
            return ClsEntityCreator.CreateDepartamentoList(reader);
        }
    }
}
Ahora regresamos a nuestro proyecto PyWcfServiceLibrary e implementamos el metodo GetDepartamentoList en la clase IService1 para luego hacer referencia e implementar en la clase Service1

Clase IService1

//Importamos los proyectos de las entidades y del negocio
using PyEntity;
using PyBusiness;

namespace PyWcfServiceLibrary
{
    // NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name "IService1" in both code and config file together.
    [ServiceContract]
    public interface IService1
    {
        //Ahora implementamos el método GetDepartamentoList
        [OperationContract]
        List GetDepartamentoDataList();
    }
}

Calase Service1

//Importamos los proyectos de las entidades y del negocio
using PyEntity;
using PyBusiness;

namespace PyWcfServiceLibrary
{
    // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service1" in both code and config file together.
    public class Service1 : IService1
    {

        //Ahora invocamos el método creado en el proyecto PyBusiness
        public List GetDepartamentoDataList()
        {
            return ClsDepartamentoBL.GetDepartamentoList();
        }
    }
}
En otros palabras acabamos de crear un servicio llamado IService1 que esta conformado con un método llamado GetDepartamentoDataList()

Para finalizar en el proyecto PyWcfService hacemos referencia a nuestro servicio que acabamos de crear y luego testeamos nuestro servicio creado

<%@ ServiceHost Language="C#" Debug="true" Service="PyWcfServiceLibrary.Service1" CodeBehind="PyWcfServiceLibrary.Service1.cs" %>


Testeamos nuestro servicio con la herramienta que nos proporciona el proyecto PyWcfService que es de aplicación de servicios WCF.


Proyecto en C#

Nos vemos en la siguiente fase que veremos sobre la publicación del servicio que acabamos de crear.

martes, 9 de diciembre de 2014

Introducción a WCF - Fase I

En el siguiente articulo estaré hablando acerca de WCF - Windows Communication Foundation, considerando que este apartado es la parte introductoria al tema de servicios:

Requisitos:
Visual Studio 2012.
Lenguaje de programación C#.

¿Qué es WCF?
Revisando en la internet se encontrará mucha información al respeto, en resumen es uno o más de las apliaciones que se implementa a una solución o proyecto, con la única diferencia que son aplicaciones orientadas a servicios - SOA, para aclarar, esto no quiere decir que el concepto que planteo es solamente crear una aplicación, iré aclarando ciertos puntos que debemos considerar al momento de construir nuestra aplicación. Para mayor detalles pueden revisar el enlace más sobre WCF con respecto a SOA estaré publicando más adelante en otro articulo.

Iniciamos con la creación de nuestra solución DemoWCF:



Crear la solución haciendo referencia al .NET Framework 4.5


Solución creado DemoWCF

Creamos nuestro proyecto PyDemoWCF:


IService1.cs: Clase que invoca todos los métodos (operaciones) creados que retornaran algún valor sin importar el tipo de dato que contiene la clase Service1.cs.
// NOTA: puede usar el comando "Rename" del menú "Refactorizar" para cambiar el nombre de interfaz "IService1" en el código y en el archivo de configuración a la vez.
[ServiceContract]
public interface IService1
{
[OperationContract]
string GetData(int value); 
[OperationContract]
CompositeType GetDataUsingDataContract(CompositeType composite); 
// TODO: agregue aquí sus operaciones de servicio
}
El atributo [ServiceContract] se encarga de definir lo que puede realizar un servicio. Además se encarga de describir las operaciones que ofrece un servicio. Es decir, permite la interoperabilidad (operaciones que se puede realizar) de un servicio, intercambiando información entre 2 o más SISTEMAS de una entidad local o varias entidades sin considerar el lugar en la que se encuentre. La importancia de ServiceContract se resume en un ACUERDO entre las partes involucradas que nos permiten definir la manera en que se trabaja entre las partes involucradas. Considerano los tipos de funciones que se van a ofrecer, qué tipos de datos serán enviados o recibidos y el cómo serán enviados.

El atributo [OperationContract] sirve para poder identificar las operaciones (métodos) que se esta realizando, así que, toda operación debe estar en el [ServiceContract] ya que nos permite indicar el acuerdo entre sí. 

// Utilice un contrato de datos, como se ilustra en el ejemplo siguiente, para agregar tipos compuestos a las operaciones de servicio.
// Puede agregar archivos XSD al proyecto. Después de compilar el proyecto, puede usar directamente los tipos de datos definidos aquí, con el espacio de nombres "PyDemoWCF.ContractType".
[DataContract]
public class CompositeType
{
bool boolValue = true;
string stringValue = "Hello "; 
[DataMember]
public bool BoolValue
{
get { return boolValue; }
set { boolValue = value; }
} 
[DataMember]
public string StringValue
{
get { return stringValue; }
set { stringValue = value; }
}
}
Además por defecto trae implementado el [DataContract] que se encarga de describir la estructura de datos manejados por la operaciones de los servicios con sus respectivos miembros de datos [DataMember]. Considerando que omitir un miembro de datos serializados, establezca la propiedad EmitDefaultValue del atributo DataMemberAttribute en false (el valor predeterminado es true), en otro articulo se profundizará el tema de los [DataMember].

Service1.cs Clase que concreta la ejecución de todos los métodos (operaciones) creados. Es decir en esta clase es la que se implementa todas la operaciones sea cual sea, traerdatosempleado, procesarsuelto, procesarnota, etc.

// NOTA: puede usar el comando "Rename" del menú "Refactorizar" para cambiar el nombre de clase "Service1" en el código y en el archivo de configuración a la vez.
public class Service1 : IService1
{
public string GetData(int value)
{
return string.Format("You entered: {0}", value);
} 
public CompositeType GetDataUsingDataContract(CompositeType composite)
{
if (composite == null)
{
throw new ArgumentNullException("composite");
}
if (composite.BoolValue)
{
composite.StringValue += "Suffix";
}
return composite;
}
}
App.config Archivo que contiene la configuración de nuestro servicio. El punto a resaltar por ahora sera el endpoint. Una aplicación basado en servicio siempre tiene que tener al menos un endpoint, que se encarga de seleccionar la dirección o ruta, quiere decir es fundamental en determinar una ruta para el compartimiento de información entre las parte involucradas en un servicio. Es decir el cliente involucrado debe saber la ruta para poder acceder a dicho servicio.

En nuestro caso esta por defecto la ruta localhost, pero no es solamente este punto de los endpoint's a considerar, hay muchos puntos que más adelante hablaremos sobre las https, las adrresses el tcp y behavior, entre otros.

Testeando nuestro Servicio:
// Aquí implementamos un contrato de datos
[DataContract]
public class OperacionPromedio
{
string alumno;
string especialidad;
string curso;
decimal promedio; 
[DataMember]
public string Alumno{
get { return alumno; }
set { alumno = value; } 
} 
[DataMember]
public string Especialidad
{
get { return especialidad; }
set { especialidad = value; } 
} 
[DataMember]
public string Curso { 
get { return curso; }
set { curso = value; }
} 
[DataMember]
public decimal Promedio
{
get { return promedio; }
set { promedio = value; }
}
}

// Aca invocamos a nuestro método GetNombresApellidos...
[OperationContract]
string GetNombresApellidos(string nombres, string apellidos); 
[OperationContract]
OperacionPromedio GetOperacionPromedio(int pNota1, int pNota2, int pNota3);
//Aca implementaremos un metodo que retorna un valor en cadena
public string GetNombresApellidos(string nombres, string apellidos) {
string dato;
dato = nombres +" "+ apellidos;
return dato;
} 

//Aca implementaremos un metodo que retorna valores utilizando un contrato de datos
public OperacionPromedio GetOperacionPromedio(int pNota1, int pNota2, int pNota3)
{
OperacionPromedio OpePromedio = new OperacionPromedio(); 
OpePromedio.Alumno = "Hadson Paredes Córdova";
OpePromedio.Especialidad = "Computación e Informatica";
OpePromedio.Curso = "Análisis y diseño de procesos";
OpePromedio.Promedio = Decimal.Round((pNota1 + pNota2 + pNota3) / 3, 2); 
return OpePromedio;
}
Crear el proyecto PyDemoWCF de tipo Biblioteca de servicios WCF haciendo referencia al .NET Framework 4.5


En nuestro proyecto creado explicaremos las consideraciones y conceptos de un servicio


Comencemos:

Al crear nuestro proyecto de tipo Biblioteca de servicios WCF por defecto crea los siguientes archivos con los siguientes contenidos.



Todas las operaciones que fueron invocados en la clase IService1.cs es decir string GetData(int value) y CompositeType GetDataUsingDataContract(CompositeType composite) ahora se podrá visualizar la estructura de dichos eventos:


Ambos métodos (Operaciones) son dependientes de la clase IService1 y son de tipo publico.

Para poder realizar el Test de nuestra aplicación implementaré 2 nuevos métodos independientemente de las que comentamos (las que trae por defecto al crear el proyecto Biblioteca de servicios WCF) líneas arriba.

En la clase IService1.cs implementamos un contrato de datos:

Además en el [ServiceContract] hacemos referencia a los métodos GetNombresApellidos y GetOperacionPromedio:

Ahora bien en la clase Service1.cs implementamos  nuestro métodos:

Ahora iniciamos nuestro test, como se vera en la siguiente imagen de la ficha con formato:


Para nuestro test solo se va a realizar con e método GetOperacionPromedio. El cliente de prueba nos ofrece la sección de métodos, solicitud y respuesta.

De la misma manera nos ofrece en la ficha XML con la única diferencia que son datos en XML:



Ahora ingresamos los datos respectivos en la sección de Solicitud:




Y como se visualiza en la sección de respuesta son los valores que se esta retornando según la operación o método en ejecución, que en lo interno se llega a ejecutar. Es decir si el cliente nos envía una solicitud o petición de algo, el servicio siempre tiene que devolver un valor o respuesta verídica o una excepción o error tiene mucho que ver la implementación que se desarrollo. Quiere decir para toda solicitud o petición  habrá algo que devolver o responder.

Veámoslo a motodo XLM:

De esta manera es la que el cliente podrá leer la respuesta de su solicitud.

Bueno, espero que les aya gustado en el siguiente articulo se implementara el proyecto. El como se consume la información a lado del cliente de nuestro servicio creado. Nos vemos...!!!