Wie führe ich ein einfaches Stück Code in einem neuen Thread aus?

Ich habe ein bisschen Code, den ich in einem anderen Thread als der GUI ausführen muss, da das Formular derzeit einfriert, während der Code ausgeführt wird (ca. 10 Sekunden).

Angenommen, ich habe noch nie einen neuen Thread erstellt. Was ist ein einfaches / grundlegendes Beispiel dafür, wie dies in C # und unter Verwendung von .NET Framework 2.0 oder höher durchgeführt wird?

Ein guter Ort, um mit dem Lesen zu beginnen, ist Joe Albahari .

Wenn Sie einen eigenen Thread erstellen möchten, ist dies so einfach wie möglich:

using System.Threading;
new Thread(() => 
{
    Thread.CurrentThread.IsBackground = true; 
    /* run your code here */ 
    Console.WriteLine("Hello, world"); 
}).Start();

BackgroundWorker scheint die beste Wahl für Sie zu sein.

Hier ist mein minimales Beispiel. Nachdem Sie auf die Schaltfläche geklickt haben, beginnt der Hintergrundarbeiter mit der Arbeit im Hintergrundthread und meldet gleichzeitig den Fortschritt. Es wird auch nach Abschluss der Arbeiten berichtet.

using System.ComponentModel;
...
    private void button1_Click(object sender, EventArgs e)
    {
        BackgroundWorker bw = new BackgroundWorker();

        // this allows our worker to report progress during work
        bw.WorkerReportsProgress = true;

        // what to do in the background thread
        bw.DoWork += new DoWorkEventHandler(
        delegate(object o, DoWorkEventArgs args)
        {
            BackgroundWorker b = o as BackgroundWorker;

            // do some simple processing for 10 seconds
            for (int i = 1; i <= 10; i++)
            {
                // report the progress in percent
                b.ReportProgress(i * 10);
                Thread.Sleep(1000);
            }

        });

        // what to do when progress changed (update the progress bar for example)
        bw.ProgressChanged += new ProgressChangedEventHandler(
        delegate(object o, ProgressChangedEventArgs args)
        {
            label1.Text = string.Format("{0}% Completed", args.ProgressPercentage);
        });

        // what to do when worker completes its task (notify the user)
        bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(
        delegate(object o, RunWorkerCompletedEventArgs args)
        {
            label1.Text = "Finished!";
        });

        bw.RunWorkerAsync();
    }

Hinweis:

• Der Einfachheit halber habe ich alles mit der anonymen Methode von C # in einer einzigen Methode zusammengefasst, aber Sie können sie jederzeit auf verschiedene Methoden zurückziehen.
• Es ist sicher, die GUI innerhalb ProgressChangedoder der RunWorkerCompletedHandler zu aktualisieren . Das Aktualisieren der GUI von DoWork führt jedoch dazu InvalidOperationException.

Das ThreadPool.QueueUserWorkItem ist ziemlich ideal für etwas Einfaches. Die einzige Einschränkung ist der Zugriff auf ein Steuerelement vom anderen Thread.

System.Threading.ThreadPool.QueueUserWorkItem(delegate {
    DoSomethingThatDoesntInvolveAControl();
}, null);

Schnell und schmutzig, aber es wird funktionieren:

Oben verwenden:

using System.Threading;

einfacher Code:

static void Main( string[] args )
{
    Thread t = new Thread( NewThread );
    t.Start();
}

static void NewThread()
{
    //code goes here
}

Ich habe dies zum Beispiel in eine neue Konsolenanwendung geworfen

Hier ist eine weitere Option:

Task.Run(()=>{
//Here is a new thread
});

Versuchen Sie es mit der BackgroundWorker- Klasse. Sie geben ihm Delegierte, was ausgeführt werden soll, und werden benachrichtigt, wenn die Arbeit beendet ist. Auf der MSDN-Seite, auf die ich verlinkt habe, befindet sich ein Beispiel.

Wenn Sie einen Wert erhalten möchten:

var someValue;

Thread thread = new Thread(delegate()
            {                 
                //Do somthing and set your value
                someValue = "Hello World";
            });

thread.Start();

while (thread.IsAlive)
  Application.DoEvents();

Fügen Sie diesen Code in eine Funktion ein (den Code, der nicht im selben Thread wie die GUI ausgeführt werden kann), und geben Sie Folgendes ein, um die Ausführung dieses Codes auszulösen.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Wenn Sie die Startfunktion für das Thread-Objekt aufrufen, wird Ihr Funktionsaufruf in einem neuen Thread ausgeführt.

Hier erfahren Sie, wie Sie Threads mit einer progressBar verwenden können. Dies dient nur dazu, die Funktionsweise der Threads zu verstehen. In der Form gibt es drei progressBar- und vier Schaltflächen:

 public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    Thread t, t2, t3;
    private void Form1_Load(object sender, EventArgs e)
    {

        CheckForIllegalCrossThreadCalls = false;

         t = new Thread(birinicBar); //evry thread workes with a new progressBar


         t2 = new Thread(ikinciBar);


         t3 = new Thread(ucuncuBar);

    }

    public void birinicBar() //to make progressBar work
    {
        for (int i = 0; i < 100; i++) {
            progressBar1.Value++;
            Thread.Sleep(100); // this progressBar gonna work faster
        }
    }

    public void ikinciBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar2.Value++;
            Thread.Sleep(200);
        }


    }

    public void ucuncuBar()
    {
        for (int i = 0; i < 100; i++)
        {
            progressBar3.Value++;
            Thread.Sleep(300);
        }
    }

    private void button1_Click(object sender, EventArgs e) //that button to start the threads
    {
        t.Start();
        t2.Start(); t3.Start();

    }

    private void button4_Click(object sender, EventArgs e)//that button to stup the threads with the progressBar
    {
        t.Suspend();
        t2.Suspend();
        t3.Suspend();
    }

    private void button2_Click(object sender, EventArgs e)// that is for contuniue after stuping
    {
        t.Resume();
        t2.Resume();
        t3.Resume();
    }

    private void button3_Click(object sender, EventArgs e) // finally with that button you can remove all of the threads
    {
        t.Abort();
        t2.Abort();
        t3.Abort();
    }
}

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Charles, dein Code (oben) ist nicht korrekt. Sie müssen nicht warten, bis der Vorgang abgeschlossen ist. EndInvoke wird blockiert, bis das WaitHandle signalisiert wird.

Wenn Sie bis zur Fertigstellung blockieren möchten, müssen Sie einfach

nrgDel.EndInvoke(nrgDel.BeginInvoke(lastRuntime,procDT,null,null));

oder alternativ

ar.AsyncWaitHandle.WaitOne();

Aber was bringt es, wenn Sie blockieren, wenn Sie blockieren? Sie können auch einfach einen synchronen Anruf verwenden. Eine bessere Wette wäre, ein Lambda nicht zu blockieren und zur Bereinigung weiterzugeben:

nrgDel.BeginInvoke(lastRuntime,procDT,(ar)=> {ar.EndInvoke(ar);},null);

Eine Sache im Auge zu behalten ist , dass Sie müssen EndInvoke nennen. Viele Leute vergessen dies und verlieren am Ende das WaitHandle, da die meisten asynchronen Implementierungen das Waithandle in EndInvoke freigeben.

Wenn Sie das rohe Thread-Objekt verwenden möchten, müssen Sie IsBackground mindestens auf true setzen und das Threading Apartment-Modell (wahrscheinlich STA) festlegen.

public static void DoWork()
{
    // do some work
}

public static void StartWorker()
{
    Thread worker = new Thread(DoWork);
    worker.IsBackground = true;
    worker.SetApartmentState(System.Threading.ApartmentState.STA);
    worker.Start()
}

Ich würde die BackgroundWorker-Klasse empfehlen, wenn Sie eine UI-Interaktion benötigen.

Eine weitere Option, die Delegaten und den Thread-Pool verwendet ...

Angenommen, 'GetEnergyUsage' ist eine Methode, die eine DateTime und eine andere DateTime als Eingabeargumente verwendet und eine Int ...

// following declaration of delegate ,,,
public delegate long GetEnergyUsageDelegate(DateTime lastRunTime, 
                                            DateTime procDateTime);

// following inside of some client method 
GetEnergyUsageDelegate nrgDel = GetEnergyUsage;                     
IAsyncResult aR = nrgDel.BeginInvoke(lastRunTime, procDT, null, null);
while (!aR.IsCompleted) Thread.Sleep(500);
int usageCnt = nrgDel.EndInvoke(aR);

Es gibt viele Möglichkeiten, separate Threads in .Net auszuführen. Jedes hat unterschiedliche Verhaltensweisen. Müssen Sie den Thread nach dem Beenden der GUI weiter ausführen? Müssen Sie Informationen zwischen dem Thread und der GUI weitergeben? Muss der Thread die GUI aktualisieren? Sollte der Thread eine Aufgabe ausführen und dann beenden oder sollte er weiter ausgeführt werden? Die Antworten auf diese Fragen zeigen Ihnen, welche Methode Sie verwenden müssen.

Auf der Code Project-Website finden Sie einen guten Artikel über asynchrone Methoden, in dem die verschiedenen Methoden beschrieben und Beispielcode bereitgestellt werden.

Beachten Sie, dass dieser Artikel geschrieben wurde, bevor das asynchrone / wartende Muster und die Task Parallel Library in .NET eingeführt wurden.

Gewusst wie: Verwenden Sie einen Hintergrund-Thread, um nach Dateien zu suchen

Sie müssen beim Zugriff von anderen Threads auf GUI-spezifische Inhalte sehr vorsichtig sein (dies ist bei vielen GUI-Toolkits üblich). Wenn Sie etwas in der GUI über den Verarbeitungsthread aktualisieren möchten, überprüfen Sie diese Antwort , die meiner Meinung nach für WinForms nützlich ist. Für WPF siehe dies (es zeigt, wie man eine Komponente in der UpdateProgress () -Methode berührt, damit sie von anderen Threads aus funktioniert, aber eigentlich gefällt es mir nicht, dass es nicht funktioniert, CheckAccess()bevor man BeginInvokeDispathcer durchläuft, siehe CheckAccess darin und sucht danach).

Ich habe ein .NET-spezifisches Buch zum Thema Threading gesucht und dieses gefunden (kostenlos herunterladbar). Siehe http://www.albahari.com/threading/ , um weitere Informationen darüber.

Ich glaube, Sie werden auf den ersten 20 Seiten finden, was Sie brauchen, um die Ausführung als neuer Thread zu starten, und es gibt noch viel mehr (nicht sicher über GUI-spezifische Snippets, die ich streng spezifisch für das Threading meine). Würde mich freuen zu hören, was die Community über diese Arbeit denkt, denn ich lese diese. Im Moment sah es für mich ziemlich ordentlich aus (um .NET-spezifische Methoden und Typen für das Threading anzuzeigen). Außerdem behandelt es .NET 2.0 (und nicht das alte 1.1), was ich wirklich schätze.

Ich würde empfehlen, sich Jeff Richters Power Threading Library und speziell den IAsyncEnumerator anzusehen. Schauen Sie sich das Video zu Charlie Calvert an Blog an, in dem Richter einen guten Überblick darüber gibt.

Lassen Sie sich nicht vom Namen abschrecken, da dadurch asynchrone Programmieraufgaben einfacher zu codieren sind.