Guide C# – Passaggio di Parametri ai Thread

Continuano gli articoli sui thread in c#. Come abbiamo visto l’utilizzo dei thread è molto semplice da gestire in c#, in questo articolo ho cercato di spiegare al meglio come avviare una funzione specifica in un thread parallelo. Ciò di cui però non ho parlato è la possibilità di gestire anche chiamate parametriche asincrone. L’intenzione è quella di avviare una funzione che richiede un numero qualsiasi di parametri in un thread a parte che lavora autonomamente. La procedura, tra l’altro estremamente semplice, è analoga a quella dell’articolo precedente.

Assicuriamoci innanzitutto di avere importato le librerie per il Threading:

using System.Threading;

Adesso dobbiamo solo apportare qualche modifica al codice precedente per l’avvio del thread. Supponiamo ad esempio di voler eseguire un banale ciclo da 1 a N dove N sarà uno dei parametri che passeremo alla funzione Foo per poi visualizzare un messaggio in una MessageBox, anch’esso passato come parametro. Il codice, molto semplice, è questo:

//creiamo un oggetto di tipo ParameterizedThreadStart, un ThreadStart parametrico
ParameterizedThreadStart entry = new ParameterizedThreadStart(Foo);
//come nel codice precedente creiamo il thread
Thread thread = new Thread(entry);
//e lo avviamo, però creando stavolta un array di oggetti con all'interno un valore long (N) e la stringa di chiusura
thread.Start(new object[] { (long)100000000, "ciao ho finito" });

Passiamo invece ora alla realizzazione della funzione, sicuramente più interessante:

private void Foo(object state)
{
//converto il parametro in un array di oggetti
object[] stateArray = (object[])state;
//il primo è un long
long nValue = (long)stateArray[0];
//il secondo una stringa
string end = (string)stateArray[1];

//eseguo il codice
for (long i = 0; i < nValue; i++)
{
//fa niente
}
//invio un messaggio di uscita
MessageBox.Show(end);
}

Nulla di eccessivamente complesso… tuttavia la pulizia del codice fa un pò desiderare, perchè devo essere obbligato a passare i parametri per forza in quell’ordine quando dispongo di un linguaggio ad oggetti? Effettivamente la risposta è immediata, creiamo un oggetto che farà da tramite per tutte queste chiamate:

class FooObject
{
private long _nValue;

public long NValue
{
get { return _nValue; }
set { _nValue = value; }
}

private string _endValue;

public string EndValue
{
get { return _endValue; }
set { _endValue = value; }
}

public FooObject(long nValue, string endValue)
{
NValue = nValue;
EndValue = endValue;
}
}

L’oggetto non è particolarmente complesso, contiene due campi (NValue ed EndValue) con relativi accessor ed un costruttore che inizializza i campi. La chiamata del Thread parametrico cambia leggermente:

thread.Start(new FooObject((long)100000000, "ciao ho finito"));

Mentre il codice della funzione è molto più pulito ora:

private void Foo(object state)
{
FooObject fooObject = (FooObject)state;

for (long i = 0; i < fooObject.NValue; i++)
{
//fa niente
}
MessageBox.Show(fooObject.EndValue);
}

Adesso abbiamo a disposizione un thread parallelo al quale abbiamo anche potuto passare parametri, sicuramente utile in numerose situazioni!