Comment exécuter un simple bout de code dans un nouveau thread?

J'ai un peu de code que je dois exécuter dans un thread différent de l'interface graphique car il provoque actuellement le gel du formulaire pendant l'exécution du code (environ 10 secondes).

Supposons que je n'ai jamais créé de nouveau thread auparavant; quel est un exemple simple / basique de la façon de procéder en C # et en utilisant .NET Framework 2.0 ou version ultérieure?

Un bon endroit pour commencer à lire est Joe Albahari .

Si vous souhaitez créer votre propre thread, c'est aussi simple que cela:

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

BackgroundWorker semble être le meilleur choix pour vous.

Voici mon exemple minimal. Après avoir cliqué sur le bouton, le travailleur d'arrière-plan commencera à travailler dans le fil d'arrière-plan et signalera également sa progression simultanément. Il fera également rapport à la fin des travaux.

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

Remarque:

• Je mets tout en méthode unique en utilisant la méthode anonyme de C # pour plus de simplicité, mais vous pouvez toujours les extraire vers différentes méthodes.
• Il est sûr de mettre à jour l'interface graphique dans ProgressChangedou RunWorkerCompleted gestionnaires. Cependant, la mise à jour de l'interface graphique à partir de DoWork entraînera InvalidOperationException.

Le ThreadPool.QueueUserWorkItem est assez idéal pour quelque chose de simple. La seule mise en garde est d'accéder à un contrôle à partir de l'autre thread.

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

Rapide et sale, mais cela fonctionnera:

Utilisation en haut:

using System.Threading;

code simple:

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

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

Je viens de le jeter dans une nouvelle application console pour un exmaple

Voici une autre option:

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

Essayez d'utiliser la classe BackgroundWorker . Vous lui donnez des délégués pour ce qu'il faut exécuter et pour être averti lorsque le travail est terminé. Il y a un exemple sur la page MSDN auquel j'ai lié.

Si vous souhaitez obtenir une valeur:

var someValue;

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

thread.Start();

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

Mettez ce code dans une fonction (le code qui ne peut pas être exécuté sur le même thread que l'interface graphique), et pour déclencher l'exécution de ce code, mettez ce qui suit.

Thread myThread= new Thread(nameOfFunction);

workerThread.Start();

L'appel de la fonction start sur l'objet thread entraînera l'exécution de votre appel de fonction dans un nouveau thread.

Voici comment utiliser des threads avec une barre de progression, c'est juste pour comprendre comment les threads fonctionnent, sous la forme il y a trois barres de progression et 4 boutons:

 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 votre code (ci-dessus) n'est pas correct. Vous n'avez pas besoin de tourner pour attendre la fin. EndInvoke se bloquera jusqu'à ce que le WaitHandle soit signalé.

Si vous souhaitez bloquer jusqu'à la fin, vous devez simplement

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

Ou bien

ar.AsyncWaitHandle.WaitOne();

Mais quel est l'intérêt d'émettre des appels anyc si vous bloquez? Vous pourriez tout aussi bien utiliser un appel synchrone. Un meilleur pari serait de ne pas bloquer et passer une lambda pour le nettoyage:

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

Une chose à garder à l'esprit est que vous devez appeler EndInvoke. Beaucoup de gens oublient cela et finissent par perdre le WaitHandle car la plupart des implémentations asynchrones libèrent le waithandle dans EndInvoke.

Si vous allez utiliser l'objet Thread brut, vous devez définir IsBackground sur true au minimum et vous devez également définir le modèle Threading Apartment (probablement 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()
}

Je recommanderais la classe BackgroundWorker si vous avez besoin d'une interaction avec l'interface utilisateur.

une autre option, qui utilise des délégués et le Thread Pool ...

en supposant que «GetEnergyUsage» est une méthode qui prend un DateTime et un autre DateTime comme arguments d'entrée, et retourne 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);

Il existe de nombreuses façons d'exécuter des threads distincts dans .Net, chacun a des comportements différents. Avez-vous besoin de continuer à exécuter le thread après la fermeture de l'interface graphique? Avez-vous besoin de transmettre des informations entre le thread et l'interface graphique? Le thread doit-il mettre à jour l'interface graphique? Le thread doit-il effectuer une tâche puis se fermer ou doit-il continuer à s'exécuter? Les réponses à ces questions vous diront quelle méthode utiliser.

Il existe un bon article sur la méthode asynchrone sur la sur le site Web Code Project qui décrit les différentes méthodes et fournit un exemple de code.

Notez que cet article a été écrit avant l' introduction du modèle async / attente et de la bibliothèque parallèle de tâches dans .NET.

Comment: utiliser un fil d'arrière-plan pour rechercher des fichiers

Vous devez être très prudent avec l'accès à partir d'autres threads à des choses spécifiques à l'interface graphique (cela est courant pour de nombreuses boîtes à outils GUI). Si vous souhaitez mettre à jour quelque chose dans l'interface graphique à partir du thread de traitement, vérifiez cette réponse qui, je pense, est utile pour WinForms. Pour WPF, voyez ceci (il montre comment toucher le composant dans la méthode UpdateProgress () pour qu'il fonctionne à partir d'autres threads, mais en fait je n'aime pas qu'il ne le fasse pas CheckAccess()avant de le faire BeginInvokevia Dispathcer, voir et rechercher CheckAccess dedans)

Je cherchais un livre spécifique à .NET sur le filetage et j'ai trouvé celui-ci (téléchargeable gratuitement). Voir http://www.albahari.com/threading/ pour plus de détails à ce sujet.

Je crois que vous trouverez ce dont vous avez besoin pour lancer l'exécution en tant que nouveau fil dans les 20 premières pages et il en a beaucoup plus (je ne suis pas sûr des extraits spécifiques à l'interface graphique, je veux dire strictement spécifiques au filetage). Serait heureux d'entendre ce que la communauté pense de ce travail parce que je lis celui-ci. Pour l'instant, cela me semblait plutôt bien (pour montrer les méthodes et les types spécifiques à .NET pour le filetage). Il couvre également .NET 2.0 (et non l'ancienne 1.1) ce que j'apprécie vraiment.

Je recommande de consulter la bibliothèque Power Threading de Jeff Richter et en particulier l'IAsyncEnumerator. Jetez un œil à la vidéo sur Charlie Calvert's blog de où Richter passe en revue pour un bon aperçu.

Ne vous laissez pas rebuter par le nom car cela rend les tâches de programmation asynchrones plus faciles à coder.