Come posso eseguire un semplice bit di codice in un nuovo thread?

Ho un po 'di codice che devo eseguire in un thread diverso rispetto alla GUI in quanto attualmente causa il blocco del modulo mentre il codice viene eseguito (circa 10 secondi).

Supponiamo che non abbia mai creato un nuovo thread prima; qual è un esempio semplice / di base di come eseguire questa operazione in C # e utilizzare .NET Framework 2.0 o versioni successive?

Un buon posto per iniziare a leggere è Joe Albahari .

Se vuoi creare il tuo thread, questo è semplice come si ottiene:

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

BackgroundWorker sembra essere la scelta migliore per te.

Ecco il mio esempio minimo. Dopo aver fatto clic sul pulsante, il lavoratore in background inizierà a lavorare nel thread in background e riporterà contemporaneamente i suoi progressi. Riferirà anche dopo il completamento del lavoro.

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

Nota:

• Ho messo tutto in un unico metodo usando il metodo anonimo di C # per semplicità, ma puoi sempre estrarlo in diversi metodi.
• È sicuro aggiornare la GUI all'interno ProgressChangedo i RunWorkerCompletedgestori. Tuttavia, l'aggiornamento della GUI da DoWork causa InvalidOperationException.

Il ThreadPool.QueueUserWorkItem è abbastanza ideale per qualcosa di semplice. L'unica avvertenza è accedere a un controllo dall'altro thread.

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

Veloce e sporco, ma funzionerà:

Utilizzando in alto:

using System.Threading;

codice semplice:

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

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

L'ho appena lanciato in una nuova applicazione console per un esempio

Ecco un'altra opzione:

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

Prova a utilizzare la classe BackgroundWorker . Gli dai dei delegati per cosa eseguire e ricevi una notifica al termine del lavoro. C'è un esempio sulla pagina MSDN a cui ho collegato.

Se vuoi ottenere un valore:

var someValue;

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

thread.Start();

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

Inserisci quel codice in una funzione (il codice che non può essere eseguito sullo stesso thread della GUI) e per attivare l'esecuzione di quel codice inserisci quanto segue.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

Chiamare la funzione di avvio sull'oggetto thread provoca l'esecuzione della chiamata di funzione in un nuovo thread.

Ecco come utilizzare i thread con progressBar, è solo per capire come funzionano i thread, nella forma ci sono tre progressBar e il pulsante 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 il tuo codice (sopra) non è corretto. Non è necessario girare in attesa del completamento. EndInvoke si bloccherà fino alla segnalazione di WaitHandle.

Se vuoi bloccare fino al completamento devi semplicemente farlo

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

o in alternativa

ar.AsyncWaitHandle.WaitOne();

Ma qual è lo scopo di emettere eventuali chiamate in caso di blocco? Potresti anche usare una chiamata sincrona. Una scommessa migliore sarebbe quella di non bloccare e passare un lambda per la pulizia:

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

Una cosa da tenere a mente è che è necessario chiamare EndInvoke. Molte persone lo dimenticano e finiscono col perdere WaitHandle poiché la maggior parte delle implementazioni asincrone rilasciano il waithandle in EndInvoke.

Se stai per utilizzare l'oggetto Thread non elaborato, devi impostare IsBackground su true come minimo e devi anche impostare il modello Threading Apartment (probabilmente 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()
}

Consiglierei la classe BackgroundWorker se hai bisogno di interazione con l'interfaccia utente.

un'altra opzione, che utilizza delegati e il pool di thread ...

supponendo che 'GetEnergyUsage' sia un metodo che accetta un DateTime e un altro DateTime come argomenti di input e restituisce un 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);

Esistono molti modi per eseguire thread separati in .Net, ognuno con comportamenti diversi. Devi continuare a eseguire il thread dopo aver chiuso la GUI? Devi passare informazioni tra il thread e la GUI? Il thread deve aggiornare la GUI? Il thread dovrebbe chiudere un'attività o dovrebbe continuare a funzionare? Le risposte a queste domande ti diranno quale metodo utilizzare.

Esiste un buon articolo sul metodo asincrono nel sito Web Code Project che descrive i vari metodi e fornisce un codice di esempio.

Si noti che questo articolo è stato scritto prima che il modello asincrono / waitit e Task Parallel Library fossero introdotti in .NET.

Procedura: utilizzare un thread in background per cercare file

Devi stare molto attento con l'accesso da altri thread a elementi specifici della GUI (è comune per molti toolkit GUI). Se vuoi aggiornare qualcosa nella GUI dall'elaborazione del thread, controlla questa risposta che ritengo utile per WinForms. Per WPF vedere questo (mostra come toccare il componente nel metodo UpdateProgress () in modo che funzioni da altri thread, ma in realtà non mi piace che non lo faccia CheckAccess()prima di fare BeginInvoketramite Dispathcer, vedere e cercare CheckAccess in esso)

Stavo cercando un libro specifico su .NET per il threading e ho trovato questo (scaricabile gratuitamente). Vedi http://www.albahari.com/threading/ per maggiori dettagli al riguardo.

Credo che troverai ciò di cui hai bisogno per avviare l'esecuzione come nuovo thread nelle prime 20 pagine e ne ha molti di più (non sono sicuro dei frammenti specifici della GUI intendo strettamente specifici del threading). Sarei felice di sapere cosa pensa la comunità di questo lavoro perché sto leggendo questo. Per ora sembrava abbastanza pulito per me (per mostrare metodi e tipi specifici di .NET per il threading). Inoltre copre .NET 2.0 (e non antico 1.1) ciò che apprezzo molto.

Consiglio di dare un'occhiata alla libreria di thread di alimentazione di Jeff Richter e in particolare a IAsyncEnumerator. Dai un'occhiata al video sul blog di Charlie Calvert in cui Richter lo esamina per una buona panoramica.

Non lasciarti scoraggiare dal nome perché semplifica la codifica delle attività di programmazione asincrona.