Wenn ihr auch mal mit Threads gearbeitet habt habt ihr sicherlich auch schon festgestellt, dass es zu Problemen kommt, wenn man einen Thread starten möchte und diesem auch noch Parameter unterjubeln will.

Ein normaler(einfacher) Threadstart sieht ja folgendermaßen aus:

public class test {
    public test() {
        Auto a = new Auto();

        Thread t = new Thread(new ThreadStart(a.Fahre));
    }
}

public class Auto {
    public void Fahre(){
        //...
    }
}



Aber was ist wenn wir nun dem Auto auch sagen sollen wie weit es fahren soll? Also so:
public class test {
    public test() {
        Auto a = new Auto();

        Thread t = new Thread(new ThreadStart(a.Fahre(100)));
    }
}

public class Auto {
    public void Fahre(){
        //...
    }

    public void Fahre(int wieWeit) {
        //...
    }
}



Leider geht das nicht so einfach, da ThreadStart einen Methodennamen erwartet. Hier müssen wir also anders ansetzen. Eine Möglichkeit dieses Problem zu lösen bzw. zu umgehen ist es die Klasse Auto etwas zu modifizieren und die Parameter, die wir eigentlich über den Methodenaufruf übergeben wollten über den Konstruktor zu übergeben (oder über Properties zu setzen). Somit wäre die Fahre Methode wieder frei von Parametern und könnte problemlos über ThreadStart aufgerufen werden:
public class test {
    public test() {
        Auto a = new Auto(100);

        Thread t = new Thread(new ThreadStart(a.Fahre));
    }
}

public class Auto {
    private int wieWeit;

    public Auto(int wieWeit) {
        this.wieWeit = wieWeit;
    }

    public void Fahre(){
        //... hier kann man mit dem Wert
        // von wieWeit arbeiten
    }
}



Aber diese „Lösung“ ist natürlich auch nicht das Gelbe vom Ei. Deswegen habe ich noch ein wenig gegoogelt und habe eine sehr schöne und zugleich einfache Lösung entdeckt:
    public class test {
        public test() {
            Auto a = new Auto();

            ThreadStart start = delegate { a.Fahre(100); };
            Thread t = new Thread(new ThreadStart(start));
        }
    }

    public class Auto {

        public void Fahre(int wieWeit) {
            //...
        }
    }



Hier machen wir von den Anonymen Methoden Gebrauch (siehe Zeile 5) und packen die in ein Delegate, das wir dann dem ThreadStart übergeben. Hier können wir auch bequem unseren Parameter mit angeben und müssen somit auch nicht an der Klasse selbst Änderungen vornehmen.
Kleiner Nachtrag noch:

Maximilian hat mich grad noch an das ParameterizedThreadStart Delegate aufmerksam gemacht, das habe ich noch unbewusst ausgelassen :). Dieses bietet ebenfalls eine angenehme Möglichkeit Parameter an Threads zu übergeben, hier auch dazu ein kleines Beispiel:
public class test {
    public test() {
        Auto a = new Auto();

        Thread t = new Thread(new ParameterizedThreadStart(a.Fahre));
        t.Start(100);
    }
}

public class Auto {

    public  void Fahre(object wieWeit) {
        //...
    }
}



Man beachte hierbei, dass der Typ des Parameters nun Object ist (Zeile 12) deswegen muss vor der Verwendung noch ein Cast stattfinden. Außerdem könnte man Probleme bekommen, wenn man Überladungen benutzen will.
Das ganze ist natürlich nichts weltbewegendes, aber da ich es noch nicht kannte habe ich es hier mal mit aufgenommen.