8.23.2011

Nuevo Blog

Como parte del proceso de especialización de este blog – en realidad lo pensé como un blog de arquitectura y desarrollo de software – he decidido abrir otro blog más especializado exclusivamente en el tema de computación en la nube. El blog va a estar disponible desde esta dirección: http://workingonthecloud.wordpress.com/. Esto no quiere decir que voy a dejar de bloguear aquí – de hecho ya viene la parte 2 del problema de concurrencia en el entity framework – si no más bien que cuando escriba de cloud computing – azure, aws, SF, etc lo haré en el nuevo blog.

Espero esta semana empezar a bloguear desde el mismo. Gracias por el apoyo a este blog y espero al que se empieza a crear desde ahora Sonrisa

8.17.2011

Presentación Charla Cloud Computing

Tal y como lo comenté en la charla, la presentación mostrada esta disponible desde el blog. Espero la disfruten.

Etiquetas de Technorati:

8.15.2011

Concurrencia y el Entity Framework – Parte 1

Existen muchos temas que con el pasar del tiempo y las nuevas facilidades que tienen los frameworks que vamos incorporando al proceso del desarrollo del software tendemos a dejar de lado. Uno de estos temas es el manejo de la concurrencia cuando utilizamos el entity framework.

Concurrencia Optimista vrs Concurrencia Pesimista

Existen dos escenarios claves a la hora de manejar la concurrencia en las aplicaciones, el optimista y el pesimista. En el primer caso – el optimista – muchos clientes pueden acceder el registro y de ser el caso modificarlo, eliminarlo o solo consultarlo; en este caso el cliente que haga la última modificación es el que prevalece – excepto por el borrado. En el caso de la concurrencia pesimista un cliente bloquea el acceso a un registro y nadie más puede efectuar una operación sobre el mismo; en este caso, pueden existir variaciones de comportamiento ya que el cliente lo puede bloquear para lectura, por lo tanto otros clientes podrían bloquearlo para lectura también pero no para cambios. Los escenarios pesimistas por lo general son muy complicados de programar – aunque hay situaciones en donde es la única opción. En el caso del Entity Framework se utiliza la concurrencia optimista, por lo que se debe de tener mucho cuidado a la hora de trabajar con este tema.

Trabajando con la Concurrencia Optimista

Para entender mejor el tema, vamos a crear un ejemplo muy simple en donde vamos a ver como reacciona el Entity Framework a la concurrencia. En este ejemplo, vamos a obtener un registro para editar – voy a usar el MVC 3 – y luego desde otra sesión voy a editar el registro y voy a ingresar el dato antes que la primera sesión lo haga.

La tabla que vamos a utilizar es la siguiente:

image

Esta tabla fue generada a partir de los objetos pocos que fueron creados en el proyecto. El objeto POCO que generó esta tabla es el siguiente:

image

Aunque esta tabla tiene una relación a las asignaciones, para este ejemplo no vamos a utilizar dicha relación. Ahora se genera el scaffold para editar, eliminar y modificar un registro del tipo consultor con el MVC, el resultado final es el siguiente:

image

El siguiente código es el de la actualización del registro. Al ser esta una aplicación n-layer se crean instancias del poco y se invocan métodos de la lógica de negocios.

image

Ahora vamos a proceder a interactuar con el sitio web para demostrar que pasa con la concurrencia optimista en el Entity Framework. Para hacer bien claros estos pasos, vamos a usar una instancia en FireFox y la otra en Internet Explorer. La primera acción la hacemos en la instancia de Firefox, de donde solicitamos el registro del consultor para modificarlo. Como podemos ver, vamos a cambiarle el nombre al consultor a Luis Diego Rojas Méndez Sonrisa --> o sea yo.

image

Pero antes de que yo haga clic en guardar desde la sesión de internet Explorer solicito el registro para editar y le cambio el nombre de la siguiente forma.

image

Inmediatamente le doy clic a guardar y el cambio se guarda en la base de datos.

image

El problema es que el registro todavía se esta editando en la sesión de Firefox, por lo que cuando se guarda el registro modificado desde este navegador vamos a sobre escribir el valor escrito desde la sesión de IE9.

image

Si editamos el registro desde el IE9 nos vamos a llevar la sorpresa que los cambios hechos en esta sesión ya no están presentes.

image

Como vemos en el ejemplo anterior, el Entity Framework de salida ofrece solamente concurrencia optimista lo cual puede generar problemas en aplicaciones de tránsito muy alto.

En el próximo post vamos a buscar una solución a este problema.

Etiquetas de Technorati: ,

8.06.2011

Tipos Anónimos y Expresiones Lambda

En post pasados hemos hecho consultas utilizando LinqToEntities o LinqToXml y hemos retornado tipos anónimos en cada consulta. En realidad la necesidad de tener un tipo anónimo viene del hecho de que en algunos casos hacemos consultas que dada su estructura se solicitan unos datos de una fuente y otros datos de otra fuente. Por ejemplo, supongamos que tenemos una tabla para Clientes y otra tabla para Órdenes, y queremos hacer una consulta que me devuelva el nombre del cliente, dirección del cliente y el número de cada orden que el cliente posee. En este caso el escenario sería el siguiente:

image

El modelo del EntityFramework para acceder a estas tablas sería el siguiente:

image

Si hacemos la consulta utilizando LinqToEntities esta luciría de la siguiente forma:

image

Como podemos ver, la hacer un join de las dos tablas, no tenemos un tipo que represente el tipo que queremos obtener, por lo tanto debemos crear un tipo anónimo tal y como se ve en la consulta. La pregunta sería: ¿ cómo lograr lo mismo utilizando expresiones Lambda?

La expresión lambda es un poco más abstracta pero nos da el mismo resultado. El código para hacer la consulta anterior con una expresión lambda es el siguiente:

image

Como vemos en el código anterior, utilizamos el método de extensión join y luego le indicamos con que lista de entidades hacer el join, luego sobre cuales campos se hace el join, y por último creamos el tipo anónimo.

Etiquetas de Technorati: ,

7.27.2011

Métodos de Extensión en .NET

¿A quién no le ha pasado la siguiente situación?

Empiezo a programar un método para que haga X cosa, de pronto me doy cuenta que necesito una función que no existe en esa clase. ¿Qué hago? Si puedo heredarla, la heredo y agrego el método, con el consiguiente problema de que si requerimos que todos los desarrolladores la usen, deben de olvidarse de utilizar la clase “estándar” y empezar a usar la clase que acabo de crear. Por otro lado, si la clase esta sellada –sealed – no la puedo heredar, lo que conlleva a crear alguna clase “Helper” que tenga el método y pueda ser invocada. Por ejemplo, supongamos que necesito saber si un string es numérico o no. En este caso procedo a crear un método en una clase Helper dado que la clase string esta sellada en .NET – es decir, no se puede heredar.

image

Ahora, para utilizar este método estático, simplemente lo hago de la siguiente forma:

image

El problema con esta solución es que todo el mundo debe de estar consciente que esta clase existe y que se puede reutilizar – esa palabra por la cual todos vivimos pero casi nunca logramos aplicar de forma constante en nuestros desarrollos – por lo cual es muy probable que veamos la misma solución aplicada de diversas formas en otros proyectos internos.

La Solución

Sin embargo, a partir de la versión del framework 3.5 se agregó una característica que personalmente utilizo mucho y pienso que es de gran utilidad: los métodos de extensión. Esto métodos de extensión son métodos que pueden formar parte de una clase y pueden ser utilizados directamente desde la instancia o el tipo de la misma. Esta característica se utiliza muchísimo sobre todo en el desarrollo de LINQ. Para entender este concepto vamos a modificar el ejemplo anterior para convertirlo en un método de extensión. Lo único que tenemos que hacer es modificar la forma en que declaramos el parámetro del método IsNumeric, tal y como se puede ver en el siguiente código:

image

Como podemos ver en el código anterior, lo único que hice fue agregarle la palabra reservada this al parámetro del método. Esto convierte el método en una extensión de la clase string, con lo cual puedo utilizarlo directamente en las instancias de este tipo de dato.

image

Etiquetas de Technorati: ,

7.26.2011

Manejo de Errores con el ASP.NET MVC

Una de las características más interesantes del MVC es el manejo de errores que tiene el framework. Por defecto, el MVC trae una vista para el manejo de errores en el campo visual, la cual se despliega cada vez que se produce un error en el sitio Web. Si vemos la estructura de nuestro proyecto al crearlo usando MVC 3, nos vamos a dar cuenta que en el folder Shared de las vistas vamos a ver una vista llamada Error.aspx.

image

En este caso, cambiamos el texto de la vista Error.aspx para que despliegue un mensaje un poco más “amigable” al usuario final.

image

Ahora procedemos a “provocar” un error en el sitio Web para verificar que el despliegue de la vista funcione. Para esto vamos a solicitar una vista que no exista en el método Index del HomeController.

image

Si ejecutamos el código no nos aparece la vista de errores que modificamos anteriormente, pero ¿por qué?

imageLo que nos faltó habilitar fue la propiedad CustomErrors=On en el web.config. Esto habilita el mecanismo para desplegar errores de forma segura y “amigable” en nuestras aplicaciones ASP.NET MVC.

image

Ahora si ejecutamos de nuevo la aplicación provocando el error, podemos ver la vista que modificamos desplegada.

image

Sin embargo, el Framework del MVC no se queda ahí. Este nos permite ser más granulares en lo que respecta al manejo de errores. Por ejemplo, podemos definir un tipo de vista que se pueda utilizar en las acciones que yo específicamente le indico. Vamos a crear una nueva vista, que llamaremos “ErroresPersonalizados”. Esta lista estará tipificada con el tipo HandleErrorInfo del System.Web.Mvc. Este tipo será el que utilicemos en el modelo de la vista; es decir, cuando se invoca la vista, se le pasa en el modelo, la variable que se produjo en el error – en este caso la excepción.

image

La vista generada esta tipificada con el tipo que le indicamos en el model class.

image

Ahora vamos a modificar la vista para presentar de forma personalizada la excepción, nótese que ahora el modelo tiene todas las propiedades de la excepción que se va a producir.

image

El script HTML que vamos a usar en esta forma es el siguiente:

image

Ahora en la acción Index del controlador, vamos a especificar vía un ActionFilter, la vista de manejo de error que se debe de mostrar en caso de que ocurra un error en la misma.

image

Al ejecutar el código anterior, la vista que nos aparece es la siguiente:

image

Si se produce un error en cualquier otra acción de cualquier otro controlador se presentará la vista estándar – Error.aspx – pero si se produce un error en la acción Index del HomeController se verá la vista anterior.

Pero el MVC va más allá en el tema de la granularidad del manejo de errores. Supongamos que queremos que todas las acciones desplieguen los errores en la vista estándar, solo que deseamos que si la acción Index del HomeController lanza una excepción del tipo InvalidOperationException, entonces se invoque la vista anterior. Para esto, procedemos a modificar el atributo de manejo de errores con la siguiente información:

image

En el código anterior se lanza un error del tipo InvalidOperationException en el código para probar que la vista adecuada sea la que se presente. Si en esa acción se produce cualquier otra excepción, se presenta la vista estandar Error.aspx y no la vista ErroresPersonalizados.aspx

Etiquetas de Technorati: ,

7.20.2011

Charla de Cloud Computing

Los quiero invitar para que el próximo 4 de agosto me acompañen en la charla de Cloud Computing: Principios y Arquitectura. La charla es gratuita y el lugar donde se va a llevar a cabo es el Auditorio de la Bolsa Nacional de Valores en Forum 1. Les dejo la invitación para que le puedan echar un vistazo a el contenido de la misma.

InvitacionSOACC

Etiquetas de Technorati: ,

7.06.2011

Invocando un Servicio WCF Asincrónicamente–Parte 2

En un post pasado, escribí un artículo acerca de como hacer asincronismo con WCF del lado del cliente a la hora de consumir un servicio. Esta vez voy a continuar con ese post pero haciendo asincronismo del lado del servidor.

Para lograr esto, nos vamos a aprovechar del Task<T>, la cual es una clase que representa una operación asincrónica que puede retornar un valor, tal y como dice la definición del msdn.

Construyendo el Servicio

Para crear un servicio que tenga operaciones asincrónicas, vamos a crear un contrato como normalmente lo hacemos, pero esta vez vamos a agregar el atributo AsynPattern a la operación.Además, vamos a crear la operación de inicio de la misma, y luego la operación de terminación; nótese que solamente se expone como contrato la operación de inicio.

[ServiceContract(Namespace="http://drojasm.net")]
public interface IServicioConsulta
{
[OperationContract(AsyncPattern = true)]
IAsyncResult BeginConsulta(int pTotalPosts, AsyncCallback pCallback, object state);

List<string> EndConsulta(IAsyncResult pResultado);
}

Es importante destacar el patrón del nombre que se debe usar para que el framework entienda la asociación entre ambos métodos.


Ahora procedemos a implementar el servicio. En este caso vamos a crear una propiedad que se llama TotalRegistros, la cual vamos a utilizar para crear los elementos en una estructura for. Luego implementamos el método BeginConsulta. En este método se recibe como parámetro la dirección del método en el cual se va a finalizar la llamada asincrónica; además, se recibe el estado del objeto, el cual para este post no hará mucha diferencia. Por otro lado, vamos a crear una nueva instancia del proceso asincrónico utilizando el método Factory.StartNew el cual recibe como parámetros el método que se inicia asincrónicamente y el estado actual del request. Por último le indicamos al método que continúe su ejecución en el puntero al método enviado a través de pCallback, el cual es EndConsulta. EndConsulta lo que hace es retornar el resultado de la operación ejecutada.

public class ServicioConsulta : IServicioConsulta
{
public int TotalRegistros { get; set; }

public IAsyncResult BeginConsulta(int pTotalRegistros, AsyncCallback pCallback, object pState)
{
TotalRegistros = pTotalRegistros;
var task = Task<List<string>>.Factory.StartNew(this.ObtenerResultado, pState);
return task.ContinueWith(res => pCallback(task));
}

public List<string> EndConsulta(IAsyncResult pResultado)
{
return ((Task<List<string>>)pResultado).Result;
}

private List<string> ObtenerResultado(object pState)
{
List<string> _lista = new List<string>();

for (int i = 0; i < TotalRegistros; i++)
{
_lista.Add("Registro " + i.ToString());
}
return _lista;
}
}

Ahora vamos a agregar la referencia al servicio. Dado que el servicio retorna una lista genérica de strings, el proxy convierte estas listas a un arreglo de strings tradicional string[], algo que podemos modificar si el cliente que vamos a utilizar es WCF. Para esto, vamos al proxy generado a la hora de agregar la referencia y cambiamos los tipos de retorno del método de string[] a List<string>

[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
public List<string> EndConsulta(System.IAsyncResult result) {
return base.Channel.EndConsulta(result);
}
public List<string> Consulta(int pTotalPosts) {
return base.Channel.Consulta(pTotalPosts);
}
[System.ServiceModel.OperationContractAttribute(Action="http://drojasm.net/IServicioConsulta/Consulta", ReplyAction="http://drojasm.net/IServicioConsulta/ConsultaResponse")]
List<string> Consulta(int pTotalPosts);
List<string> EndConsulta(System.IAsyncResult result);

Luego de esto procedemos a crear una pantalla en la aplicación WPF que luce como se muestra a continuación:


image


El código XAML de este ejemplo es el siguiente:

<Grid>
<
Label Content="Ítems Asincrónicos" Height="28" HorizontalAlignment="Left" Margin="35,28,0,0" Name="label1" VerticalAlignment="Top" />
<
TextBox Height="23" HorizontalAlignment="Left" Margin="36,54,0,0" Name="txtCantidad" VerticalAlignment="Top" Width="69" />
<
Button Content="Invocar" Height="23" HorizontalAlignment="Left" Margin="35,129,0,0" Name="btnInvocar" VerticalAlignment="Top" Width="75" Click="btnInvocar_Click" />
<
ListBox Height="157" HorizontalAlignment="Left" Margin="221,41,0,0" Name="lstItems" VerticalAlignment="Top" Width="120" />
<
Label Content="Ítems Asincrónicos" Height="28" HorizontalAlignment="Left" Margin="221,21,0,0" Name="label2" VerticalAlignment="Top" />
<
ListBox Height="157" HorizontalAlignment="Left" Margin="367,41,0,0" Name="lstSincronicos" VerticalAlignment="Top" Width="120" />
<
Label Content="Ítems Sincrónicos" Height="28" HorizontalAlignment="Left" Margin="367,21,0,0" Name="label3" VerticalAlignment="Top" />
<
TextBox Height="23" HorizontalAlignment="Left" Margin="35,100,0,0" Name="txtSincronicos" VerticalAlignment="Top" Width="70" />
<
Label Content="Ítems Sincrónicos" Height="28" HorizontalAlignment="Left" Margin="33,74,0,0" Name="label4" VerticalAlignment="Top" />
</
Grid>

Ahora vamos a proceder con el código del evento del botón llamado btnInvocar. En este botón primero vamos a llamar al método WCF de forma asincrónica, y luego, mientras este método se procesa invocamos el mismo método de forma sincrónica. Como este último bloquea la ejecución cuando este termina, el método asincrónico ya ha terminado igualmente, con lo que a la hora de hacer databinding a las listas correspondientes, ambas se llenarán casi simultáneamente.

private void btnInvocar_Click(object sender, RoutedEventArgs e)
{
int _cantidadAsincronicos = int.Parse(txtCantidad.Text);
int _cantidadSincronicos = int.Parse(txtSincronicos.Text);

var _proxy = new ServicioConsultaClient();
object _estado = "No tiene relevancia ahorita";
var Task = Task<List<string>>.Factory.FromAsync(_proxy.BeginConsulta, _proxy.EndConsulta, _cantidadAsincronicos, _estado);

//Mientras invocamos sincronicamente
List<string> _resultado = _proxy.Consulta(_cantidadSincronicos);
//Luego vamos por el resultado
List<string> _resultadoAsincronico = Task.Result;
//Cerramos el proxy
_proxy.Close();
lstItems.ItemsSource = _resultadoAsincronico;
lstSincronicos.ItemsSource = _resultado;

}

El resultado a la hora de ejecutar el código anterior es el siguiente:


image


Etiquetas de Technorati:

6.30.2011

Repetición charla de SOA

Volviendo al tema de la charlas y como les indique en un post anterior, estamos trabajando en conjunto con CTE con un grupo de charlas gratuitas relacionadas con el tema de Arquitectura de Software. Dado el éxito de la charla  de SOA – Arquitectura Orientada a Servicios – hemos decidido repetirla el próximo 14 de Julio en las instalaciones de CTE. La misma es gratuita e incluye desayuno. Les adjunto la invitación por si quieren participar en la misma.

Charla SOA

Etiquetas de Technorati: ,

6.29.2011

Invocando un Servicio WCF Asincrónicamente

En WCF existen varias formas para consumir un servicio de forma asincrónica. La más simple quizás es poner el asincronismo del lado del cliente, que es lo que vamos a hacer en este post.

Para iniciar vamos a crear un proyecto del tipo WCF ServiceLibrary y vamos a crear un servicio muy simple que tiene solamente un método que retorna el número de frutas – strings – que se lo soliciten vía parámetro a la operación. La interface – contrato – del servicio se ve a continuación:

[ServiceContract(Namespace="http://drojasm.net")]
public interface IServicioProductos
{
[OperationContract]
List<string> ObtenerProductos(int pCantidad);
}

Seguidamente procedemos con el código para implementar la operación. Como podemos ver en el siguiente código, este simplemente lo que hace es hacer un for y agregar un string a la lista por cada iteración. Nótese además la línea en donde ponemos a dormir el thread del servicio, esto con el fin de que nos de tiempo de hacer algo diferente en el UI mientras el servicio se ejecuta.

    public class ServicioProductos : IServicioProductos
{
public List<string> ObtenerProductos(int pCantidad)
{
List<string> _productos = new List<string>();

for (int i = 0; i < pCantidad; i++)
{
_productos.Add("Fruta Número " + i.ToString());
}

System.Threading.Thread.Sleep(5000);
return _productos;

}
}
}

Ahora vamos a proceder a crear el cliente que va a consumir el servicio. En este caso vamos a utilizar una aplicación WPF. Lo primero que vamos a hacer después de crear la aplicación es agregar una referencia al servicio como se hace tradicionalmente; es decir, botón derecho sobre el proyecto, seleccionar agregar referencia, y en la pantalla de configuración de la referencia del servicio, poner la dirección del servicio – en este caso hosteado en el wcfsvchost – y por último obtener el wsdl del mismo.


image


Sin embargo, esta vez vamos a seleccionar además el botón de “Advanced” para configurar la generación del proxy. Luego en esta pantalla vamos a configurar la generación del proxy, seleccionando en esta la opción para generar clientes asincrónicos. Esta opción nos va a generar además de los métodos tradicionales sincrónicos, los métodos necesarios para invocar el servicio utilizando asincronismo.


image


Luego seleccionamos Ok en las siguientes dos pantallas y se procede con la generación del proxy. Como podemos ver en la siguiente figura, el proxy genera los métodos para consumir asincrónicamente el servicio.


image


Ahora procedemos a crear la pantalla en WPF para invocar el servicio. Para esto, vamos a agregar un listbox en donde pintamos el resultado de cada servicio. Además vamos a poner un textbox para que el usuario – yo Sonrisa - digite cuantos elementos quiere en la lista. También vamos a poner dos botones, uno para invocar el servicio sincrónicamente y otro asincrónicamente. Por último, vamos a poner un botón que va a lanzar un MessageBox cuando se le da click; el objetivo de este es demostrar que cuando invocamos el servicio de forma asincrónica, podemos llevar a cabo otras tareas mientras que cuando lo hacemos de forma sincrónica la pantalla se bloquea. El XAML de la pantala es el siguiente:

<Window x:Class="ClienteAsincronicoWCF.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="350" Width="447">
<
Grid>
<
ListBox Height="197" HorizontalAlignment="Left" Margin="47,74,0,0" Name="lstFrutas" VerticalAlignment="Top" Width="120" />
<
Label Content="Frutas" Height="28" HorizontalAlignment="Left" Margin="47,40,0,0" Name="label1" VerticalAlignment="Top" />
<
Button Content="Cargar Sincronicamente" Height="23" HorizontalAlignment="Left" Margin="213,220,0,0" Name="btnSincronico" VerticalAlignment="Top" Width="140" Click="btnSincronico_Click" />
<
Button Content="Cargar Asincronicamente" Height="23" HorizontalAlignment="Left" Margin="213,249,0,0" Name="btnAsincronico" VerticalAlignment="Top" Width="140" Click="btnAsincronico_Click" />
<
Label Content="Cantidad de Productos" Height="28" HorizontalAlignment="Left" Margin="213,146,0,0" Name="label2" VerticalAlignment="Top" />
<
TextBox Height="23" HorizontalAlignment="Left" Margin="213,180,0,0" Name="txtCantidad" VerticalAlignment="Top" Width="140" />
<
Button Height="75" HorizontalAlignment="Left" Margin="269,40,0,0" Name="button1" VerticalAlignment="Top" Width="75" Click="button1_Click">
<
Button.Content>
<
StackPanel>
<
Image Height="48" Name="image1" Stretch="Fill" Width="48" Source="/ClienteAsincronicoWCF;component/pens.png" />
<
Label Content="Otra Tarea" Height="28" Name="label3" />
</
StackPanel>
</
Button.Content>
</
Button>
</
Grid>
</
Window>


Y la pantalla en modo de diseño es la siguiente:


image


El código del botón para la invocación sincrónica del servicio es el siguiente:

private void btnSincronico_Click(object sender, RoutedEventArgs e)
{
lstFrutas.ItemsSource = null;
ServicioProductosClient _proxy = new ServicioProductosClient();
lstFrutas.ItemsSource = _proxy.ObtenerProductos(int.Parse(txtCantidad.Text));
}

No olvidar agregar el namespace del servicio – el que digitamos en la pantalla para agregar la referencia al mismo.

using ClienteAsincronicoWCF.ReferenciaServicioProductos;

Como podemos ver en el código del botón, la forma de invocar este servicio es la tradicional; este procedimiento bloquea la pantalla y no permite realizar ninguna otra tarea mientras la invocación al servicio se esta ejecutando.


image


Ahora procedemos a agregar el código de la llamada asincrónica.

private void btnAsincronico_Click(object sender, RoutedEventArgs e)
{
lstFrutas.ItemsSource = null;
ServicioProductosClient _proxy = new ServicioProductosClient();
AsyncCallback _callBack =
delegate(IAsyncResult pResult)
{
this.Dispatcher.BeginInvoke((Action)delegate { lstFrutas.ItemsSource = _proxy.EndObtenerProductos(pResult); });
};

_proxy.BeginObtenerProductos(int.Parse(txtCantidad.Text), _callBack, _proxy);
}

En este código nos vamos a detener un momento para analizarlo un poco mas detalladamente. En primera instancia procedemos a crear un delegate en donde vamos a obtener la respuesta del servicio. En este delegate además, debemos hacer un llamado a la operación BeginInvoke porque el thread en donde se invoca el proceso es diferente al thread del UI, por lo tanto no se puede asignar el resultado directamente a la lista. Por último, invocamos el servicio de forma asincrónica utilizando el método BeginObtenerProductos.


En el botón del MessageBox tenemos el siguiente código:

private void button1_Click(object sender, RoutedEventArgs e)
{
MessageBox.Show("Iniciando otra operación");
}

Ahora procedemos a ejecutar el servicio con el botón btnAsincronico. Como podemos ver en la siguiente imagen, se pudo invocar al messageBox mientras el servicio estaba procesándose.


image


En realidad este método puede ser reemplazado fácilmente utilizando threads del lado del cliente. Sin embargo, esta es una forma muy simple de obtener asincronismo con WCF en el cliente. En post posteriores vamos a analizar el asincronismo del lado del servicio WCF.


Por último, también es relevante aclarar que una cosa es el asincronismo y otra cosa el paralelismo – tema que espero poder abarcar en post posteriores.


Etiquetas de Technorati: ,,