UI Asincrona

public partial class Form1 : Form
    {
        // El delegado que vamos a usar para invocar con BeginInvoke...
        public delegate void Invokador();

        public Form1()
        {
            InitializeComponent();

            //Cambiamos la barra para que esté animada desde que se carga el form
            barra.Style = ProgressBarStyle.Marquee;
        }

        // Función que se encarga de actualizar el texto tratandolo como si estuviera en el mismo hilo
        public void actualizaTexto()
        {
            Texto.Text += "TEXTO ";
        }

        // Función para limpiar el texto
        public void limpiaTexto()
        {
            Texto.Text = "";
        }

        // Función que comprueba si necesitamos invocar (Estamos en otro hilo?) y entonces invoca al delegado el cual recibe una
        // lambda ( () => ) la cual llama a la funcion que actualiza el texto (en ese punto ya estamos en el hilo principal)
        public void actualizaTextoAsincronamente()
        {
            if (Texto.InvokeRequired) Texto.BeginInvoke(new Invokador(() => actualizaTexto()));
            // Si sabes seguro que estas en otro hilo, te puedes ahorrar el InvokeRequired, pero a mi me gusta ponerlo...
        }

        // Botón que actualiza el texto de manera sincrónica, congelando la UI.
        private void ButSincrono_Click(object sender, EventArgs e)
        {
            limpiaTexto();

            for (int i = 0; i < 100; i++)
            {
                Thread.Sleep(50);       // Espera 50 milisegundos en cada iteración, esto acentúa el congelamiento.
                actualizaTexto();
            }
        }

        // Función que crea un hilo paralelo, llamando al delegado que llama a una lambda, la cual llama a la función para actualizar
        // el texto desde otro thread distinto.
        private void ButThread_Click(object sender, EventArgs e)
        {
            limpiaTexto();

            Thread hilo = new Thread(new ThreadStart( () => ejecutaBucleAsincronamente() )); // Aquí declaramos el hilo.
            hilo.Start();   // Aquí arrancamos el hilo.
        }

        // Adaptación asincrona del bucle que se encarga de actualizar el texto. (Se usa siempre que sepamos que estamos en otro hilo)
        private void ejecutaBucleAsincronamente()
        {
            for (int i = 0; i < 100; i++)
            {
                Thread.Sleep(50);       // Espera 50 milisegundos en cada iteración, aquí la congelación la tiene el hilo secundario.
                actualizaTextoAsincronamente();
            }
        }

        // Función que hace uso de Task.Run de .NET 4.5 (En 4.0 es Task.Factory.StartNew) para lanzar una Task directamente, sin tener que declararla
        private void ButTaskRun_Click(object sender, EventArgs e)
        {
            limpiaTexto();

            Task.Run( () => ejecutaBucleAsincronamente() );     // Lambdas, lambdas everywhere. :)
        }

        // Función que declara una tarea y luego la ejecuta.
        private void ButTask_Click(object sender, EventArgs e)
        {
            limpiaTexto();

            Task tarea = new Task( () => ejecutaBucleAsincronamente());

            tarea.Start();

            // Aquí se muestra como utilizar una sencilla continuación mediante el uso de una lambda que llama a una msgbox.
            // Lo que se le pasa a la lambda entre paréntesis (tareaAnterior) está dentro del contexto de la lambda solamente
            // y sirve para obtener los valores de la tarea anterior, si fuera necesario.
            // Además se muestra como a las lambda se les puede poner llaves para poner más de una instrucción.

            tarea.ContinueWith( (tareaAnterior) => {

                // Para mostrar el uso de valores de la tarea anterior, se obtiene el bool de si esa tarea fue o no completada.
                MessageBox.Show(tareaAnterior.IsCompleted.ToString(),"HECHO!");

            });     // Al cerrar las llaves de la lambda, seguimos teniendo que cerrar los paréntesis de la llamada a ContinueWith.
        }


        // Pequeño ejemplo de como hacer un par de llamadas a async
        private void ButAsync_Click(object sender, EventArgs e)
        {
            limpiaTexto();
            Bucle();
        }

        // Bucle está declarada como async pero en la función anterior se la llama sincrónicamente...
        public async void Bucle()
        {
            for (int i = 0; i < 1000; i++)
                // Aguardamos a la Task que actualiza el texto.
                await actualizaTextoAsync();
        }

        // Esta función es una tarea, porque para usar await se ha de hacer contra funciones u objetos que devuelvan o sean Task.
        public async Task actualizaTextoAsync()
        {
                await Task.Delay(50);   // Aguardamos un retardo de 50 ms.
                actualizaTexto();       // Actualizamos el texto tranquilamente, de manera normal. ;)
        }



    }   // Form1