Consumir servicios web ASP.NET y WCF en Silverlight (Parte 4)

Este artículo es la cuarta parte de una mini serie que intenta enseñarte como crear, publicar y ahora consumir servicios web, el primer artículo habla de la base de datos que has estado usando, puedes ver aquí como crear servicios web ASP.NET y aquí como crear servicios WCF.

Creo que la mejor manera de manejar ambos servicios anteriormente creados es en una sola aplicación, para ahorrar la parte del diseño te dejo una imagen guía.

Pero para ahorrar aún mas, puedes descargar aquí el proyecto de inicio.

Ya con el proyecto inicial, en Visual Studio, da clic derecho sobre tu proyecto y selecciona la opción de “Agregar referencia de servicio”.

En el cuadro de diálogo, comienza con el servicio web ASP.NET, recuerda la URL, algo así como “http://localhost/ServicioASP/Service1.asmx” y después presiona “Go”, deberás ver algo así.

Después de presionar “Ok”, repite la misma operación pero ahora con la liga del servicio WCF.

Hasta aquí, como puedes ver, el procedimiento es exactamente el mismo para ambos tipos de servicios, la diferencia comenzará de aquí en adelante, vamos primero a declarar cada uno de los objetos de los servicios.

//servicioASP
ServicioDatosASP.Service1SoapClient servicioASP = new ServicioDatosASP.Service1SoapClient();

//servicioWCF
ServicioDatosWCF.Service1Client servicioWCF = new ServicioDatosWCF.Service1Client();

Como puedes ver, la diferencia es grande desde aquí, el protocolo de servicio de ASP.NET es SOAP, cuando en WCF utilizas un cliente sin ese protocolo, en los manejadores de eventos para consultar información, tendrás las diferentes líneas.

Consultar Información

Para el servicio ASP.NET necesitas crear primero una clase, de la siguiente forma.

public class NombreContacto
{
public string Nombre { get; set; }
public string Apellidos { get; set; }
public string Telefono { get; set; }
public string Email { get; set; }
}

Y ya con la clase creada, poder usar un evento clic para poder consultar al servicio web.

private void btnObtenerContactosASP_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioASP.MostrarTodosLosContactosCompleted += new EventHandler<serviciodatosasp .MostrarTodosLosContactosCompletedEventArgs>(servicioASP_MostrarTodosLosContactosCompleted);
servicioASP.MostrarTodosLosContactosAsync();
}

void servicioASP_MostrarTodosLosContactosCompleted(object sender, ServicioDatosASP.MostrarTodosLosContactosCompletedEventArgs e)
{
if (e.Error == null)
{
List<nombrecontacto> listaContactos = new List</nombrecontacto><nombrecontacto>();
foreach (string entidad in e.Result)
{
NombreContacto contacto = new NombreContacto();
contacto.Nombre = entidad.Split('|')[1];
contacto.Apellidos = entidad.Split('|')[2];
contacto.Telefono = entidad.Split('|')[3];
contacto.Email = entidad.Split('|')[4];
listaContactos.Add(contacto);
}

dgDatosASP.ItemsSource = listaContactos;
}
}

Por el lado de WCF tendrás lo siguiente.

private void btnObtenerContactosWCF_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioWCF.MostrarTodosLosContactosCompleted += new EventHandler<serviciodatoswcf .MostrarTodosLosContactosCompletedEventArgs>(servicioWCF_MostrarTodosLosContactosCompleted);
servicioWCF.MostrarTodosLosContactosAsync();
}

void servicioWCF_MostrarTodosLosContactosCompleted(object sender, ServicioDatosWCF.MostrarTodosLosContactosCompletedEventArgs e)
{
if (e.Error == null)
{
dgDatosWCF.ItemsSource = e.Result;
}
}

¿Como ves? Una gran diferencia ¿no es así? Bueno, también debes considerar que por el lado de XAML hay una diferencia con los DataGrid que estás usando.

Este es el DataGrid que estamos usando para el servicio web ASP.NET.

<sdk:datagrid x:Name="dgDatosASP" Margin="8,51,401,8" SelectionChanged="dgDatosASP_SelectionChanged"/>

Este es el DataGrid que estamos usando para el servicio WCF.

<sdk:datagrid x:Name="dgDatosWCF" Margin="8,51,401,8" Grid.Row="1" AutoGenerateColumns="False" SelectionChanged="dgDatosWCF_SelectionChanged">
</sdk:datagrid><sdk:datagrid .Columns>
<sdk:datagridtextcolumn Width="130" Header="Nombre" Binding="{Binding Nombre}"/>
<sdk:datagridtextcolumn Width="130" Header="Apellidos" Binding="{Binding APELLIDOS}"/>
<sdk:datagridtextcolumn Width="130" Header="Teléfono" Binding="{Binding TELEFONO}"/>
<sdk:datagridtextcolumn Width="130" Header="Correo electrónico" Binding="{Binding EMAIL}"/>
</sdk:datagrid>

Si lo pongo en palabras sencillas, la lista que recibimos del servicio WCF es la misma lista que alimenta al DataGrid, solo que al hacer un enlazado de datos le estarás diciendo a que columna debe ir que información.

Insertar Información

Para hacer esta operación los métodos requeridos son los siguientes, primero vamos con el servicio web ASP.NET.

private void btnIngresarASP_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioASP.InsertarNuevoContactoCompleted += new EventHandler<serviciodatosasp .InsertarNuevoContactoCompletedEventArgs>(servicioASP_InsertarNuevoContactoCompleted);
servicioASP.InsertarNuevoContactoAsync(txtNombreNuevoASP.Text, txtApellidosNuevoASP.Text, txtTelefonoNuevoASP.Text, txtCorreoNuevoASP.Text);
}

void servicioASP_InsertarNuevoContactoCompleted(object sender, ServicioDatosASP.InsertarNuevoContactoCompletedEventArgs e)
{
if (e.Error == null)
{
txtNombreNuevoASP.Text = string.Empty;
txtApellidosNuevoASP.Text = string.Empty;
txtTelefonoNuevoASP.Text = string.Empty;
txtCorreoNuevoASP.Text = string.Empty;
MessageBox.Show("Tu nuevo contacto ha sido agregado");
}
}

En el caso del servicio WCF, será de la siguiente forma.

private void btnIngresarWCF_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioWCF.InsertarContactoCompleted += new EventHandler<serviciodatoswcf .InsertarContactoCompletedEventArgs>(servicioWCF_InsertarContactoCompleted);
ServicioDatosWCF.Contacto nuevoContacto = new ServicioDatosWCF.Contacto();
nuevoContacto.Nombre = txtNombreNuevoWCF.Text;
nuevoContacto.APELLIDOS = txtApellidosNuevoWCF.Text;
nuevoContacto.TELEFONO = txtTelefonoNuevoWCF.Text;
nuevoContacto.EMAIL = txtCorreoNuevoWCF.Text;
servicioWCF.InsertarContactoAsync(nuevoContacto);
}

void servicioWCF_InsertarContactoCompleted(object sender, ServicioDatosWCF.InsertarContactoCompletedEventArgs e)
{
if (e.Error == null)
{
txtNombreNuevoWCF.Text = string.Empty;
txtApellidosNuevoWCF.Text = string.Empty;
txtTelefonoNuevoWCF.Text = string.Empty;
txtCorreoNuevoWCF.Text = string.Empty;
MessageBox.Show("Tu nuevo contacto ha sido agregado");
}
}

Actualizar información

Para poder modificar elementos de nuestros contactos lo primero que debes hacer es manejar el manejador para el evento SelectionChanged de los respectivos DataGrid.

En el caso de ASP.NET te debe quedar así.

private void dgDatosASP_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
contactoElegidoASP = new NombreContacto();
contactoElegidoASP = dgDatosASP.SelectedItem as NombreContacto;
txtNombreModificarASP.Text = contactoElegidoASP.Nombre;
txtApellidosModificarASP.Text = contactoElegidoASP.Apellidos;
txtTelefonoModificarASP.Text = contactoElegidoASP.Telefono;
txtCorreoModificarASP.Text = contactoElegidoASP.Email;
}

Y en el caso de WCF será así.

private void dgDatosWCF_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
contactoElegidoWCF = new ServicioDatosWCF.Contacto();
contactoElegidoWCF = dgDatosWCF.SelectedItem as ServicioDatosWCF.Contacto;
txtNombreModificarWCF.Text = contactoElegidoWCF.Nombre;
txtApellidosModificarWCF.Text = contactoElegidoWCF.APELLIDOS;
txtTelefonoWCF.Text = contactoElegidoWCF.TELEFONO;
txtCorreoModificarWCF.Text = contactoElegidoWCF.EMAIL;
}

Y en el caso del evento clic de los respectivos botones, te debe quedar de la siguiente manera.

Para el evento del botón de ASP.

private void btnModificarASP_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioASP.ActualizarContactoCompleted += new EventHandler<serviciodatosasp .ActualizarContactoCompletedEventArgs>(servicioASP_ActualizarContactoCompleted);
servicioASP.ActualizarContactoAsync(contactoElegidoASP.ID, txtNombreModificarASP.Text, txtApellidosModificarASP.Text, txtTelefonoModificarASP.Text, txtCorreoModificarASP.Text);
}

void servicioASP_ActualizarContactoCompleted(object sender, ServicioDatosASP.ActualizarContactoCompletedEventArgs e)
{
if (e.Error == null)
{
txtNombreModificarASP.Text = string.Empty;
txtApellidosModificarASP.Text = string.Empty;
txtTelefonoModificarASP.Text = string.Empty;
txtCorreoModificarASP.Text = string.Empty;
MessageBox.Show("Tu registro ha sido actualizado");
}
}

Y para el evento del botón WCF.

private void btnModificarWCF_Click(object sender, System.Windows.RoutedEventArgs e)
{
servicioWCF.ActualizarContactoCompleted += new EventHandler<serviciodatoswcf .ActualizarContactoCompletedEventArgs>(servicioWCF_ActualizarContactoCompleted);
servicioWCF.ActualizarContactoAsync(contactoElegidoWCF);
}

void servicioWCF_ActualizarContactoCompleted(object sender, ServicioDatosWCF.ActualizarContactoCompletedEventArgs e)
{
if (e.Error == null)
{
txtNombreModificarWCF.Text = string.Empty;
txtApellidosModificarWCF.Text = string.Empty;
txtTelefonoWCF.Text = string.Empty;
txtCorreoModificarWCF.Text = string.Empty;
MessageBox.Show("Tu registro ha sido actualizado");
}
}

¡Listo! De esta manera podrás comenzar a hacer grandes aplicaciones, hay muchas “best practices” que debes considerar aquí, en este caso los fines son meramente didácticos, ya solo te falta a ti encontrar la opción de borrar elementos para que puedas comenzar con la base mas importante para poder crear aplicaciones empresariales de la manera mas sencilla posible.

Si tienes alguna duda o error con tu aplicación, puedes descargar el código aquí.

Ya lo sabes, si aún así te estás trabando en algo, solo escríbelo en los comentarios, con gusto veremos cuales son los problemas.