Threads parametrizados en C#

Acostumbrado a usar hilos en Java y ahora que me ha tocado hacerlo en C# se me ha hecho extraño su uso al principio ya que cambia un poco.

En vez de crear una clase que herede de la clase thread, como se haría en Java, en C# lo que hay que hacer es crear un objeto de la clase que se quiera y lanzar un hilo que ejecute un método de ese objeto creado.

Además para poder pasarle parámetros al hilo/método hay que crear un tipo delegate que permite encapsular el método con sus parámetros, después estos parámetros podrán ser usados como lectura, lectura/escritura o incluso podrán devolver el resultado por valor. En este enlace hay un documento muy interesante.

Sin mas paso a poner un ejemplo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace myNameSpace
{
    public partial class MainClass
    {
        static void Main(string[] args)
        {
            // 1. Array de objetos que contiene los operadores y el resultado a devolver por referencia:
            object[] operadores = { 5 , 10 , 0 };

            // 2. Se crea un objeto de la clase operar:
            Operar operar = new Operar();

            // 3. Se lanza un hilo que ejecuta el metodo multiplicar de la clase instanciada:
            Thread miHilo = new Thread(delegate()
            {
                operar.multiplicar(operadores);
            });

            // 4. Se ejecuta el hilo:
            miHilo.Start();

            // 5. Se pausa el programa principal hasta que el hilo termine de hacer sus tareas:
            miHilo.Join();

            // 6. Se imprime el resultado y se sale del programa:
            MessageBox.Show(operadores[0] + " * " + operadores[1] + " = " + operadores[2]);
            Environment.Exit(0);
        }
    }


    public class Operar
    {
        public void multiplicar(object[] parametros)
        {
            Thread.Sleep(1000);
            parametros[2] = (((int)parametros[0]) * ((int)parametros[1]));
        }
    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Threading;

namespace myNameSpace

{

public partial class MainClass

{

static void Main(string[] args)

{

// 1. Array de objetos que contiene los operadores y el resultado a devolver por referencia:

object[] operadores = { 5 , 10 , 0 };

// 2. Se crea un objeto de la clase operar:

Operar operar = new Operar();

// 3. Se lanza un hilo que ejecuta el metodo multiplicar de la clase instanciada:

Thread miHilo = new Thread(delegate()

{

operar.multiplicar(operadores);

});

// 4. Se ejecuta el hilo:

miHilo.Start();

// 5. Se pausa el programa principal hasta que el hilo termine de hacer sus tareas:

miHilo.Join();

// 6. Se imprime el resultado y se sale del programa:

MessageBox.Show(operadores[0] + " * " + operadores[1] + " = " + operadores[2]);

Environment.Exit(0);

}

public class Operar

{

public void multiplicar(object[] parametros)

{

Thread.Sleep(1000);

parametros[2] = (((int)parametros[0]) * ((int)parametros[1]));

}

Si quisiéramos obtener los resultados por valor modificaríamos lo siguiente:

Thread miHilo = new Thread(delegate()
{
    operadores = operar.multiplicar(operadores);
});

//-------------------------

public object[] multiplicar(object[] parametros)
{
    Thread.Sleep(1000);
    int resultado = (((int)parametros[0]) * ((int)parametros[1]));
    return new Object[] { parametros[0] , parametros[1] , resultado };
}

Thread miHilo = new Thread(delegate()

{

operadores = operar.multiplicar(operadores);

});

//-------------------------

public object[] multiplicar(object[] parametros)

{

Thread.Sleep(1000);

int resultado = (((int)parametros[0]) * ((int)parametros[1]));

return new Object[] { parametros[0] , parametros[1] , resultado };

}

En ambos ejemplos se ha querido enviar los parámetros como un array pero no es necesario ya que no hay ningún impedimento en enviar varios parámetros por separado.