Descripción:
En este artículo te voy a explicar cómo
definir una clase dentro de un servicio Web para usarla desde los métodos Web
expuestos, así como una aplicación cliente que utilice esa clase.
Además veremos cómo trata los servicios Web la sobrecarga de métodos y como
podemos solucionarlo.
Introducción:
Realmente no tiene
ningún misterio, pero el hecho de mostrar este código es para que sepas que se
puede hacer, ya que me he topado con gente que se "comen el coco" para hacer
algo parecido, y, como algunas veces nos pasa, buscando la solución por el
lado más complicado.
Básicamente lo que tenemos que hacer es
simplemente definir la clase en el propio servicio Web, aunque esa clase tenga
los miembros típicos de cualquier clase: Métodos, propiedades, etc. Desde
fuera del servicio Web sólo podremos usar los campos públicos o las
propiedades (que a la hora de usarlos se convertirán en campos públicos), pero
no los métodos, aunque desde dentro del propio servicio Web si que podemos
acceder a esos métodos y poder crear un método Web que nos lo devuelva.
En nuestro ejemplo utilizaremos una clase Colega que tendrá varias propiedades:
Nombre, Apellidos, Edad y Correo. Además de tres constructores, uno sin
parámetros, que será el único que podremos usar desde fuera del servicio Web, y los otros con parámetros para asignar algunos valores de las
propiedades.
También añadiremos un método ToString el cual devolverá el nombre y los
apellidos, pero que nosotros no podremos usarlo directamente desde la
aplicación cliente.
Crear un servicio Web que define una clase
El servicio Web que vamos a crear es muy simple, por tanto lo haremos "manualmente", es decir sin
ayuda del Visual Studio .NET, el cliente si lo haremos con el Visual Studio,
para ver cómo agregar la referencia Web, actualizarla, etc.
El servicio Web tendrá
varios métodos para acceder a esa clase o para recibir un objeto de la clase
definida en el propio servicio Web. La clase como comenté anteriormente tendrá
unas propiedades y un método, aunque será fácil añadirle nuevos métodos, por
ejemplo para actualizar los datos en una tabla de una base de datos o para
recuperar esos datos; aunque, como he comentado antes, no podremos acceder a
esos métodos directamente, sino que tendremos que hacerlo por medio de los
métodos Web expuestos por la clase usada para crear el servicio Web.
Lo primero será crear un fichero con extensión .asmx, al que
llamaremos ColegaSW.asmx y que contendrá el código mostrado más abajo:
el de VB y el de C#.
Cabe destacar
que el código del servicio Web tiene dos métodos que se llaman igual, pero
esto no puede "soportarlo" un servicio Web, ya que cada método debe llamarse
de forma diferente, (es como si los servicios Web no soportaran la sobrecarga
de métodos). Para solucionarlo, le añadimos al atributo WebMethod, la
propiedad MessageName a la que le asignamos un nombre, que será
distinto para cada uno de los métodos, pero el nombre del método permanece
igual, y de hecho, desde nuestra aplicación lo usaremos tal y como está
definido en la clase, aunque los nombres que exportará el servicio Web serán
los indicados en MessageName.
Publicar el servicio Web en el servidor local
Ahora lo que tenemos que hacer es copiar en el "localhost"
el servicio Web que hemos creado.
El servidor local, normalmente está en
la misma unidad que Windows, en una carpeta llamada wwwroot que estará dentro
de InetPub. Pues simplemente copiamos el fichero con el servicio Web en esa
carpeta y ya estará disponible para usarlo.
Nota:
Una vez que tenemos el servicio Web publicado en el locaslhost, podremos usar
indistintamente el que hemos hecho en Visual Basic o en C#, ya que el cliente
que lo vaya a utilizar no le importará en que lenguaje esté escrito, por la
sencilla razón de que el .NET Framework lo compilará para poder usarlo. Y como
sabemos, en .NET podemos usar ensamblados compilados con cualquier lenguaje de
.NET desde cualquier proyecto creado con cualquier lenguaje.
Crear un cliente con Visual Studio .NET que utilice el servicio Web
Bien, ahora vamos a crear una aplicación de tipo Windows
Forms que utilice el servicio Web.
Así que, abre el Visual Studio .NET y
crea un nuevo proyecto del tipo Aplicación para Windows, en el lenguaje que
quieras.
Yo lo voy a crear en los dos lenguajes, al de Visual Basic lo
llamaré: tColegaSW_VB y al de C#: tColegaSW_CS.
Como es una aplicación
de Windows, tendremos un formulario listo para usar, vamos a añadirle una
serie de controles, en particular cinco etiquetas, cuatro cajas de textos y un
botón. Cuatro de las etiquetas las usaremos para indicar que dato se debe
incluir en las cajas de textos. El botón lo usaremos para crear un nuevo
objeto del tipo Colega con los datos introducidos, y después de crearlo
llamaremos al método Hola del servicio Web pasándole el objeto del coleguilla
que acabamos de crear y el resultado devuelto de esa función se mostrará en la
otra etiqueta.
El diseño del formulario será este:
Figura 1. El formulario de la aplicación cliente
El código de ese botón es realmente simple, pero antes debemos añadir una referencia
Web, la cual apuntará al servicio Web que acabamos de copiar en el localhost.
Por tanto el sitio en el que tenemos que localizar ese servicio Web es en
nuestro servidor local.
Para añadir la referencia Web, pulsa en el icono
References que estará en el Explorador de Soluciones, selecciona
Referencia Web y cuando te muestre el cuadro de diálogo para localizar el
servicio Web escribe: http://localhost/ColegaSW.asmx y te aparecerá lo
mismo que en la figura 2:
Figura 2. Añadir una referencia al servicio Web
Pulsa en el
botón agregar referencia, (deja el nombre predeterminado), y ya tendremos
acceso al servicio Web, además que el propio Visual Studio .NET se habrá
encargado de añadir una nueva referencia al proyecto: System.Web.Services,
con idea de que pueda comunicarse con el servicio Web.
Ahora debemos
agregar una importación al espacio de nombres "localhost" para poder acceder a
la clase que contiene el servicio Web.
En VB añade esta línea:
Imports tColegaSW_VB.localhost
En C# añade
esta línea: using tColegaSW_CS.localhost;
Y ya solo nos queda escribir el código del evento Click del botón, el cual se
encargará de crear un nuevo objeto del servicio Web, llamará al método que
recibe los cuatro parámetros y devolverá un objeto del tipo Colega, el cual lo
podemos usar para pasarlo como parámetro del método Hola de nuestro servicio
Web o bien llamar a los métodos que tenga, como por ejemplo: ToString.
Aquí tienes el código para VB y aquí
está el de C# del evento Click del botón.
Resumiendo que es gerundio
Y esto es todo, a que no es tan complicado, lo que pasa
que hay que saber hacerlo, je, je. Y para eso están las páginas del Guille,
pa enseñarte a hacer las cosas... ;-)
Ya queda en ti añadirle más cosas y hacer tus propias pruebas. Pero si modificas el servicio Web,
acuérdate de "actualizar" la referencia Web, para que el Visual Studio .NET
actualice el contenido del servicio Web.
¡A disfrutarlo!
Nos vemos.
Guillermo
Nerja, 30-31 de Julio de 2005
El código para Visual Basic .NET (cualquier versión)
El servicio Web: ColegaSW.asmx
<%@ WebService Language="VB" Class="ColegaSW" %>
Imports System
Imports System.Web.Services
<WebService(Namespace := "http://elguille/WebServices/")> _
Public Class ColegaSW
' Estos dos métodos permitirán crear nuevos Colegas
' Se usarán los constructores apropiados al número de parámetros
'
' Los métodos Web no admiten sobrecarga, deben llamarse de forma diferente
'
<WebMethod(Description := "Devuelve un nuevo Colega", MessageName := "NuevoColega2")> _
Public Function NuevoColega(nombre As String, apellidos As String) As Colega
Return New Colega(nombre, apellidos)
End Function
'
<WebMethod(Description := "Devuelve un nuevo Colega", MessageName := "NuevoColega4")> _
Public Function NuevoColega( _
nombre As String, apellidos As String, _
correo As String, edad As Integer) As Colega
Return New Colega(nombre, apellidos, correo, edad)
End Function
'
<WebMethod(Description := "Saluda al Colega pasado en el parámetro")> _
Public Function Hola(co As Colega) As String
Return "Hola, " & co.Nombre
End Function
End Class
'---------------------------------------------
' La clase Colega definida en el servicio Web
'---------------------------------------------
Public Class Colega
' Los campos privados para usar con las propiedades
Private _Nombre As String
Private _Apellidos As String
Private _Correo As String
Private _Edad As Integer
' Campo público de solo lectura
Public ReadOnly Creado As DateTime
'
'-----------------
' Las propiedades
'-----------------
Public Property Nombre() As String
Get
Return _Nombre
End Get
Set(value As String)
_Nombre = value
End Set
End Property
Public Property Apellidos() As String
Get
Return _Apellidos
End Get
Set(value As String)
_Apellidos = value
End Set
End Property
Public Property Correo() As String
Get
Return _Correo
End Get
Set(value As String)
_Correo = value
End Set
End Property
Public Property Edad() As Integer
Get
Return _Edad
End Get
Set(value As Integer)
_Edad = value
End Set
End Property
'
'-------------
' Los Métodos
'-------------
' El método ToString devuelve el nombre y apellidos
Public Overrides Function ToString() As String
Return Nombre & " " & Apellidos
End Function
'
'-------------------
' Los constructores
'-------------------
' En el constructor sin parámetros asignamos la fecha de creación de la clase
Public Sub New()
Creado = DateTime.Now
End Sub
'--------------------------------------------------------------------------
' Los constructores con parámetros para usar dentro del servicio Web
'--------------------------------------------------------------------------
' Desde este constructor llamamos al que no recibe parámetros
Public Sub New(nombre As String, apellidos As String)
Me.New()
Me.Nombre = nombre
Me.Apellidos = apellidos
End Sub
' Desde este constructor llamamos al que recibe dos parámetros
Public Sub New(nombre As String, apellidos As String, correo As String, edad As Integer)
Me.New(nombre, apellidos)
Me.Correo = correo
Me.Edad = edad
End Sub
End Class
El cliente de VB que utiliza el servicio Web
' Creamos un objeto del servicio Web
Dim ws As New ColegaSW
' Creamos un nuevo objeto del tipo Colega
Dim co As Colega = ws.NuevoColega( _
txtNombre.Text, txtApellidos.Text, _
txtCorreo.Text, CInt(txtEdad.Text))
' y lo usamos como parámetro para el saludo
label3.Text = ws.Hola(co)
El código para C# (cualquier versión)
El servicio Web: ColegaSW.asmx
<%@ WebService Language="C#" Class="ColegaSW" %>
using System;
using System.Web.Services;
[WebService(Namespace = "http://elguille/WebServices/")]
public class ColegaSW
{
// Estos dos métodos permitirán crear nuevos Colegas
// Se usarán los constructores apropiados al número de parámetros
//
// Los métodos Web no admiten sobrecarga, deben llamarse de forma diferente
//
[WebMethod(Description = "Devuelve un nuevo Colega", MessageName = "NuevoColega2")]
public Colega NuevoColega(string nombre, string apellidos)
{
return new Colega(nombre, apellidos);
}
//
[WebMethod(Description = "Devuelve un nuevo Colega", MessageName = "NuevoColega4")]
public Colega NuevoColega(string nombre, string apellidos, string correo, int edad)
{
return new Colega(nombre, apellidos, correo, edad);
}
//
[WebMethod(Description = "Saluda al Colega pasado en el parámetro")]
public string Hola(Colega co)
{
return "Hola, " + co.Nombre;
}
}
//---------------------------------------------
// La clase Colega definida en el servicio Web
//---------------------------------------------
public class Colega
{
// Los campos privados para usar con las propiedades
private string _Nombre;
private string _Apellidos;
private string _Correo;
private int _Edad;
// Campo público de solo lectura
public readonly DateTime Creado;
//
//-----------------
// Las propiedades
//-----------------
public string Nombre
{
get{ return _Nombre; }
set{ _Nombre = value; }
}
public string Apellidos
{
get{ return _Apellidos; }
set{ _Apellidos = value; }
}
public string Correo
{
get{ return _Correo; }
set{ _Correo = value; }
}
public int Edad
{
get{ return _Edad; }
set{ _Edad = value; }
}
//
//-------------
// Los Métodos
//-------------
// El método ToString devuelve el nombre y apellidos
public override string ToString()
{
return Nombre + " " + Apellidos;
}
//
//-------------------
// Los constructores
//-------------------
// En el constructor sin parámetros asignamos la fecha de creación de la clase
public Colega()
{
Creado = DateTime.Now;
}
//-------------------------------------------------------------------------
// Los constructores con parámetros para usar dentro del servicio Web
//-------------------------------------------------------------------------
// Desde este constructor llamamos al que no recibe parámetros
public Colega(string nombre, string apellidos) : this()
{
this.Nombre = nombre;
this.Apellidos = apellidos;
}
// Desde este constructor llamamos al que recibe dos parámetros
public Colega(string nombre, string apellidos,
string correo, int edad) : this(nombre, apellidos)
{
this.Correo = correo;
this.Edad = edad;
}
}
El cliente de C# que utiliza el servicio Web
// Creamos un objeto del servicio Web
ColegaSW ws = new ColegaSW();
// Creamos un nuevo objeto del tipo Colega
Colega co = ws.NuevoColega(
txtNombre.Text, txtApellidos.Text,
txtCorreo.Text, int.Parse(txtEdad.Text));
// y lo usamos como parámetro para el saludo
label3.Text = ws.Hola(co);
Espacios de nombres usados en el código de este artículo:
System.Web.Services