Lluís Franco on Geeks.ms : 4.0, Ejemplo

[HowTo] Crear una pantalla que espere la conclusión de una tarea larga (con cancelación)

Lluis Franco — Thu, 29 Sep 2011 09:52:00 GMT

En el post anterior vimos un ejemplo de cómo crear una ventana que espere la conclusión de una tarea. Si bien este ejemplo cubría sobradamente el objetivo, dejamos abierta la puerta a la posibilidad de que dicha tarea pudiese ser cancelada por petición del usuario, pulsando el botón ‘cancel’ de la ventana.

Si se hizo de este modo fue para evitar complicar en exceso el post, ya que el objetivo inicial era simplemente “mostrar una ventana mientras durase el proceso”.

Tras publicar el post y ver algunas de las reacciones en el hilo del foro de C# de MSDN (gracias Pedro por tu idea), he decidido ampliar el proyecto de ejemplo ofreciendo al usuario la posibilidad de cancelar REALMENTE la tarea, utilizando para ello un CancellationToken.

CancellationToken es una estructura nueva del .NET Framework 4.0 (así como toda la TPL en sí), y permite la cancelación de un proceso asíncrono. Es comúnmente usada cuando deseamos propagar una notificación de cancelación hacia arriba, por ejemplo, hacia el método que está siendo ejecutado como en nuestro caso.

Para ello necesitamos crear previamente un CancellationTokenSource, que es el objeto que contiene el token de cancelación y que además nos va a permitir cancelar la tarea. Posteriormente este objeto nos proporcionará el token de cancelación, que usaremos en la llamada a la tarea. Pero vamos a verlo mejor con un poco de código:

En el formulario de espera:

Aparecen algunos cambios, por ejemplo debemos modificar la firma de la propiedad ActionToExecute para que acepte un método que contenga un parámetro de tipo CancellationToken. Este parámetro será usado por el método para saber si se ha cancelado y actuar en consecuencia. De paso aprovecharemos para declarar el CancellationTokenSource.

public Action<CancellationToken> ActionToExecute { get; set; }

CancellationTokenSource cancelTokenSource = new CancellationTokenSource();

Nota importante: En el proyecto anterior, el botón ‘cancel’ no tenía código asociado. Simplemente tenía establecida la propiedad DialogResult en Cancel, de modo que al pulsarlo cerraba automáticamente la ventana y devolvía el valor Cancel a su llamador. En el proyecto actual como sí que nos interesa controlar el cierre de la ventana, es necesario establecer la propiedad DialogResult en None e interceptar su evento:

closeButton.Click += closeButton_Click;

void closeButton_Click(object sender, EventArgs e)

//

Aquí más adelante cancelaremos la tarea y devolveremos un valor DialogResult = Cancel.

Ahora vamos a centrarnos en la creación y ejecución de la tarea asíncrona:

void fSplashScreen_Shown(object sender, EventArgs e)

    titleLabel.Text = Title;

    messageLabel.Text = Message;

    pictureBox.Image = Picture;

    Task.Factory.StartNew(() =>

        ActionToExecute(cancelTokenSource.Token)).ContinueWith((t) => taskCompleted());

Como veis en realidad no hay demasiados cambios, lo único es que en la llamada a StartNew obtenemos el token de cancelación de su CancellationTokenSource, y cuando posteriormente ésta sea cancelada por el usuario, el token será propagado hasta el método que se está ejecutando, permitiendo su cancelación.

Hablando del método, que modificaciones hay que realizar?

El método original era este:

private void DoSomeHardWork()

    for (int i = 0; i < 50; i++)

        Console.WriteLine(i);

        Thread.Sleep(100);

Y el nuevo quedaría así:

private void DoSomeHardWorkWithCancellation(CancellationToken cancelToken)

try

        for (int i = 0; i < 50; i++)

            cancelToken.ThrowIfCancellationRequested();

            Console.WriteLine(i);

            Thread.Sleep(100);

    catch (Exception ex)

        MessageBox.Show(ex.Message, Application.ProductName,

            MessageBoxButtons.OK, MessageBoxIcon.Exclamation);

Como decíamos antes, este método recibe un parámetro de tipo CancellationToken y lo único que hay que hacer es lanzar una excepción en caso que haya sigo solicitada una cancelación (de ahí que se envuelva el código dentro de un bloque try-catch).

Nada más. Una sólo línea y el pertinente bloque de intercepción de errores… y voilá! No os parece bonito y elegante? :-)

Por cierto, en caso que no se desee lanzar una excepción es posible que os interese preguntar por el valor de la propiedad IsCancellationRequested y elegir vosotros mismos la acción más apropiada.

Volvamos al formulario de espera y completemos el código que falta. Primeramente el código del botón ‘cancel’, encargado de cancelar realmente la tarea:

void closeButton_Click(object sender, EventArgs e)

    DialogResult = DialogResult.Cancel;

    cancelTokenSource.Cancel();

    releaseCancellationTokenSource();

private void releaseCancellationTokenSource()

    if (cancelTokenSource != null)

        cancelTokenSource.Dispose();

        cancelTokenSource = null;

Y por último, agregar una línea para liberar también el token al finalizar con éxito la tarea:

private void taskCompleted()

    if (InvokeRequired)

        this.Invoke((MethodInvoker)(() =>

            Close();

            DialogResult = DialogResult.OK;

        }));

    releaseCancellationTokenSource();

Y con esto y un bizcocho, hemos terminado! Espero que os haya gustado :-D

Muchas gracias de nuevo a Pedro Hurtado y a toda la gente del foro de C# en MSDN :-)

Os dejo también el mini proyecto de ejemplo por si queréis jugar un rato:

Nos vemos,

[HowTo] Crear una pantalla que espere la conclusión de una tarea larga

Lluis Franco — Wed, 28 Sep 2011 13:49:00 GMT

Nota: Otro post en respuesta a una pregunta bastante habitual en los foros MSDN: “Mi frmPrincipal ejecuta una función (no tengo el tiempo preciso) y mientras realiza esto quiero que aparezca una ventana … que impida el acceso al frmPrincipal y una vez que se termine de ejecutar la función, desaparezca frmMensaje.”

La verdad es que hay un montón de posibles soluciones. Desde el uso del componente BackgroundWorker (la opción más sencilla pero la que menos me gusta :-P) hasta los futuros async y await que vendrán con C# 5, pasando por los clásicos threads de toda la vida o las tareas que se introdujeron con la TPL en Visual Studio 2010.

Para este ejemplo vamos a utilizar ésta última aproximación, ya que de las otras hay millones de ejemplos de todos los tipos y colores. Además, puede servir como -sencillo- ejercicio de uso de la clase Task, para que quién no la conozca vaya introduciéndose en el maravilloso mundo de la programación paralela.

Primeramente vamos a crear un formulario con un título, un mensaje y una barra de progreso de tipo marquesina, ya que como dice el enunciado “no se conoce de antemano la duración de la tarea a ejecutar”. Y para comprobar que la tarea se ejecuta en segundo plano (en realidad en paralelo si hay más de un core en el procesador) también añadiremos un botón para poder cerrar la ventana.

Aviso: Este botón únicamente sirve para cerrar la ventana y retornar a la ventana principal. Realmente no va a cancelar la tarea, para eso se requeriría un CancellationToken, y no quiero complicar tanto el ejemplo... Aunque tal vez sea buena idea verlo en otro post, más adelante.

El punto de partida será la ventana principal. En mi caso y para no complicarme la vida he creado un formulario muy sencillo con un sólo botón, y que contiene un método que se supone que va a tardar un cierto tiempo en ejecutarse. Iba a poner ‘un huevo’ pero prefiero no hacerlo para no herir susceptibilidades :-)

El formulario principal:

El método que tarda… mucho:

private void DoSomeHardWork()

    for (int i = 0; i < 50; i++)

        Console.WriteLine(i);

        Thread.Sleep(100);

El formulario que espera a que la tarea termine:

Una vez diseñada el formulario de espera, le agregaremos algunas propiedades como el título, mensaje, y sobre todo el método que deseamos ejecutar en forma de Action:

public string Title { get; set; }

public string Message { get; set; }

public Image Picture { get; set; }

public Action ActionToExecute { get; set; }

Una vez creadas estas propiedades, podemos volver al formulario principal y hacer la llamada a la ventana de espera, pasándole los valores oportunos:

private void button1_Click(object sender, EventArgs e)

    using (fWaitForTaskScreen fwait = new fWaitForTaskScreen())

        fwait.Title = "Executing a looooong task...";

        fwait.Message = "This form will close when the task completes its work.\nJust wait a few seconds... :-)";

        fwait.Picture = Properties.Resources.LogoWeb30_small;

        fwait.ActionToExecute = DoSomeHardWork;

        if (fwait.ShowDialog() == DialogResult.OK)

            MessageBox.Show("OK");

        else

            MessageBox.Show("Cancel or error");

Lo único importante aquí es la forma en que le pasamos el método que debe ejecutar. Estamos usando una propiedad de tipo Action, que representa un método con un parámetro que no retorna un valor. De modo, que -ya os aviso- sirve para ejecutar cualquier método que no devuelva un valor. En caso que queramos devolver un valor podríamos utilizar una propiedad pública, o mejor un delegado Func<T, TResult>. Pero como os decía antes, prefiero no complicar el ejemplo.

El código es muy sencillo, como podéis ver. Crea el formulario de espera, le pasa los valores (incluyendo el método a ejecutar) y examinamos el valor de DialogResult para saber si ha terminado con éxito la tarea o no, o se ha cancelado por el usuario.

Y a todo esto ¿cómo se ejecuta el método de forma asíncrona?

Pues aquí está la gracia de este ejercicio. Ya veréis lo sencillo que resulta, sobre todo para aquellos acostumbrados a trabajar ‘a pelo’ con threads:

void fSplashScreen_Shown(object sender, EventArgs e)

    titleLabel.Text = Title;

    messageLabel.Text = Message;

    pictureBox.Image = Picture;

    Task.Factory.StartNew(ActionToExecute).ContinueWith((t) => taskCompleted());

private void taskCompleted()

    if (InvokeRequired)

        this.Invoke((MethodInvoker)(() =>

            Close();

            DialogResult = DialogResult.OK;

        }));

Vayamos por partes. El primer bloque es realmente la parte importante. De hecho, la última línea es la que se encarga de todo. Crea y ejecuta una tarea asíncrona que apunte al método que le hemos pasado al formulario, y no sólo hace eso, si no que además le decimos que cuando termine ejecute una segunda tarea ‘taskCoompleted’. A esto se le llama ‘encadenamiento’ de tareas, y es muy útil cuando una tarea depende de otra.

Y que hace la segunda tarea? Apenas nada. Cierra el formulario y devuelve el valor OK para que la ventana principal sepa que todo ha terminado bien. Lo único que sucede es que -al igual que cuando usamos threads- en .NET no se puede modificar un control fuera del thread que lo ha creado, eso es, el thread principal. Y nuestras tareas se están ejecutando en otros threads creados de forma transparente por la tarea. De modo que para poder llamar al método Close o modificar la propiedad DialogResult debemos hacerlo mediante Control.Invoke, y por ese motivo el código es un poco extraño a primera vista.

Os dejo el mini proyecto de ejemplo por si queréis jugar un rato:

Nos vemos,

Materiales de la charla sobre computación paralela en BcnDev

Lluis Franco — Mon, 22 Nov 2010 09:30:00 GMT

Hola de nuevo,

Después de la charla del viernes en BCNDEV, lo prometido es deuda. Os comenté que había realizado las demos en forma de un pequeño proyecto web, para no tener que ir con un pedazo-de-pepino a hacer las demos (más que nada porque no lo tengo :-P). Así que sólo quiero dejaros el enlace al proyecto que usé para las demos de la TPL, por si alguno las quiere probar:

Os recuerdo que si el proyecto lo probáis en una máquina virtual poco paralelismo vais a ver, pero publicarlo en el host o en cualquier estación con varios cores y veréis la diferencia de rendimiento. En algunos casos no hay mucha ganancia, pero en algunos otros la diferencia es de 5 a 1 o más.

Aprovecho para dejaros la versión más reciente de la presentación, y os prometo que no la voy a actualizar más :-) que bastante lo he hecho en los ú días:

News40 Parallel Computing

View more presentations from AndorraDotNet.

Saludos a todos,