WCF

Por Daniel García

Diciembre 11, 2013
 INDICE

Introducción a LINQ ............................................................................................................................................ 3

Sentencias en LINQ ............................................................................................................................................. 7

Selecciones simples. Tipado Implícito y Tipos Anónimos. ....................................................................... 7

Joins y Multiselects................................................................................................................................. 15

Agrupaciones (Group by) ....................................................................................................................... 18

Particionado. Delegados y Expresiones Lambda. ................................................................................... 25

Funciones de Agregación (Count, Sum, Average, Max, Min) ................................................................. 31

Ordenación (Order by) ........................................................................................................................... 38

Operaciones sobre conjuntos ................................................................................................................ 42

Cuantificadores, Generadores y Conversores ........................................................................................ 47

LINQ to SQL ....................................................................................................................................................... 52

Mapeo Objeto-Relacional ...................................................................................................................... 52

Relaciones .............................................................................................................................................. 72

Consultas compiladas. Ejecución nativa de SQL. Procedimientos almacenados ................................... 76

Modificación de datos (Insert, Update, Delete) ..................................................................................... 81

Entity Framework ............................................................................................................................................. 93

Creación de un Entity Model .................................................................................................................. 93

ObjectContext y Entity SQL .................................................................................................................. 105

Select, Insert, Update, Delete .............................................................................................................. 107

Mapeo mediante Procedimientos Almacenados ................................................................................. 114

Enlazado y desenlazado de entidades. Estados ................................................................................... 118

Entity Model y Data Services ................................................................................................................ 121

Construcción de ficheros XML mediante LINQ ............................................................................................... 139

 INTRODUCCIÓN A WINDOWS COMMUNICATION
FOUNDATION (WCF)
La plataforma .NET sufrió su gran transformación a partir de sus versiones 3.0/3.5, momento en el que surgen
oficialmente las ahora conocidas como Foundations, orientadas a especializar secciones completas del framework.
Windows Communication Foundation, originalmente conocida por el nombre de Indigo, es la parte encargada, como su
propio nombre indica, de las comunicaciones y mensajería, aunque su principal uso son los servicios web.

Hasta el momento, el servicio de mensajería entre aplicaciones se realizaba mediante los protocolos COM, DCOM o
MSQM, que obligaba a los programadores a ceñirse no sólo a una forma de programación concreta, sino que también
estaba atada a la plataforma y al lenguaje de programación. Los servicios web surgen con el propósito de cambiar esta
filosofía, permitiendo hacer la comunicación independiente de lenguaje de programación y plataforma gracias a la
creación de estándares de comunicación. No importará si un servicio está codificado en Java o .NET, ni si corre en una
plataforma Windows o Linux: lo importante será que respeten los estándares del protocolo sobre el cual está construido,
del mismo modo que ocurre con los servidores web.

Tipos de servicios web

A día de hoy existe una gran variedad de protocolos sobre los que los servicios web pueden operar, pero son dos los
protocolos estrella que la práctica totalidad de los servicios web utilizan hoy día:

 SOAP: Simple Object Access Protocol. Creado en 1998, se sirve de mensajes XML para el intercambio de
mensajes. Puede operar sobre cualquier protocolo de transporte, aunque lo más común es que lo haga sobre
HTTP o HTTPS. Es el protocolo más común en servicios web de carácter privado.

 REST: REpresentational State Transfer. Concepto surgido en el año 2000, hace uso del protocolo HTTP para el
envío de mensajes, y puede utilizar lenguajes como XML o JSON.

SOAP
Este protocolo, como ya hemos dicho, utiliza XML como lenguaje de codificación, y su principal ventaja es que es
agnóstico respecto a la capa de transporte, es decir, que puede ser transmitido a través de HTTP, TCP/IP, SMTP o cualquier
otro, a diferencia de REST que únicamente opera sobre HTTP/HTTPS.

Su estructura recuerda vagamente a la de un documento HTML, constando de una cabecera (header) que implementará
los metadatos del mensaje (opciones de seguridad, protocolo, transaccionalidad…) y de un cuerpo (body) que contendrá el
mensaje en sí. Todo ello irá encapsulado dentro de un sobre (envelope). Un ejemplo de mensaje SOAP podría ser el
siguiente:

1 <?xml version='1.0' ?>

2 <soap:Envelope xmlns:soap="[Link]
3
4 <soap:Header>
5 <!-- Metadatos -->
6 </soap:Header>
7
8 <soap:Body xmlns:c="[Link]
9 <c:ObtenerNombreCliente>
10 <c:IdCliente>61</c:IdCliente>
11 </c:ObtenerNombreCliente>
12 </soap:Body>
13
14 </soap:Envelope>
 REST
Su filosofía se basa en la ausencia de estado y la “equivalencia” entre los cuatro verbos que pueden utilizarse en el
protocolo HTTP y las cuatro operaciones CRUD (Create, Read, Update, Delete) básicas que pueden realizarse sobre una
fuente de datos. Es el protocolo más utilizado en servicios web abiertos o públicos.

 GET ↔ SELECT (Obtener)

 POST ↔ INSERT (Crear)
 PUT ↔ UPDATE (Actualizar)
 DELETE ↔ DELETE (Borrar)

En la pequeña introducción que vimos hace un par de días acerca de Entity Framework + Webservices vimos un pequeño
ejemplo de cómo se hace uso de REST para generar y consumir un servicio. Así, para recuperar un cliente realizaríamos una
petición como la siguiente:

 GET [Link]

Una eliminación sería similar, pero haciendo uso del verbo DELETE:

 DELETE [Link]

SOA
Una vez que hemos descubierto las dos principales tipos de servicios web (SOAP y RESTful), es hora de hablar de SOA.
Seguro que muchos hemos oído hablar de SOA, pero ¿de qué se trata? SOA son las siglas de Service-Oriented Architecture,
es decir, Arquitectura Orientada a Servicios.

SOA se basa en organizar una aplicación en unidades funcionales que pueden ser gestionadas por distintos proveedores
e incluso compañías de modo que puedan ser accedidas de un modo homogéneo. Por lo tanto, SOA no habla acerca de la
tecnología a utilizar, como REST o SOAP, sino lo que conceptualmente debería ser un modelo de comunicaciones
distribuido.

WCF entra en escena

Tras una serie de acercamientos a los servicios web utilizando SOAP y servicios web de extensión asmx, Microsoft
publica finalmente Windows Communication Foundation. Su objetivo básico era el de unificar las comunicaciones. Ya no
importará que nuestra aplicación distribuida se comunique a través de TCP en unos servicios, SOAP en otros y REST en
otros: WCF soporta todos estos protocolos, y permitirá que nuestro código sea independiente del protocolo que vayamos
a utilizar.

¿Cómo logra WCF esta independencia? Básicamente, mediante la separación entre operaciones y datos. Al igual que
hacemos uso de interfaces en nuestro código para aislar la firma de los métodos de sus implementaciones (ver este artículo
para refrescar estos conceptos), un servicio web WCF utiliza este mismo concepto: establece un contrato a través de una
interfaz (que será adornado con atributos específicos) que una clase se encargará de implementar. De este modo, un
servicio WCF, se compondrá, a grandes rasgos, de:

 Contrato de servicio (ServiceContract): expone una operación que nuestro servicio web es capaz de ejecutar.
Corresponde a una interfaz.
 Contrato de datos (DataContract): implementa un tipo de dato que el servicio web será capaz de manejar.
Generalmente, será el tipo de dato que manejará el contrato de servicio.
 Implementación del servicio: implementará la interfaz correspondiente al contrato de servicio, haciendo uso del
contrato de datos para intercambiar la información.
 En cuanto a la comunicación, se realizará mediante la configuración de los denominados endpoints, a través de un
simple archivo XML. Un endpoint no es más que la dirección de un servicio, que implementa un protocolo determinado. Así,
en el siguiente ejemplo tendríamos un único servicio que puede comunicarse de tres formas distintas a través de tres
endpoints diferentes:

1 <?xml version='1.0' ?>

2 <configuration>
3 <[Link]>
4 <services>
5 <service name='GestionPedidosDataService'>
6 <endpoint address='[Link]
7 binding='webHttpBinding'
8 contract='IServiceContract' />
9 <endpoint address='[Link]://localhost:9043/GestionPedidosTcpService'
10 binding='netTcpBinding'
11 contract='IServiceContract' />
12 <endpoint address='[Link]://localhost/GestionPedidosMsmqService'
13 binding='netMsmqBinding'
14 contract='IServiceContract' />
15 </service>
16 </services>
17 </[Link]>
18 </configuration>

El primer endpoint realizará su comunicación a través de HTTP utilizando REST. Los otros dos endpoints realizarán el
mismo trabajo que el primero, pero usarán los protocolos TCP y MSMQ utilizando SOAP. Como podemos observar, tan sólo
ha sido necesario codificar una sola vez la funcionalidad del servicio web, creando en un momento tres formas distintas de
realizar la comunicación.

Con esto podemos entender el éxito de WCF en la plataforma .NET: permite olvidarse del transporte y centrarse en la
codificación de la lógica del servicio, ahorrando una enorme cantidad de tiempo y recursos y simplificando enormemente la
interoperabilidad, ya que, si en un determinado momento es necesario un protocolo determinado para comunicarse con un
cliente preexistente, basta con configurar un endpoint para que ese cliente pueda acceder a nuestro servicio en lugar de
codificar toda la lógica de comunicaciones que implicaría un servicio web convencional.

A lo largo de los siguientes artículos aprenderemos a implementar distintos tipos de servicios web haciendo uso de WCF,
profundizando un poco más en las posibilidades que esta tecnología nos ofrece.
 Creación de un servicio web simple
Comprendidos los principios sobre los que se basa Windows Communication Foundation, es momento de crear un
pequeño servicio básico que maneje una lista interna de clientes. No haremos uso de bases de datos, puesto que el objetivo
principal de este artículo es centrarnos en la comunicación. El último artículo dedicado a Entity Framework desarrolla,
precisamente, un ejemplo más específico del uso de Entity Framework para desarrollar un servicio web RESTful mediante
WCF.

Como vimos en el artículo anterior, a grandes rasgos un servicio WCF se compondrá de cuatro elementos:

 Contrato de datos: estructura de datos que será intercambiada por el servicio.

 Contrato de servicio: interfaz que expondrá los métodos que pueden ser invocados por el cliente.
 Implementación del servicio: codificación del contrato de servicio, incorporará la lógica interna del servicio.
 Configuración: archivo XML con información sobre dirección, nombre o protocolo.

Comenzaremos creando el servicio para pasar, a continuación, por el primero de estos elementos: el contrato de datos.

Creación del servicio

Para comenzar la codificación de nuestro servicio, crearemos un nuevo proyecto WCF, específicamente del tipo WCF
Service Library, que generará una biblioteca DLL que contendrá la funcionalidad del servicio.

Visual Studio creará ahora un esqueleto de nuestro primer servicio web, que tendrá un aspecto similar al siguiente:
 Estos archivos tendrán los nombres [Link] y [Link]. Comenzaremos eliminando estos archivos y creando el
primero de los elementos que conformará el servicio.

Contrato de datos (DataContract)

Añadiremos una nueva clase que simbolizará la estructura de datos que nuestro servicio web intercambiará con un
potencial cliente: el DataContract o contrato de datos. Llamaremos a la clase [Link].

Esta información no será más que un POCO (Plain Old CLR Object) que contendrá los campos que queremos enviar a
través de la red. Un POCO no es más que una estructura simple, sin funcionalidad, que contiene una serie de campos que
normalmente simbolizará un registro en una base de datos relacional desde una perspectiva orientada a objetos. A nivel
estructural equivaldría a los struct de C.

Por tanto, haremos la clase pública y añadiremos los campos que queremos exponer, que también tendrán visibilidad
pública.
 1 namespace WcfServices
2 {
3 public class Cliente
4 {
5 public int IdCliente;
6 public string Nombre;
7 public DateTime FechaNacimiento;
8 }
9 }

Para que nuestro POCO adquiera la categoría de contrato de datos, será necesario adornar la clase y sus elementos con
un par de atributos heredados de [Link]. Por lo tanto, añadimos el using correspondiente y
asignamos el atributo DataContract a la clase y el atributo DataMember a cada uno de los elementos de la clase.

1 namespace WcfServices
2 {
3 [DataContract] // [Link]
4 public class Cliente
5 {
6 [DataMember]
7 public int IdCliente;
8
9 [DataMember]
10 public string Nombre;
11
12 [DataMember]
13 public DateTime FechaNacimiento;
14 }
15 }

Contrato de Servicio (ServiceContract)

El segundo elemento que deberemos configurar será el contrato de servicio, interfaz que contendrá la firma de los
métodos que el servicio expondrá de forma pública. Añadiremos, por lo tanto, una nueva interfaz a la que llamaremos
IClienteService.

Esto hará que se cree una interfaz vacía con el siguiente aspecto:
 1 namespace WcfServices
2 {
3 interface IClienteService
4 {
5 }
6 }

Nuevamente, haremos la interfaz pública, y añadiremos la firma de los métodos que queremos que esta incluya. Para
este caso concreto, crearemos un método de recuperación, otro de inserción, otro de modificación y un último método de
eliminación. Recordemos que en una interfaz no debemos indicar la visibilidad de los métodos que ésta incluye.

1 namespace WcfServices
2 {
3 interface IClienteService
4 {
5 List<Cliente> ObtenerClientes();
6 void InsertarCliente(Cliente c);
7 void ModificarCliente(Cliente c);
8 void EliminarCliente(int id);
9 }
10 }

Por último, importaremos el espacio de nombres [Link] y adornaremos la interfaz con el atributo
ServiceContract. Los métodos de la interfaz, por su parte, irán adornados con el atributo OperationContract, ya que
establecerán el contrato de las operaciones que el servicio puede realizar.

1 namespace WcfServices
2 {
3 [ServiceContract] // [Link]
4 interface IClienteService
5 {
6 [OperationContract]
7 List<Cliente> ObtenerClientes();
8
9 [OperationContract]
10 void InsertarCliente(Cliente c);
11
12 [OperationContract]
13 void ModificarCliente(Cliente c);
14
15 [OperationContract]
16 void EliminarCliente(int id);
17 }
18 }

Implementación del contrato

Contando con datos y operaciones, es el momento de codificar una clase que implemente la interfaz que define el
contrato de servicio con sus correspondientes operaciones. Por lo tanto, crearemos una nueva clase, a la que
denominaremos ClienteService, que implemente la interfaz IClienteService.

1 namespace WcfServices
2 {
3 class ClienteService : IClienteService
4 {
5 }
6 }

Para que Visual Studio genere el cuerpo de las funciones que debemos implementar, haremos click derecho sobre el
nombre de la interfaz y seleccionaremos la opción Implement Interface.
 Esto hará que se genere el código correspondiente a la firma de los métodos de la interfaz, indicándonos qué es lo que
debemos codificar.

1 class ClienteService : IClienteService

2 {
3 public List<Cliente> ObtenerClientes()
4 {
5 throw new NotImplementedException();
6 }
7
8 public void InsertarCliente(Cliente c)
9 {
10 throw new NotImplementedException();
11 }
12
13 public void ModificarCliente(Cliente c)
14 {
15 throw new NotImplementedException();
16 }
17
18 public void EliminarCliente(int id)
19 {
20 throw new NotImplementedException();
21 }
22 }

Nuevamente, importaremos el espacio de nombres [Link] y asignaremos el atributo ServiceBehavior a la

clase. Además, crearemos un atributo estático de carácter privado que simbolizará nuestra fuente de datos. Consistirá en
una lista de clientes sobre las que realizaremos las operaciones del servicio.

1 [ServiceBehavior]
2 public class ClienteService : IClienteService
3 {
4 private static List<Cliente> listaClientes = new List<Cliente>();

El atributo ServiceBehavior puede aceptar parámetros que permite configurar aspectos específicos del servicio, como el
tipo de concurrencia o si el servicio funcionará en modo singleton. Pueden consultarse en la MSDN aquí.
 Finalmente, añadimos la funcionalidad deseada a cada método. Por ejemplo, codificaríamos algo como lo siguiente:

1 [ServiceBehavior]
2 public class ClienteService : IClienteService
3 {
4 private static List<Cliente> listaClientes = new List<Cliente>();
5
6 public List<Cliente> ObtenerClientes(Cliente c)
7 {
8 return listaClientes;
9 }
10
11 public void InsertarCliente(Cliente c)
12 {
13 // Calculamos el ID del siguiente elemento
14 if ([Link] == 0)
15 [Link] = 1;
16 else
17 [Link] = [Link](cliente => [Link]) + 1;
18
19 // Añadimos el cliente a la lista
20 [Link](c);
21 }
22
23 public void ModificarCliente(Cliente c)
24 {
25 // Recuperamos el cliente cuyo ID coincide con el pasado como parámetro
26 Cliente clienteModif = [Link](cliente => [Link] ==
[Link]).First();
27
28 // Si el registro existe, se modifica
29 if (clienteModif != null)
30 {
31 [Link] = [Link];
32 [Link] = [Link];
33 }
34 }
35
36 public void EliminarCliente(int id)
37 {
38 // Recuperamos el cliente cuyo ID coincide con el pasado como parámetro
39 Cliente clienteEliminar = [Link](cliente => [Link] == id).First();
40
41 // Si el registro existe, se elimina
 42 if (clienteEliminar != null)
43 [Link](clienteEliminar);
44 }
45 }

Con esto concluiríamos la codificación del servicio. Sólo nos quedan dos pasos: configurar los endpoints y realizar una
prueba para comprobar su funcionamiento. En realidad faltaría un tercer paso, su despliegue, pero esto lo dejaremos para
una ocasión posterior.

Configuración
Para accede a la configuración del servicio, podemos editar directamente el archivo de configuración [Link] /
[Link] o bien podemos dejar que el asistente nos facilite esta tarea. Para acceder a él, haremos click derecho sobre el
[Link] y seleccionaremos la opción Edit WCF Configuration.

Esto abrirá un diálogo que nos mostrará la configuración de nuestro servicio, mostrando dos endpoints. Sin embargo, la
configuración que se nos muestra es la configuración inicial generada al crear el proyecto, por lo que no nos será de mucha utilidad.

Para solucionarlo, comenzaremos por compilar el servicio web de modo que se genere el archivo dll objetivo.
 Hecho esto, seleccionaremos el servicio preconfigurado y pulsaremos el botón […] que se muestra a la derecha del
nombre del servicio cuando éste es seleccionado.

A continuación buscaremos la dll que acabamos de generar. La encontraremos en el directorio /bin/Debug de nuestro
proyecto.

Esto hará que el nombre del servicio cambie, mostrando la configuración correspondiente al servicio que hemos
codificado.
 Desplegaremos la carpeta Endpoints y seleccionaremos el primero de ellos, realizando el mismo proceso de seleccionar
el archivo dll para localizar el contrato del servicio.

Si desplegamos el combo Binding podremos observar todas las posibilidades que WCF nos oferta como métodos de
enlace. Sin embargo, también dejaremos esto para posteriores artículos, seleccionando el valor por defecto,
basicHttpBinding.
 Prueba
Si pulsamos F5, una vez guardada la configuración, se lanzará el cliente de prueba del servicio. Este cliente es generado
automáticamente por Visual Studio, y nos permite realizar invocaciones a los métodos expuestos por el servicio a través de
una interfaz de usuario.

Haremos doble click sobre el método InsertarCliente e introduciremos los datos solicitados. Hecho esto, pulsaremos el
botón Invoke, que hará que se ejecute el método del servicio y se obtenga la respuesta correspondiente, en caso de que
ésta exista. Repetiremos el proceso un par de veces más para que la lista mantenida en el servidor tenga datos con los que
realizar pruebas.
 Si hacemos doble click sobre ObtenerClientes(), la respuesta no se mostrará vacía, sino que estará compuesta por un
listado de objetos Cliente. Recordemos que Cliente es en este caso el contrato de datos que es intercambiado mediante los
métodos expuestos por el contrato de servicio.

La modificación también solicitará un objeto de la clase cliente, que cambiará los datos del Cliente cuyo ID coincida con
el incluido dentro del objeto.

Si realizamos una nueva consulta, veremos que, efectivamente, los datos se han actualizado.

Finalmente, la eliminación solicitará un entero con el ID del elemento a eliminar. Procedemos, por lo tanto, a
proporcionárselo y a invocar el servicio.

Si volvemos a consultar, comprobamos que, efectivamente, el registro habrá sido eliminado de la lista.
 Para finalizar con la introducción, el cliente de prueba de WCF nos permite comprobar también el contenido de los
mensajes. En este caso, se trata de mensajes SOAP. Como podremos recordar del artículo anterior, el mensaje SOAP se
componía de un envoltorio (envelope) que contiene una cabecera (header) y un cuerpo (body). El resultado de la petición y
de la respuesta será el siguiente:
 Creación de un cliente de un webservice
Ahora que ya hemos creado nuestro primer servicio, es el momento de consumirlo. Al igual que hicimos en ejemplos
anteriores, comenzaremos creando un nuevo proyecto, por ejemplo de consola.

Es importante tener a mano la dirección del servicio, ya que nos hará falta para referenciarlo. Si estamos desarrollando
el cliente en el mismo equipo en el que desarrollamos el webservice, bastará con copiar la dirección del WCF Test Client que
Visual Studio creará por nosotros y que vimos en el artículo anterior.

Seleccionaremos la sección References del proyecto y haremos click derecho sobre ella, seleccionando la opción Add
Service Reference… para añadir una referencia de servicio.
 En el campo Address (dirección), insertaremos el valor que copiamos previamente. El hecho de que la dirección termine
en mex indica que se trata el servicio de metadatos creado por defecto, que proporcionará la información sobre el resto de
endpoints del servicio web. Más adelante profundizaremos en el concepto de endpoint y aprenderemos qué son, cómo
configurarlos y cómo acceder a ellos.

Al pulsar el botón Go, se mostrarán los contratos de servicio disponibles junto a las operaciones que éstos pueden
ejecutar. Asignaremos un nombre al espacio de nombres del cliente y pulsaremos el botón Ok.

Si echamos un vistazo a nuestro archivo [Link], veremos que se ha añadido una nueva sección [Link]
que incluye información sobre el servicio web que acabamos de referenciar, mostrando un endpoint que cumple con los
elementos ABC (Address, Binding, Contract). Toda esta información será recabada automáticamente del servicio web de
metadatos mex referenciado en el paso anterior, por lo que no será necesario codificar absolutamente nada.

1 <[Link]>
2 <bindings>
3 <basicHttpBinding>
4 <binding name="BasicHttpBinding_IClienteService" />
5 </basicHttpBinding>
6 </bindings>
7 <client>
8 <endpoint address="[Link]
9 binding="basicHttpBinding"
bindingConfiguration="BasicHttpBinding_IClienteService"
10 contract="[Link]"
name="BasicHttpBinding_IClienteService" />
11 </client>
12 </[Link]>
 A continuación añadiremos la cláusula using que incluirá la referencia del servicio (espacio de nombres del proyecto + . +
nombre que indicamos en el asistente al crear la referencia) e instanciaremos un cliente del servicio, pasándole como
parámetro el nombre del endpoint al que queremos conectar.

Este nombre podemos consultarlo en el archivo [Link] a partir del atributo name del endpoint correspondiente. En
nuestro caso será BasicHttpBinding_IClienteService.

1 using [Link];
2
3 namespace WCFSimpleClient
4 {
4 class Program
5 {
7 static void Main(string[] args)
8 {
9 ClienteServiceClient servicioCliente = new
ClienteServiceClient("BasicHttpBinding_IClienteService");
10 }
11 }
12 }

Ahora procederemos a realizar las mismas operaciones que realizamos de forma manual con el cliente de prueba.
Comenzaremos instanciando tres nuevos clientes.

1 [Link]("INSERCIÓN\n-----------------------------");
2 Cliente carlos = new Cliente()
3 {
4 Nombre = "Carlos Garcia Castaño",
5 FechaNacimiento = new DateTime(1980, 2, 2)
6 };
7
8 Cliente ana = new Cliente()
9 {
10 Nombre = "Ana Gonzalez Sierra",
11 FechaNacimiento = new DateTime(1981, 2, 22)
12 };
13
14 Cliente luis = new Cliente()
15 {
16 Nombre = " Luis Coria Chamorro ",
17 FechaNacimiento = new DateTime(1974, 6, 12)
18 };

Una vez creados los objetos, invocamos el método InsertarCliente del servicio web referenciado pasándoselos como
parámetro, y realizaremos una invocación a ObtenerClientes() para comprobar que todo es correcto.

1 [Link](carlos);
2 [Link](ana);
3 [Link](luis);
4
5 [Link]("CONSULTA\n-----------------------------");
6 var resultado = [Link]();
7
8 foreach (Cliente c in resultado)
9 {
10 [Link]([Link]("\tID: {0}\tNOMBRE: {1}\t CUMPLEAÑOS: {2}/{3}", [Link],
[Link], [Link], [Link]));
11 }

Realizaremos el mismo proceso con el método ModificarCliente() tras modificar, por ejemplo, el nombre de uno de los
objetos que previamente recuperaremos del listado.
 1 [Link]("MODIFICACIÓN \n-----------------------------");
2 Cliente clienteModif = [Link]();
3 [Link] = [Link] + " MODIFICADO";
4 [Link](clienteModif);
5 resultado = [Link]();
6
7 foreach (Cliente c in resultado)
8 {
9 [Link]([Link]("\tID: {0}\tNOMBRE: {1}\t CUMPLEAÑOS: {2}/{3}", [Link],
[Link], [Link], [Link]));
10 }

Por ultimo, eliminaremos el segundo registro pasándole el identificador del cliente al método EliminarCliente().

1 [Link]("ELIMINACIÓN\n-----------------------------");
2 Cliente clienteEliminar = [Link](1).First();
3 [Link]([Link]);
4 resultado = [Link]();
5
6 foreach (Cliente c in resultado)
7 {
8 [Link]([Link]("\tID: {0}\tNOMBRE: {1}\t CUMPLEAÑOS: {2}/{3}", [Link],
[Link], [Link], [Link]));
9 }

Si ejecutamos nuestro programa a partir del código anterior, se mostrará lo siguiente:

Creación del cliente mediante [Link]

Al igual que la herramienta [Link] servía para generar código de forma automática a partir de la dirección de una
base de datos, Visual Studio nos proporciona una herramienta que automatiza la creación de un cliente a partir de la
dirección mex de un servicio web de una forma similar, denominada [Link]. Para hacer uso de esta orden, abriremos en
primer lugar la consola de desarrollo de Visual Studio.
 A continuación, nos dirigiremos a la ruta donde queremos crear nuestro cliente y escribiremos lo siguiente:

[Link] <dirección del endpoint mex>

Esto hará que se generen dos archivos: una clase cliente junto a un archivo de configuración.

Ambos archivos contendrán la funcionalidad necesaria (código y configuración) para realizar una conexión al servicio
web, tal y como hacía la referencia al servicio de forma implícita.
 Como podemos observar, también contienen la codificación de las invocaciones a los métodos del servicio.

1 public [Link][] ObtenerClientes()

2 {
3 return [Link]();
4 }
5
6 public [Link]<[Link][]> ObtenerClienteAsync()
7 {
8 return [Link]();
9 }
10
11 public void InsertaCliente([Link] c)
12 {
13 [Link](c);
14 }
15
16 public [Link] InsertarClienteAsync([Link] c)
17 {
18 return [Link]();
19 }

En el siguiente artículo ampliaremos el concepto de endpoint y aprenderemos a crearlos, modificarlos y (sobre todo)
entender un poco mejor de qué se tratan.