Bagaimana cara menjalankan sedikit kode sederhana di utas baru?

Saya memiliki sedikit kode yang harus saya jalankan di utas yang berbeda dari GUI karena saat ini menyebabkan formulir membeku sementara kode berjalan (sekitar 10 detik).

Asumsikan saya belum pernah membuat utas baru sebelumnya; apa contoh sederhana / dasar tentang bagaimana melakukan ini di C # dan menggunakan .NET Framework 2.0 atau yang lebih baru?

Tempat yang baik untuk mulai membaca adalah Joe Albahari .

Jika Anda ingin membuat utas sendiri, ini sesederhana mungkin:

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

BackgroundWorker tampaknya menjadi pilihan terbaik untuk Anda.

Inilah contoh minimal saya. Setelah Anda mengklik tombol pekerja latar akan mulai bekerja di utas latar dan juga melaporkan kemajuannya secara bersamaan. Ini juga akan melaporkan setelah pekerjaan selesai.

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

catatan:

• Saya meletakkan semuanya dalam satu metode menggunakan metode anonim C # untuk kesederhanaan tetapi Anda selalu dapat menarik mereka ke metode yang berbeda.
• Aman untuk memperbarui GUI di dalam ProgressChangedatau RunWorkerCompletedpenangan. Namun, memperbarui GUI dari DoWork akan menyebabkan InvalidOperationException.

The ThreadPool.QueueUserWorkItem cukup ideal untuk sesuatu yang sederhana. Satu-satunya peringatan adalah mengakses kontrol dari utas lainnya.

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

Cepat dan kotor, tetapi akan berhasil:

Menggunakan di atas:

using System.Threading;

kode sederhana:

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

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

Saya baru saja melemparkan ini ke aplikasi konsol baru untuk exmaple

Berikut ini pilihan lain:

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

Coba gunakan kelas BackgroundWorker . Anda memberinya delegasi untuk apa yang harus dijalankan, dan untuk diberitahu ketika pekerjaan telah selesai. Ada contoh di halaman MSDN yang saya tautkan.

Jika Anda ingin mendapatkan nilai:

var someValue;

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

thread.Start();

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

Letakkan kode itu dalam suatu fungsi (kode yang tidak bisa dieksekusi di utas yang sama dengan GUI), dan untuk memicu eksekusi kode itu, letakkan yang berikut ini.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Memanggil fungsi mulai pada objek utas akan menyebabkan pelaksanaan panggilan fungsi Anda di utas baru.

Di sini bagaimana caranya menggunakan utas dengan progressBar, itu hanya untuk menggarisbawahi cara kerja utas, dalam bentuk ada tiga tombol progressBar dan 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 kode Anda (di atas) tidak benar. Anda tidak perlu berputar menunggu sampai selesai. EndInvoke akan memblokir hingga WaitHandle diberi sinyal.

Jika Anda ingin memblokir hingga selesai, Anda hanya perlu melakukannya

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

atau sebagai alternatif

ar.AsyncWaitHandle.WaitOne();

Tapi apa gunanya mengeluarkan panggilan telepon jika Anda memblokir? Anda mungkin juga hanya menggunakan panggilan sinkron. Taruhan yang lebih baik adalah dengan tidak memblokir dan meneruskan lambda untuk pembersihan:

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

Satu hal yang perlu diingat adalah Anda harus menelepon EndInvoke. Banyak orang lupa ini dan akhirnya membocorkan WaitHandle karena kebanyakan implementasi async melepaskan waithandle di EndInvoke.

Jika Anda akan menggunakan objek Thread mentah maka Anda harus mengatur IsBackground menjadi true minimum dan Anda juga harus mengatur model Threading Apartment (mungkin 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()
}

Saya akan merekomendasikan kelas BackgroundWorker jika Anda memerlukan interaksi UI.

opsi lain, yang menggunakan delegasi dan Thread Pool ...

dengan asumsi 'GetEnergyUsage' adalah metode yang mengambil DateTime dan DateTime lain sebagai argumen input, dan mengembalikan ...

// 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);

Ada banyak cara menjalankan utas terpisah di .Net, masing-masing memiliki perilaku yang berbeda. Apakah Anda perlu terus menjalankan utas setelah GUI berhenti? Apakah Anda perlu menyampaikan informasi antara utas dan GUI? Apakah utas perlu memperbarui GUI? Haruskah utas melakukan satu tugas kemudian berhenti, atau haruskah terus berjalan? Jawaban atas pertanyaan-pertanyaan ini akan memberi tahu Anda metode mana yang digunakan.

Ada artikel metode async yang bagus di situs web Proyek Code yang menjelaskan berbagai metode dan memberikan kode sampel.

Catatan artikel ini ditulis sebelum pola async / await dan Task Parallel Library diperkenalkan ke .NET.

Cara: Gunakan Thread Latar Belakang untuk Mencari File

Anda harus sangat berhati-hati dengan akses dari utas lain ke hal-hal spesifik GUI (ini umum untuk banyak toolkit GUI). Jika Anda ingin memperbarui sesuatu dalam GUI dari pemrosesan utas, periksa jawaban ini yang menurut saya berguna untuk WinForms. Untuk WPF lihat ini (ini menunjukkan bagaimana menyentuh komponen dalam metode UpdateProgress () sehingga akan bekerja dari utas lainnya, tapi sebenarnya saya tidak suka itu tidak dilakukan CheckAccess()sebelum melakukan BeginInvokemelalui Dispathcer, lihat dan cari CheckAccess di dalamnya)

Sedang mencari .NET buku khusus tentang threading dan menemukan ini (dapat diunduh gratis). Lihat http://www.albahari.com/threading/ untuk perincian lebih lanjut tentang itu.

Saya yakin Anda akan menemukan apa yang Anda butuhkan untuk menjalankan eksekusi sebagai utas baru di 20 halaman pertama dan memiliki lebih banyak (tidak yakin tentang cuplikan khusus GUI yang saya maksud khusus untuk threading). Senang mendengar apa pendapat masyarakat tentang pekerjaan ini karena saya membaca yang ini. Untuk sekarang tampak cukup rapi untuk saya (untuk menunjukkan metode dan jenis NET spesifik untuk threading). Juga mencakup .NET 2.0 (dan bukan 1.1 kuno) apa yang saya sangat hargai.

Saya akan merekomendasikan melihat Power Threading Library milik Jeff Richter dan khususnya IAsyncEnumerator. Lihatlah videonya di Charlie Calvert's blog mana Richter memeriksanya untuk ikhtisar yang bagus.

Jangan menunda namanya karena itu membuat tugas pemrograman yang tidak sinkron lebih mudah dikodekan.