Receta Multithreading en C# No. 5-7: Gestión Irregularidades de Tipo de Retorno void en Métodos Asincrónicos

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Tipo de retorno void
6. Práctica: Gestión de Tipo de Retorno void en Métodos Asincrónicas
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

Llega la oportunidad de explorar cómo en un método asincrónico con tipo de retorno void se comporta el flujo de ejecución de una aplicación con múltiples tareas en ejecución. El propósito principal es conocer los problemas que compromete usar este tipo de retorno en la gestión de excepciones por parte del programador. En la sección práctica se demuestra los casos irregulares en la generación de excepciones en dos situaciones: bloque try-catch y una expresión lambda.

2. Palabras Clave

• Asincronismo
• Excepción
• Expresión lambda
• Operación asincrónica
• Pool de threads
• Thread
• try-catch

3. Problema

Gestionar el tipo de retorno void en operaciones asincrónicas.

4. Solución

Aunque existen soluciones para gestionar el tipo de retorno void, en esta receta se describe cuáles son los problemas que generar este tipo de retorno en operaciones asincrónicas.

5. Discusión de la Solución

5.1 Tipo de retorno void

El tipo de retorno void especifica que un método no retorna ningún valor una vez ejecutada las operaciones de su implementación. Esto no tiene ningún problema en métodos sincrónicos. Sin embargo, en operaciones asincrónicas y más en particular en métodos que pueden generar excepciones sí que pueden producirse comportamientos anómalos e irregulares.

Continuando, esto es así porque en el contexto de sincronización la gestión de excepciones se lleva a cabo en el pool de threads; entonces, si una excepción no es gestionada, el proceso general terminará de forma abrupta (Agafonov, 2016).

Aún así, existen mecanismos para gestionar las excepciones como el evento AppDomain.UnhandledException. Este evento ocurre cuando una excepción no es capturada/gestionada ("AppDomain.UnhandledException Event", 2016).

Este es un ejemplo de uso de este evento: 

Archivo C# UsoUnhandledException.cs [Enlace alternativo][Enlace alternativo]: 

6. Práctica: Gestión de Tipo de Retorno void en Métodos Asincrónicos

El siguiente ejemplo adaptado de Agafonov (2013) demuestra cuáles son los problemas que pueden emerger en el uso del tipo de retorno void en una operación asincrónica.

Archivo C# VoidAsyn.cs [Enlace alternativo][Enlace alternativo]: 

La primera parte empieza con la descripción del método AsyncRetornoTaskConErrores() (líneas 64-69): este método retorna un objeto Task y genera una excepción simulada por medio de una cadena de texto.

Por otra parte, con AsyncRetornoVoidConErrores() (líneas 75-80) se simula también una excepción con una cadena de texto que incluye la palabra Exception.

El propósito con estos dos métodos es demostrar lo que ocurre al invocar una operación asincrónica que produce una excepción.

Como contraste, los métodos AsyncRetornoTask() (líneas 86-91) y AsyncRetornoVoid() (líneas 97-102) no generan ninguna excepción; sin embargo, en el caso de AsyncRetornoVoid() permite hacer la demostración de lo que ocurre con el tipo de retorno void. Mientras que AsyncRetornoTask() facilita la monitorización del estado de ejecución de la tarea asincrónica, gracias al tipo de retorno, por su parte AsyncRetornoVoid() no; para lograrlo se debe esperar un tiempo debido a que no cuenta con mecanismo de monitoreo de la operación asincrónica.

En cuanto al método Ejecutar() (líneas 15-58), estas son las operaciones que se ejecutan: 

• Líneas 17-18: Definición de un objeto Task que recibe como retorno el objeto Task de AsyncRetornoTask(). Con t.Wait() se espera unos instantes mientras que la tarea asincrónica se completa.
• Líneas 20-21: Invocación de AsyncRetornoVoid(). El monitoreo del estado de la operación asincrónica sólo se logra con un tiempo de espera. Este tiempo de espera es superior al tiempo ejecución simulado por el método. ¿La razón? El tipo de retorno de la operación asincrónica: void.
• Líneas 23-29: Invocación de AsyncRetornoTaskConErrores(). El ciclo while comprueba que mientras no se genere ninguna falla se simula un tiempo de espera. Al final, línea 27, se muestra la excepción que se produjo con la invocación de esta método.
• Líneas 31-55: Sirve al lector como comprobación del comportamiento irregular del manejo de excepciones de operaciones asincrónicas que retornan el tipo void. El lector puede tomar este código y verificar por medios propios lo que ocurre cuando se remueven los comentarios.

Esta es la demostración del código en ejecución: 

7. Conclusiones

Quedó demostrado cómo gestionar el tipo de retorno void de métodos asincrónicos. El no reconocer las problemas en manejo de excepciones en métodos con esta clase de firma puede hacer que un programa genere un comportamiento irregular y afecte la experiencia del usuario.

La próxima receta multithreading explicará cómo diseñar un tipo personalizado de await.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.
AppDomain.UnhandledException Event (System) (2016, julio 12). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.appdomain.unhandledexception(v=vs.110).aspx

O

Receta Multithreading en C# No. 5-6: Cambiar el Modo de Ejecución Asincrónica

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Método Task.ConfigureAwait()
6. Práctica: Cambio de Ejecución Asincrónico
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

El modo de operación de la invocación de una función asincrónica await puede ser alterado, por ejemplo, en la ejecución de operaciones asincrónicas de una interfaz gráfica de usuario. Esta receta multithreading en C# explica cómo usar el método ConfigureAwait() para configurar la ejecución asincrónica de código que no accede a los componentes de la interfaz gráfica de usuario. La demostración en la sección práctica enseña el uso de este método alternando entre el uso del contexto de sincronización y sin recurrir a él.

2. Palabras Clave

• Asincronismo
• Contexto de sincronización
• Interfaz gráfica de usuario
• GUI
• Sincronismo

3. Problema

Configurar el modo de ejecución asincrónico de una tarea.

4. Solución

El método ConfigureAwait() permite la configuración del modo de ejecución asincrónico.

5. Discusión de la Solución

5.1 Método Task.ConfigureAwait()

El método ConfigureAwait() configura el modo de ejecución asincrónica de una tarea. Este método recibe como argumento un valor booleano que en caso de ser true, el modo de ejecución asincrónica captura el contexto desde donde es ejecutada la tarea; en caso contrario la tarea se debe ejecutar sin capturar el contexto de sincronización.

Esta es su firma: 

public ConfiguredTaskAwaitable ConfigureAwait(

bool continueOnCapturedContext

)

6. Práctica: Cambio de Ejecución Asincrónica

La siguiente receta C# explica cómo el programador puede cambiar el modo de ejecución asincrónica.

Archivo C# ContextoSincronizacion.cs [Enlace alternativo][Enlace alternativo]: 

El método que controla el evento Click (líneas 48-69) del botón que activa las operaciones asincrónicas lleva a cabo estas operaciones: 

• Línea 51: Asigna el texto Calculando... cuando se inicia la ejecución asincrónica de dos tareas que operan en asincronismo con y sin contexto.
• Línea 54: Inicia la ejecución de una operación con contexto.
• Línea 55: Inicia la ejecución de una operación sin contexto.
• Líneas 61-65: Construcción de la cadena de resultados de las dos operaciones asincrónicas anteriores.
• Línea 68: Asigna el nuevo texto a la etiqueta de la interfaz gráfica de usuario.

Por otra parte, con el método OperacionContexto() (líneas 75-90) realiza estas operaciones: 

• Línea 77: Especifica el número de iteraciones que ejecuta este método asincrónico.
• Líneas 78-79: Creación e inicio de cronómetro.
• Líneas 81-85: Repite la ejecución de una tarea asincrónica simulada. Aquí la tarea se ejecuta capturando implícitamente el contexto de ejecución.
• Línea 87: Se detiene el cronómetro.
• Línea 89: Retorna el tiempo que tomó la ejecución.

De manera análoga, el método OperacionSinContexto() (líneas 96-112) ejecuta estas operaciones: 

• Línea 98: Especifica el número de iteraciones que ejecuta este método asincrónico.
• Líneas 99-100: Creación e inicio de cronómetro.
• Líneas 102-107: Repite la ejecución de una tarea asincrónica simulada. A través del método ConfigureAwait() se establece que el método se debe ejecutar sin capturar el contexto de sincronismo.
• Línea 109: Se detiene el cronómetro.
• Línea 111: Retorna el tiempo que tomó la ejecución.

Finalmente, con el método Ejecutar() (líneas 19-41) se construye la interfaz gráfica de una aplicación Windows Presentation Foundation (WPF).

Prueba de ejecución: 

7. Conclusiones

Se ha demostrado cómo a través del método ConfigureAwait() se puede alterar el modo de ejecución de una operación asincrónica: con y sin captura de contexto de sincronismo. Quedó claro que cuando no se captura el contexto el desempeño general de la aplicación es superior comparado con la captura del contexto.

Hasta ahora se ha estudiado los métodos asincrónicos que retornan un tipo paramétrico para el tipo Task, sin embargo en la siguiente receta multithreading se estudiará cómo trabajar con operaciones asincrónicas que retornan void.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.
Task.ConfigureAwait Method (Boolean) (System.Threading.Tasks) (2016, julio 11). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.threading.tasks.task.configureawait(v=vs.110).aspx

V

Receta Multithreading en C# No. 5-5: Manejo de Excepciones en Operaciones Asincrónicas

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Excepciones
6. Práctica: Manejo de Excepciones en Operaciones Asincrónicas
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

El programador debe hacer de sus aplicaciones robustas a través de la manipulación de excepciones que eventualmente pudiera generar las operaciones. En una aplicación basada en procesos asincrónicos, el programador también debe invertir esfuerzos en cuidar los detalles de implementación en busca de posibles fallas en la lógica o uso de elementos de programa del lenguaje. Esta receta multithreading explica cómo controlar el flujo de excepciones en operaciones asincrónicas.

2. Palabras Clave

• Asincronismo
• Excepción
• Operación asincrónica

3. Problema

Controlar el flujo de excepciones en una operación asincrónica.

4. Solución

El modelo de gestión de excepciones de operaciones sincrónicas se modifica para controlar las excepciones de operaciones asincrónicas.

5. Discusión de la Solución

5.1 Excepciones

En la siguiente serie de artículos C# el lector encontrará una amplia explicación del manejo de excepciones en este lenguaje: 

1. Excepciones en C# - Parte 1: Introducción a las Excepciones
2. Excepciones en C# - Parte 2: Uso de Excepciones
3. Excepciones en C# - Parte 3: Diseño de Excepciones Personalizadas
4. Excepciones en C# - Parte 4: Propiedades de la Clase Base System.Exception
5. Excepciones en C# - Parte 5: Ejemplos de Excepciones Comunes

6. Práctica: Manejo de Excepciones en Operaciones Asincrónicas

Esta receta multithreading demuestra tres distintos casos de manipulación de excepciones en operaciones asincrónicas donde están involucrados los operadores asincrónicos async y await.

Archivo C# ManejoExcepcionesAsync.cs [Enlace alternativo][Enlace alternativo]: 

El método ObtenerInfoAsync(string, int) (líneas 80-85) simula la ejecución de un proceso largo (línea 82) y lanza una excepción de forma intencional (línea 84).

Sobre el método ProcesamientoAsincronico() (líneas 21-72) ocurren las siguientes operaciones: 

• Líneas 25-33: Aquí se manipula la excepción que genera el método asincrónico ObtenerInfoAsync() del mismo modo que en ejecución sincrónica.
• Líneas 40-48: Para múltiples tareas que se ejecutan en paralelo no es recomendable este enfoque, debido a que sólo se obtiene la información de excepción del objeto AggregateException.
• Líneas 56-70: Este enfoque de manejo de excepciones es idóneo para obtener toda la información de las excepciones que eventualmente pudieran generarse en el método ObtenerInfoAsync() (claro está que en este caso particular las excepciones se disparan de forma intencional). En el ciclo foreach se muestra el mensaje de cada una de las excepciones que produjeron las tareas ejecutadas en paralelo.

La siguiente captura muestra cómo ocurren las excepciones de estos tres casos.

Nótese cómo en la segunda parte -2. Múltiples Excepciones- sólo se captura los detalles de excepción de una sola tarea.

7. Conclusiones

Se demostró el proceso de gestión de excepciones en tareas asincrónicas. Las excepciones producidas por un grupo de tareas asincrónicas requiere una gestión especial como se demostró en las líneas 56-70 del código de la sección práctica.

Para comprender el mecanismo de control flujo de sincronización la siguiente receta multithreading explica el comportamiento de cambio de contexto de sincronización.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.
Excepciones en C#: Introducción a las Excepciones (2016, junio 22). Recuperado desde: http://ortizol.blogspot.com.co/2014/06/excepciones-en-csharp-parte-1-introduccion-a-las-excepciones.html
Excepciones en C#: Uso de Excepciones (2016, junio 22). Recuperado desde: http://ortizol.blogspot.com.co/2014/07/excepciones-en-csharp-parte-2-uso-de-excepciones.html
Excepciones en C#: Diseño de Excepciones Personalizadas (2016, junio 22). Recuperado desde: http://ortizol.blogspot.com.co/2014/07/excepciones-en-csharp-parte-3-diseno-de-excepciones-personalizadas.html
Excepciones en C#: Propiedades de la Clase Base System.Exception (2016, junio 22). Recuperado desde: http://ortizol.blogspot.com.co/2014/07/excepciones-en-csharp-parte-4-propiedades-de-la-clase-base-system.exception.html
Excepciones en C#: Ejemplos de Excepciones Comunes (2016, junio 22). Recuperado desde: http://ortizol.blogspot.com.co/2014/07/excepciones-en-csharp-parte-5-ejemplos-de-excepciones-comunes.html

V

Receta Multithreading en C# No. 5-4: Ejecución en Paralelo de Tareas con await

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Combinación de tareas con Task.WhenAll
6. Práctica: Ejecución en Paralelo de Tareas
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

Aquí se explica cómo el programador puede lograr la ejecución en paralelo de múltiples tareas usando la función asincrónica await. El ejemplo de la sección práctica demuestra que esto es posible a través de la ejecución de dos tareas, cada una con 3 y 5 segundos de retrasa. Al final quedará demostrado que el tiempo máximo de espera será 5 segundos.

2. Palabras Clave

• await
• Ejecución en paralelo
• Función asincrónica
• Tarea

3. Problema

Ejecutar en paralelo dos o más tareas.

4. Solución

A través del operador await el programador puede implementar código de ejecución en paralelo.

5. Discusión de la Solución

5.1 Combinación de tareas con Task.WhenAll

El método static Task.WhenAll() ("Task.WhenAll Method", 2016) crea una tarea compuesta; una vez que el conjunto de tareas integrales finalicen su ejecución, el flujo de control de ejecución pasa a la tarea compuesta y se continua con la lógica de implementación particular a esta tarea.

Este método cuenta hasta con 4 versiones static sobrecargadas; tal y como se muestra en la siguiente figura: 

Figura 1. Versiones sobrecargadas de Task.WhenAll ("Task.WhenAll Method", 2016).

6. Práctica: Ejecución en Paralelo de Tareas

El siguiente ejemplo en C# demuestra la ejecución de dos tareas en paralelo a través del uso de la función asincrónica await.

Archivo C# EjecucionParalelaConAwait.cs [Enlace alternativo][Enlace alternativo]: 

El método ObtenerInfoAsync(string, int) (líneas 46-54) representa una operación de ejecución asincrónica. Estas son las operaciones que lleva a cabo: 

• Línea 48: Simula la ejecución extendida.
• Líneas 50-53: Retorna cadena de caracteres con la información del thread que ejecuta la tarea.

Por otra parte, con el método ProcesamientoAsincronico() (líneas 25-38) se preparan para ejecución dos tareas; cada una con duración de 3 y 5 segundos. Los resultados se almacenarán en el arreglo de objetos string resultados (línea 30). Cuando estas dos tareas hayan finalizado su ejecución, se muestran los resultados de los threads de ejecución en el ciclo foreach de las líneas 34-37.

En esta captura se presenta el flujo de ejecución de esta interesante receta: 

> Prueba de ejecución (online): http://ideone.com/6yNUeO

7. Conclusiones

El operador await permite al programador del lenguaje de programación C# ejecutar en paralelo dos o más tareas. Hasta ahora se ha visto que el modelo TPL resulta más intuitivo y poderoso que los modelos EAP y APM estudiados en series de recetas multithreading anteriores.

La próxima receta multithreading enseña al programador cómo manipular excepciones en operaciones asincrónicas.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.
Task.WhenAll Method (System.Threading.Tasks) (2016, julio 3). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.threading.tasks.task.whenall(v=vs.110).aspx

V

Receta Multithreading en C# No. 5-3: Uso Operador await en Tareas Asincrónicas Subsecuentes

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Implementación con TPL
5.2 Implementación con el operador asincrónico async
6. Práctica: TPL vs Operador Asincrónico await en Tareas Asincrónicas
Conclusiones
Literatura & Enlaces

1. Introducción

Es momento de comprender qué ocurre con las llamadas consecutivas a tareas asincrónicas con el operador asincrónico await. Esta receta explica la forma de leer el flujo de control de invocaciones de operaciones asincrónicas tanto de una implementación con TPL y otra con el operador asincrónico await para finalmente concluir cuál de los dos enfoques es el más práctico.

2. Palabras Clave

• Asincronismo
• await
• Flujo de control
• Operador asincrónico
• Sincronismo
• TPL

3. Problema

Analizar el flujo de control de tareas asincrónicas subsecuentes tanto con el enfoque de TPL y uso del operador asincrónico await.

4. Solución

Para la solución de este problema se escriben dos métodos:

1. Con construcciones de TPL -objetos Task y continuaciones.
2. Con operador asincrónico await.

5. Discusión de la Solución

5.1 Implementación con TPL

Para definir una implementación con TPL se recurre al uso de continuaciones a partir de una tarea compuesta. Esta tarea compuesta cuenta con declaraciones de otro objetos Task anidadas, que al mismo tiempo definen un esquema de respuesta a casos de éxito y fallo a través de continuaciones.

5.2 Implementación con el operador asincrónico await

Este operador simplifica la invocación de operaciones asincrónicas usando elementos del lenguaje para la obtención de resultados, gestión de excepciones y el flujo de control del programa.

6. Práctica: TPL vs Operador Asincrónico await en Tareas Asincrónicas Subsecuentes

Este ejemplo es una adaptación del código presentado por Aganof (2016): presenta una implementación del flujo de control de operaciones asincrónicas en TPL y con la función asincrónica await.

Código C# TareasAsincronicasConsecutivas.cs [Enlace alternativo][Enlace alternativo]:

El método ObtenerInfoThreadAsync(string) (líneas 86-103) lleva a cabo las siguientes operaciones: 

• Línea 88: Muestra el nombre de la fuente desde donde se invocó este método.
• Línea 91: Simula la ejecución de una operación de duración extendida.
• Líneas 93-96: Lanza una excepción intencionada cuando el nombre de la fuente es "TPL No. 2".
• Líneas 98-102: Retorna información del thread de ejecución para esta operación asincrónica.

Método AsincronismoConTpl() (líneas 26-58): 

• Líneas 28-53: Definición de tarea compuesta.
• Línea 30: Definición y asociación de objeto Task con el método ObtenerInfoThreadAsync().
• Líneas 35-44: Definición de un nuevo objeto Task anidado, además de continuaciones para los casos de éxito y excepción.
• Líneas 49-52: Continuación para objeto Task tarea1.
• Línea 55: Inicio de la ejecución de la tarea compuesta.

Método AsincronismoConAwait() (líneas 65-78): 

• Líneas 67-73: Bloque try para la invocación lineal/sincrónica de ObtenerInfoThreadAsync() a través del operador asincrónico await.
• Líneas 74-77: Bloque catch para responder a excepciones que eventualmente se produzcan durante la ejecución de las operaciones invocadas con await.

Hay que notar que en el caso de AsincronismoConAwait() ambas invocaciones se realizarán una tras otra, es decir de modo secuencial -i.e., sincrónicamente. Mientras que en AsincronismoConTpl() se requiere de una mayor complejidad -tareas anidadas, continuaciones y definiciones para responder a casos de falla y éxito.

Otro punto relevante en este caso es que el programa da la impresión de tratarse de una implementación de sincronismo, sin embargo al remover las llamadas a Wait() en el método Ejecutar() (líneas 12-19), se puede pensar que las llamadas a AsincronismoConAwait() y AsincronismoConTpl() son tareas asincrónicas y que Ejecutar() puede ejecutar otras expresiones mientras que éstos dos terminan. Wait() sólo se ha usado en este caso para demostrar la diferencia de implementación de estos dos enfoques.

La siguiente captura de vídeo demuestra lo que sucede con la invocación de los dos métodos anterior: 

En este enlace de GitHub puede encontrar la solución de Visual Studio 2015 y los proyectos asociados a esta receta y otras más: https://github.com/Fhernd/RecetasMultithreadingCSharp.

7. Conclusiones

Se demostró que una implementación de una operación asincrónico con el operador asincrónico await es mucho más elegante e intuitiva frente a una creada usando elementos de programa de TPL.

En la próxima receta multithreading se mostrará al programador cómo usar await en la ejecución en paralelo de operaciones asincrónicas.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.

V

Receta Multithreading en C# No. 5-2: Operador await en una Expresión Lambda

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la solución
5.1 Operador asincrónico await
5.2 Operador asincrónico async
6. Práctica: Expresión Lambda con Operador Asincrónico await
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

El programador C# puede usar el operador asincrónico await en una expresión lambda. Esta receta multithreading explica cómo usar este operador asincrónico en el cuerpo de declaración, junto con el uso de async en listado de parámetros de la expresión lambda. Para llevar a cabo la demostración programática de esta receta se usará el delegado estándar Func<T, TResult>.

2. Palabras Clave

• Asincronismo
• Expresión lambda
• Sincronismo

3. Problema

Definir la implementación de una expresión lambda usando el operador await.

4. Solución

El cuerpo de la implementación de una expresión lambda puede incluir la invocación de operaciones por medio de await; sin embargo para esto es necesario marcar la firma de la expresión con el operador asincrónico async. Esta expresión lambda quedará declarada sobre un delegado del tipo Func<T, TResult>.

5. Discusión de la Solución

5.1 Operador asincrónico await

(Nota: En la sección 5.1 de Receta Multithreading en C# No. 5-2: Operador await en una Expresión Lambda se detalla el funcionamiento de este operador.)

5.2 Operador asincrónico async

A través del operador asincrónico el programador C# puede marcar un método, expresión lambda o método anónimo como asincrónico ("async (C# Reference)", 2016). Este un ejemplo para marcar un método nombrado: 

public async Task OperacionAsync()
{
// ...
}

Y para el caso de una expresión lambda: 

async param => {
// ...
}

5.3 Delegado Func<T, TResult>

(Nota: En la sección 2.1 de Delegados en C#: Delegados Func y Action de .NET Framework se explica detallamente el funcionamiento de este tipo de delegado.)

6. Práctica: Composición de una Expresión Lambda con el Operador Asincrónico await

La aplicación consola que se ha construido demuestra cómo definir una expresión lambda especificando en su cuerpo de implementación el operador asincrónico await.

Archivo C# AwaitExpresionLambda.cs [Enlace alternativo][Enlace alternativo]: 

El método ProcesamientoAsincronico() (líneas 26-42) se implementa de la siguiente manera: 

• Líneas 31-39: Declaración de delegado por medio de la firma Func<T> con la siguiente expresión lambda:
• Línea 29: Especificación el parámetro nombre antecedido por el operador asincrónico async.
• Línea 31: Invocación asincrónica de tarea que simula ejecución extendida a través del operador await.
• Línea 32-36: Retorno con la información del thread en ejecución en la operación asincrónica.
• Línea 39: Invocación de la expresión lambda por medio del operador asincrónico await.
• Línea 41: Visualización del resultado de la expresión lambda.

Demostración de la ejecución a través de una aplicación basada en consola construida en Visual Studio 2015: 

> Prueba de ejecución (online): http://ideone.com/Mg0XL1

En este enlace de GitHub puede encontrar la solución de Visual Studio 2015 y los proyectos asociados a esta receta y otras más: https://github.com/Fhernd/RecetasMultithreadingCSharp

7. Conclusiones

Se ha demostrado que dentro del cuerpo de una expresión lambda es posible usar la función asincrónica await para invocar otras operaciones asincrónicas. Lo anterior siempre y cuando el programador especifique la función asincrónica async en la firma de parámetros de la expresión.

La siguiente receta multithreading explica cómo usar el operador asincrónico await para llamadas asincrónicas consecutivas de tareas.

8. Literatura & Enlaces

Agafonov, E. (2013). Multithreading in C# 5.0 Cookbook. United States: Packt Publishing.
Receta Multithreading en C# No. 5-1: Obtención de Resultados de Tareas Asincrónicas con el Operador await (2016, junio 26). Recuperado desde: http://ortizol.blogspot.com/2016/06/receta-multithreading-en-csharp-no-5-1-obtencion-de-resultados-de-tareas-asincronicas-con-el-operador-await.html
async (C# Reference) (2016, junio 26). Recuperado desde: https://msdn.microsoft.com/en-us/library/hh156513.aspx?f=255&MSPPError=-2147217396
Delegados en C#: Delegados Func y Action de .NET Framework (2016, junio 26). Recuperado desde: http://ortizol.blogspot.com.co/2014/05/delegados-en-csharp--parte-5-delegados-func-y-action-de-dotnet-framework.html

V