Jak uruchomić prosty fragment kodu w nowym wątku?

Mam trochę kodu, który muszę uruchomić w innym wątku niż GUI, ponieważ obecnie powoduje zawieszanie się formularza podczas działania kodu (około 10 sekund).

Załóżmy, że nigdy wcześniej nie tworzyłem nowego wątku; jaki jest prosty / podstawowy przykład tego, jak to zrobić w języku C # i przy użyciu .NET Framework 2.0 lub nowszej?

Dobrym miejscem do rozpoczęcia czytania jest Joe Albahari .

Jeśli chcesz utworzyć własny wątek, jest to tak proste, jak to możliwe:

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

BackgroundWorker wydaje się być najlepszym wyborem dla Ciebie.

Oto mój minimalny przykład. Po kliknięciu przycisku pracownik w tle rozpocznie pracę w wątku w tle i jednocześnie będzie raportować swoje postępy. Będzie także raportować po zakończeniu pracy.

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();
    }

Uwaga:

• Dla uproszczenia umieściłem wszystko w jednej metodzie za pomocą anonimowej metody C #, ale zawsze możesz wyciągnąć je na różne metody.
• Aktualizowanie GUI w programie obsługi ProgressChangedlub w programie RunWorkerCompletedobsługi jest bezpieczne . Jednak aktualizacja GUI DoWork spowoduje InvalidOperationException.

ThreadPool.QueueUserWorkItem jest całkiem idealne do czegoś prostego. Jedynym zastrzeżeniem jest dostęp do kontrolki z drugiego wątku.

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

Szybki i brudny, ale zadziała:

U góry:

using System.Threading;

prosty kod:

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

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

Właśnie wrzuciłem to do nowej aplikacji konsolowej na przykład

Oto kolejna opcja:

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

Spróbuj użyć klasy BackgroundWorker . Dajesz mu delegatów do uruchomienia i powiadamiania o zakończeniu pracy. Na stronie MSDN znajduje się przykład, z którym się łączyłem.

Jeśli chcesz uzyskać wartość:

var someValue;

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

thread.Start();

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

Umieść ten kod w funkcji (kod, którego nie można wykonać w tym samym wątku co GUI), a aby uruchomić wykonanie tego kodu, wstaw następujące polecenie.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Wywołanie funkcji start na obiekcie wątku spowoduje wykonanie wywołania funkcji w nowym wątku.

Tutaj, jak używać wątków z paskiem postępu, służy to po prostu zrozumieniu działania wątków, w formie są trzy paski postępu i przycisk 4:

 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 twój kod (powyżej) jest niepoprawny. Nie musisz obracać się, czekając na zakończenie. EndInvoke będzie blokować do momentu zasygnalizowania WaitHandle.

Jeśli chcesz zablokować do czasu zakończenia, po prostu musisz

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

lub alternatywnie

ar.AsyncWaitHandle.WaitOne();

Ale jaki jest sens wydawania połączeń anyc, jeśli blokujesz? Równie dobrze możesz użyć połączenia synchronicznego. Lepszym rozwiązaniem byłoby nie blokowanie i przekazywanie lambda do czyszczenia:

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

Należy pamiętać, że musisz wywołać EndInvoke. Wiele osób zapomina o tym i w końcu wyciekają WaitHandle, ponieważ większość implementacji asynchronicznych zwalnia waithandle w EndInvoke.

Jeśli zamierzasz użyć surowego obiektu Thread, musisz ustawić IsBackground na minimum, a także powinieneś ustawić model Threading Apartment (prawdopodobnie STA).

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()
}

Poleciłbym klasę BackgroundWorker, jeśli potrzebujesz interakcji z interfejsem użytkownika.

inna opcja, która wykorzystuje delegatów i pulę wątków ...

zakładając, że „GetEnergyUsage” jest metodą, która przyjmuje DateTime i inną DateTime jako argumenty wejściowe i zwraca 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);

Istnieje wiele sposobów uruchamiania osobnych wątków w .Net, z których każdy ma inne zachowania. Czy musisz kontynuować uruchamianie wątku po zamknięciu GUI? Czy potrzebujesz przekazać informacje między wątkiem a GUI? Czy wątek wymaga aktualizacji GUI? Czy wątek powinien wykonać jedno zadanie, a następnie zakończyć, czy powinien nadal działać? Odpowiedzi na te pytania podpowiedzą, jakiej metody użyć.

W witrynie Code Project znajduje się dobry artykuł na temat metody asynchronicznej, który opisuje różne metody i podaje przykładowy kod.

Uwaga: ten artykuł został napisany przed wprowadzeniem wzorca asynchronicznego / oczekiwania i biblioteki zadań równoległych do .NET.

Instrukcje: używanie wątku w tle do wyszukiwania plików

Musisz być bardzo ostrożny z dostępem z innych wątków do specyficznych dla GUI rzeczy (jest to powszechne w wielu zestawach narzędzi GUI). Jeśli chcesz zaktualizować coś w GUI z przetwarzania wątku, sprawdź tę odpowiedź, która moim zdaniem jest przydatna dla WinForm. W przypadku WPF zobacz to (pokazuje, jak dotknąć komponentu w metodzie UpdateProgress (), aby działał z innych wątków, ale tak naprawdę nie podoba mi się, że nie robi się to CheckAccess()przed BeginInvokeprzejściem przez Dispathcer, zobacz i wyszukaj w nim CheckAccess)

Szukałem konkretnej książki .NET na temat wątków i znalazłem tę (do pobrania za darmo). Więcej informacji na ten temat można znaleźć na stronie http://www.albahari.com/threading/ .

Wierzę, że znajdziesz to, czego potrzebujesz, aby uruchomić wykonywanie jako nowy wątek na pierwszych 20 stronach i ma on o wiele więcej (nie jestem pewien co do fragmentów specyficznych dla GUI, to znaczy ściśle specyficznych dla wątków). Z przyjemnością usłyszę, co społeczność myśli o tej pracy, ponieważ ją czytam. Na razie wyglądało to dla mnie całkiem fajnie (do pokazywania metod i typów specyficznych dla .NET dla wątków). Obejmuje również .NET 2.0 (a nie starożytny 1.1), co naprawdę doceniam.

Poleciłbym przejrzeć bibliotekę Power Threading Library Jeffa Richtera, a zwłaszcza IAsyncEnumerator. Spójrz na wideo na blogu Charliego Calvert'a, na którym Richter je omawia, aby uzyskać dobry przegląd.

Nie zniechęcaj się tą nazwą, ponieważ ułatwia kodowanie zadań programowania asynchronicznego.