miércoles, 3 de noviembre de 2010

[.NET] Visual Studio Async CTP

En el último PDC hubo alguna agradable sorpresa en la presentación de las nuevas versiones del framework. Actualmente la industria se está especializando en trabajar para múltiples procesos y procesadores. Desde las consolas (XBOX, PS3, quién sabe si las nuevas portátiles…), PC’s, Tablets (cada vez es más reciente escuchar procesadores de doble núcleo para móviles…) y cualquier dispositivo. La programación paralela se convertirá en lo estándar en un tiempo, así que en la PDC se presento el framework Async que responde a estas necesidades.

Este framework supone una evolución frente al anterior e incluye las características de los servicios de Windows Communication Foundation (WCF) de un modo más extendido. Como se mostró en este artículo, una de las ventajas de usar servicios basados en WCF es que son totalmente asíncronos. Simplemente creo un manejador para el evento de finalizar el servicio y ya está. Cuando invoco al servicio, el hilo realiza la llamada pero no se dedica a ejecutar el código del servicio. Cuando el servicio termina de ejecutarse, se lanza el evento que es recogido por el manejador. De este modo liberamos el hilo principal de la aplicación de esta tarea, permitiendo que realice otras operaciones. ¿Interesante, verdad?

Pues esta funcionalidad hasta ahora concreta de WCF la extenderán a la futura versión de todo el framework. Antes para realizar este tipo de tareas había que crear el hilo, controlarlo y “matarlo”. O si queremos realizar alguna operación más compleja, hay que crear sistemas de control de la concurrencia como los semáforos.

Lo primero que han añadido es crear dos nuevas palabras reservadas:

   1: await,async;

Y la idea es invocar un método asíncrono con la palabra async, que devolverá una Tarea (Task, de .NET Framework 4.0). Y esta tarea nos devolverá el valor de retorno de la invocación. Veamos un ejemplo. Supongamos que disponemos del siguiente código:

   1: Gallery gallery = GalleryManager.LoadGallery("testGallery");

En este caso se invocaría el gestor de galerías y hasta que no estuviese cargado, el hilo se quedaría bloqueado hasta terminar la ejecución de dicha llamada. Esto podemos paralelizarlo del siguiente modo:

   1: Task<Gallery> taskGallery = GalleryManager.LoadGalleryAsync("testGallery");

Con la línea de arriba estamos indicando que vamos a esperar a que el método termine de forma asíncrona. Nótese que por convenio, los métodos asíncronos deben terminar con el sufijo “Async”. Para que esto funcione, debemos especificar los siguientes cambios en la declaración de la función:

   1: //Metodo antiguo
   2: Gallery LoadGallery(string galleryName)
   3: {
   4: ...
   5: }
   6:  
   7: //Nueva version asincrona
   8: async Task<Gallery> LoadGallery(string galleryName)
   9: {
  10:  
  11: }

Y luego aplicamos una conversión para transformar el resultado de la invocación anterior del método en el objeto en cuestión:

   1: Gallery gallery = await taskGallery;

O bien podemos usar los tipos anónimos para evitar esta conversión:

   1: var gallery = await GalleryManager.LoadGallery("testGallery");

Sencillo e intuitivo. Esto tiene mucho potencial.

2 comentarios:

  1. Que buena tio, no me había enterado de esto pero va a estar muy wapo, he tenido que hacer mi gestión de hilos unas cuantas veces con DispatcherTimers en Silverlight o con BackgroundWorkers en servers y si me la dan ya de base, deeeeee lujo!

    Gran artículo.

    ResponderEliminar
  2. Pues sí. De todas formas ten en cuenta que la CTP es la "semilla" de lo que será el Framework 5.0, así que aún le queda un tiempo para que podamos disfrutarlo a lo grande ;)

    ResponderEliminar