ConversionAPMaTPL.cs

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Recetas.Multithreading.R0404
{
    public class ConversionAPMaTPL
    {
        public static void Main()
        {
            // Variables auxiliares:
            int idThread;
            TareaAsincronica ta = Prueba;
            TareaAsincronicaIncompatible tai = Prueba;

            Console.WriteLine ("\nOpción 1:\n");

            // Tarea para el delegado TareaAsincronica:
            Task<string> tarea = Task<string>.Factory.FromAsync(
                ta.BeginInvoke("ThreadTareaAsincronica", Callback, "Invocación asincrónica con delegado."),
                ta.EndInvoke
            );

            // Continuar tarea:
            tarea.ContinueWith(t => Console.WriteLine ("El callback ha terminado.\n\tEjecución de continuación.\n\t\tResultado: {0}",
                t.Result));

            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep (TimeSpan.FromSeconds(0.5));
            }

            // El último estado de la tarea:
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);
            Thread.Sleep(TimeSpan.FromSeconds(1));


            Console.WriteLine ("----------------------------------------");
            Console.WriteLine ();
            Console.WriteLine ("Opción 2:\n");

            // Variante de la opción 1:
            tarea = Task<string>.Factory.FromAsync(
                ta.BeginInvoke, ta.EndInvoke, "ThreadTareaAsincronica", "Invocación asincrónica con delegado."
            );

            // Continuación tarea:
            tarea.ContinueWith(t => Console.WriteLine ("Tarea completada.\n\tEjecución de continuación.\n\tResultado: {0}",
                t.Result));

            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }

            // El último estado de la tarea:
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);
            Thread.Sleep(TimeSpan.FromSeconds(1));


            Console.WriteLine ("------------------------------------------");
            Console.WriteLine ();
            Console.WriteLine ("Opción 3:\n");

            // Envoltura del callback:
            IAsyncResult ar = tai.BeginInvoke(out idThread, Callback, "Invocación asincrónica de delegado.");

            tarea = Task<string>.Factory.FromAsync(ar, _ => tai.EndInvoke(out idThread, ar));

            // Continuación tarea:
            tarea.ContinueWith( t =>
                Console.WriteLine("Tarea completada.\n\tEjecución de continuación.\n\tResultado: {0}\n\tID Thread: {1}",
                    t.Result, idThread));

            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }

            Console.WriteLine ();
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);

            Thread.Sleep(TimeSpan.FromSeconds(1));

            Console.WriteLine ();
        }

        // Delegado con firma directamente compatible con TPL:
        private delegate string TareaAsincronica(string nombreThread);

        // Delegado con firma no compatible con TPL:
        private delegate string TareaAsincronicaIncompatible(out int idThread);

        // Callback para respuesta a llamadas asincrónicas:
        private static void Callback(IAsyncResult ar)
        {
            Console.WriteLine ("Iniciando callback...");
            Console.WriteLine ("Estado pasado al callback: {0}", ar.AsyncState);
            Console.WriteLine ("¿Thread del pool de threads?: {0}",
                Thread.CurrentThread.IsThreadPoolThread);
            Console.WriteLine ("ID del thread: {0}", Thread.CurrentThread.ManagedThreadId);
        }

        // Método para ejecución asincrónica:
        private static string Prueba(string nombreThread)
        {
            Console.WriteLine ("Iniciando prueba...");
            Console.WriteLine ("¿Thread del pool de threads?: {0}",
                Thread.CurrentThread.IsThreadPoolThread);

            // Espera simulada:
            Thread.Sleep(TimeSpan.FromSeconds(2));

            Thread.CurrentThread.Name = nombreThread;

            // Resultado:
            return String.Format("-Nombre thread: {0}-", Thread.CurrentThread.Name);
        }

        // Método para ejecución asincrónica:
        private static string Prueba(out int idThread)
        {
            Console.WriteLine ("Iniciando prueba...");
            Console.WriteLine ("¿Thread del pool de threads?: {0}",
                Thread.CurrentThread.IsThreadPoolThread);

            // Simulación de espera:
            Thread.Sleep(TimeSpan.FromSeconds(2));

            idThread = Thread.CurrentThread.ManagedThreadId;

            // Resultado:
            return String.Format("-ID del thread del pool de threads: {0}-", idThread);
        }
    }
}