Passage de paramètres multithread C#

1. Passez par la classe d'entité (vous pouvez passer plusieurs paramètres et obtenir la valeur de retour), la démo est la suivante :

Fonction qui doit être appelée dans le fil :

namespace ThreadParameterDemo
{
    public class FunctionClass
    {
        public static string TestFunction(string name, int age)
        {
            //内部处理省略
            return name + " 的年龄是：" + age;
        }
    }
}

Encapsulé à travers des entités :

namespace ThreadParameterDemo
{
    /// <summary>
    /// 过渡类
    /// </summary>
    public class TransitionalClass
    {
        private string name = string.Empty;
        private int age;
        public string acceptResults = string.Empty;
        public TransitionalClass(string name, int age)
        {
            this.name = name;
            this.age = age;
        }

        public void TestFunction()
        {
            acceptResults = FunctionClass.TestFunction(this.name, this.age);
        }
    }
}

Appel :

  private void Form1_Load(object sender, EventArgs e)
        {
            //实例化ThreadWithState类，为线程提供参数  
            TransitionalClass tc = new TransitionalClass(" Jack", 42);
            // 创建执行任务的线程，并执行  
            Thread t = new Thread(new ThreadStart(tc.TestFunction));
            t.Start();
            //获取返回值，通过 tc.acceptResults;  
        }

Petite note :

Vous devez faire attention au problème d'IsBackground Si IsBackground est faux, le programme Windows ne quittera pas automatiquement le fil de discussion pour vous. quand il sort. Autrement dit, votre candidature n’est pas réellement terminée.

Recommandation MSDN : La meilleure façon de fournir des paramètres pour les appels de méthode multithread est d'envelopper la méthode cible dans une classe et de donner la classe Définir les champs qui seront utilisés comme paramètres pour le nouveau thread.

L'avantage de cette approche est qu'à chaque fois que vous souhaitez démarrer un nouveau fil de discussion, vous pouvez créer une nouvelle instance de la classe, avec ses propres paramètres.

Classe BackgroundWorker

La fonction dans ThreadStart n'a pas de valeur de retour ni de paramètres

2. Paramètres et valeurs de retour dans les appels asynchrones
La solution parfaite pour les paramètres et les valeurs de retour consiste à utiliser des appels asynchrones. Par rapport à Thread, l’un des plus gros inconvénients des appels asynchrones est qu’ils ne peuvent pas contrôler leur priorité.

Le code spécifique est le suivant :

        public delegate string delegateFunction(string name,int age);//委托
        delegateFunction df;
        private void Form1_Load(object sender, EventArgs e)
        {
            //指向需要调用的方法
            df = new delegateFunction(FunctionClass.TestFunction);
            string name = "my name";//输入参数 
            int age = 19;
            IAsyncResult result = df.BeginInvoke(name,age, null, null);
            string myResult = df.EndInvoke(result);//用于接收返回值 
            MessageBox.Show(myResult);
        }

Simplifié :

 public Func<string, int, string>  df;//委托
        private void Form1_Load(object sender, EventArgs e)
        {
            //指向需要调用的方法
            df += FunctionClass.TestFunction;
            string name = "my name";//输入参数 
            int age = 19;
            IAsyncResult result = df.BeginInvoke(name, age, null, null);
            string myResult = df.EndInvoke(result);//用于接收返回值 
            MessageBox.Show(myResult);
        }

Petite note :

Dans See More de cette façon Le nouveau thread généré s'exécute en arrière-plan (arrière-plan), et la priorité est normale

3 . Utilisez BackgroundWorker

Le moyen le plus simple de renvoyer une valeur à partir de plusieurs threads consiste à utiliser le composant BackgroundWorker pour gérer les threads, à déclencher un événement lorsque la tâche est terminée, puis à utiliser un gestionnaire d'événements. pour gérer le résultat.

Petite remarque :
Le composant BackgroundWorker est utilisé pour effectuer des opérations asynchrones fastidieuses telles que des transactions de base de données et des téléchargements de fichiers.
Ajoutez une instance BackgroundWorker dans l'application. Si vous utilisez VS, vous pouvez la faire glisser directement de l'outil vers l'application :

BackgroundWorker backgroundWorker1 = new BackgroundWorker();

Pour commencer à fonctionner en arrière-plan, vous devez appeler la méthode RunWorkerAsync() de BackgroundWorker. Lorsque cette méthode est appelée, BackgroundWorker commence à effectuer des opérations en arrière-plan en déclenchant l'événement DoWork. exécuté dans un autre thread.
Lorsque l'opération en arrière-plan est terminée, qu'elle soit terminée ou annulée, l'événement RunWorkerCompleted est déclenché. Grâce à cette méthode, le résultat de l'achèvement de l'opération en arrière-plan peut être renvoyé à l'utilisateur.
De plus, utilisez la propriété Canceled de l'instance RunWorkerCompletedEventArgs pour déterminer si l'opération en arrière-plan est terminée en raison de l'opération Cancel.

La démo spécifique est la suivante :

using System;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private void Form2_Load(object sender, EventArgs e)
        {
            //TransitionalClass tc = new TransitionalClass("xiaoming", 10);
            //ThreadPool.QueueUserWorkItem(new WaitCallback(TransitionalClass.TestFunction), tc);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            this.TestArea2();
        }

        private System.ComponentModel.BackgroundWorker BackgroundWorker1
    = new System.ComponentModel.BackgroundWorker();

        private void TestArea2()
        {
            InitializeBackgroundWorker();

            AreaClass2 AreaObject2 = new AreaClass2();
            AreaObject2.Base = 30;
            AreaObject2.Height = 40;

            // Start the asynchronous operation.
            BackgroundWorker1.RunWorkerAsync(AreaObject2);
        }

        private void InitializeBackgroundWorker()
        {
            // Attach event handlers to the BackgroundWorker object.
            BackgroundWorker1.DoWork +=
                new System.ComponentModel.DoWorkEventHandler(BackgroundWorker1_DoWork);
            BackgroundWorker1.RunWorkerCompleted +=
                new System.ComponentModel.RunWorkerCompletedEventHandler(BackgroundWorker1_RunWorkerCompleted);
        }

        private void BackgroundWorker1_DoWork(
            object sender,
            System.ComponentModel.DoWorkEventArgs e)
        {
          //在执行DoWork 事件时，DoWorkEventArgs 实例的Result 属性，返回值到用户；在RunWorkerCompleted 事件里，RunWorkerCompletedEventArgs 实例的Result 属性接收值；
            AreaClass2 AreaObject2 = (AreaClass2)e.Argument;
            // Return the value through the Result property.
            e.Result = AreaObject2.CalcArea();
        }

        private void BackgroundWorker1_RunWorkerCompleted(
            object sender,
            System.ComponentModel.RunWorkerCompletedEventArgs e)
        {
            // Access the result through the Result property. 
            double Area = (double)e.Result;
            MessageBox.Show("The area is: " + Area.ToString());
        }
    }
}

Code de démonstration de MSDN : Cliquez pour ouvrir le lien

Article de référence : Cliquez pour ouvrir le lien

4 . Si ce n'est pas aussi bon que la valeur de retour, comment devrions-nous l'écrire avec élégance ? Fonction anonyme

La classe FunctionClass est ajoutée, la fonction de test est la suivante :

   public static void TestFunction2(string name, int age)
        {
            //内部处理省略            
        }

L'appel est le suivant :

 private void Form1_Load(object sender, EventArgs e)
        {
            Thread t1 = new Thread(new ThreadStart(delegate
            {
                FunctionClass.TestFunction2("eee", 5);
            }));
            t1.Start();          
        }

Petite note :

Si elle est appelée via WCF, la fonction de démarrage du thread doit être placée sur le serveur. Si elle est placée sur le client, il est facile de provoquer un crash inexplicable du programme principal en raison de la limite de temps. Client WCF.

La principale raison du crash est que le temps de réponse du client WCF est limité.

Ce qui précède est le contenu du passage des paramètres multithread C#. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !