Threading ist ein sehr komplexes Thema und es gibt auch genügend Alternativen Prozesse zeitgleich zu starten. Siehe BackgroundWorker, Task, Linqextension Parallel und Konsorten sowie asynchronen Methoden an WebServices und mehr…

Im Folgenden wird an einem recht einfachen Beispiel versucht zu veranschaulichen, wie man Arbeitsaufgaben mit einfachen .NET Mitteln parallel erledigen kann. Also wie man quasi eine Methode in einem anderen Thread aufrufen kann, die die Arbeit im Hintergrund erledigen soll ohne den anderen, aufrufenden Thread zu blockieren.

Ich erstelle mir dazu eine Methode welche aus der Programmlogik aufgerufen werden soll. Diese verwendet eine weitere Methode, die die eigentliche Arbeit übernimmt. Damit ich der asynchronen Methode auch Parameter mitgeben kann, verwende ich zusätzlich der normalen Thread-Klasse die Klasse ParameterizedThreadStart, weil es durch diese ermöglicht wird, Parameter an die Jobmethode weiterzuleiten.

Die notwendigen Parameter halte ich in der Klasse Namens “AsyncData”, die zu den Daten auch eine boolesche Variable beinhaltet. Mit dieser Variable ist es mir möglich zu prüfen wann der asynchrone Prozess denn erledigt ist. Damit ich keine Problem bekomme, wenn beide Threads auf diese Variable zugreifen wollen verwende ich das Schlüsselwort volatile.

Klasse Asyncdata:

1
2
3
4
5
6

protected class AsyncData
{
    public List<Person> Personen = new List<Person>();
    public int PersonenRequired { get; set; }
    public volatile bool IsCompleted;
}

Dieses Methode erstellt die den Arbeitsthread und lässt über eine weitere Methode den Job erledigen.

1
2
3
4
5
6

private static void GetPersonen(AsyncData data)
{
    ParameterizedThreadStart pts = new ParameterizedThreadStart(GetPersonenJob);
    Thread thread = new Thread(pts);
    thread.Start(data);
}

Die folgende Methode erledigt den Job und setzt die boolesche Variable, wenn die Arbeit erledigt ist auf true

1
2
3
4
5
6
7
8
9
10
11
12
13

private static void GetPersonenJob(object result)
{
    AsyncData asyncData = (AsyncData)result;
 
    //Beispiel Job, der viel zeit in Anspruch nimmt (ggfl. Anzahl der Personen erhoehen)
    for (int i = 0; i < asyncData.PersonenRequired; i++)
    {
        var p = new Person() { Age = i, Firstname = "Bla" + i, Name = "Blubb" + i };
        asyncData.Personen.Add(p);
    }
    //Job erledigt
    asyncData.IsCompleted = true;
}

Der Aufruf im Programm, stellt sich wie folgt dar:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

static void Main(string[] args)
{
    AsyncData asyncData = new AsyncData();
    asyncData.PersonenRequired = 1000000;
    GetPersonen(asyncData);
 
    //an der Stelle verwende ich die boolesche Variable und zu pruefen ob der Job erledigt ist.
    while (!asyncData.IsCompleted)
        Thread.Sleep(1);
 
    foreach (var person in asyncData.Personen)
    {
        Console.WriteLine("{0},{1} Alter: {2}", person.Name, person.Firstname, person.Age);
    }
 
    Console.ReadLine();
}

//Beispielklasse

1
2
3
4
5
6

internal class Person
{
public string Name { get; set; }
public string Firstname { get; set; }
public int Age { get; set; }
}

Viel Spass beim entwickeln : )

Ähnliche Beiträge

• 3. Dezember 2010 -- Biggle ist kein Palindrom
• 16. November 2010 -- Windows Phone 7 – Push Notification
• 1. November 2010 -- Bing API Beispiel – C# Quicky
• 13. April 2010 -- Das WPF Control “Popup” – HowTo
• 7. April 2010 -- WCFService testen