Introduction détaillée à l'exemple de code de Winform en c# pour implémenter la mise à jour asynchrone multithread de l'interface utilisateur

Cet article présente principalement l'interface utilisateur de mise à jour asynchrone multithread (informations de progression et d'état) de Winform en c#. L'éditeur pense qu'elle est plutôt bonne, je vais donc la partager avec vous maintenant et la donner comme référence. Suivons l'éditeur et jetons un coup d'œil.

Introduction

Lors du développement de programmes Winform qui nécessitent une grande quantité d'opérations de lecture et d'écriture de données, cela prend souvent un certain montant Cependant, pendant cette période, l'interface utilisateur ne peut pas être mise à jour, ce qui entraîne une animation suspendue de l'interface aux yeux de l'utilisateur, ce qui entraîne une mauvaise expérience utilisateur. Par conséquent, dans les applications qui exploitent une grande quantité de données, le multithreading doit être utilisé pour gérer cette situation. Il est très pratique d'utiliser le multi-threading en C#. Il vous suffit d'utiliser la méthode Start d'une instance de System.Threading.Thread, mais comment réaliser l'interaction entre multi-threads n'est pas si simple. Cet article implémente l'utilisation de sous-threads pour traiter les données et met à jour l'état de l'interface utilisateur du thread principal en temps réel. Commençons étape par étape pour implémenter le programme de démonstration de l'interface utilisateur de mise à jour de thread asynchrone.

Contexte de l'application

Écrivez une certaine quantité de données dans un fichier texte, et la progression en temps réel de l'écriture des données doit être reflétée dans l'interface principale. Condition requise : les données écrites doivent être encapsulées dans une classe.

Processus d'implémentation

1. Créez d'abord un projet Winform, faites glisser un bouton, une barre de progression et une étiquette sur le formulaire principal. Comme indiqué ci-dessous.

2. Écrivez une classe (WriteDate) pour traiter les données. Le code source est le suivant.

 public class DataWrite
 {
  public delegate void UpdateUI(int step);//声明一个更新主线程的委托
  public UpdateUI UpdateUIDelegate;

  public delegate void AccomplishTask();//声明一个在完成任务时通知主线程的委托
  public AccomplishTask TaskCallBack;
  
  public void Write(object lineCount)
  {
   StreamWriter writeIO = new StreamWriter("text.txt", false, Encoding.GetEncoding("gb2312"));
   string head = "编号,省,市";
   writeIO.Write(head);
   for (int i = 0; i < (int)lineCount; i++)
   {
    writeIO.WriteLine(i.ToString() + ",湖南,衡阳");
    //写入一条数据，调用更新主线程ui状态的委托
    UpdateUIDelegate(1);
   }
   //任务完成时通知主线程作出相应的处理
   TaskCallBack();
   writeIO.Close();
  }
 }

3. Le code dans l'interface principale est le suivant :

Tout d'abord, un délégué doit être établi pour implémenter le contrôle de mise à jour du thread du contrôle non créé.

delegate void AsynUpdateUI(int step);

Écrivez ensuite plusieurs threads pour démarrer la méthode d'écriture des données et la fonction de rappel.

  private void btnWrite_Click(object sender, EventArgs e)
  {
   int taskCount = 10000; //任务量为10000
   this.pgbWrite.Maximum = taskCount;
   this.pgbWrite.Value = 0;

   DataWrite dataWrite = new DataWrite();//实例化一个写入数据的类
   dataWrite.UpdateUIDelegate += UpdataUIStatus;//绑定更新任务状态的委托
   dataWrite.TaskCallBack += Accomplish;//绑定完成任务要调用的委托

   Thread thread = new Thread(new ParameterizedThreadStart(dataWrite.Write));
   thread.IsBackground = true;
   thread.Start(taskCount);
  }

  //更新UI
  private void UpdataUIStatus(int step)
  {
   if (InvokeRequired)
   {
    this.Invoke(new AsynUpdateUI(delegate(int s)
    {
     this.pgbWrite.Value += s;
     this.lblWriteStatus.Text = this.pgbWrite.Value.ToString() + "/" + this.pgbWrite.Maximum.ToString();
    }), step);
   }
   else
   {
    this.pgbWrite.Value += step;
    this.lblWriteStatus.Text = this.pgbWrite.Value.ToString() + "/" + this.pgbWrite.Maximum.ToString();
   }
  }

  //完成任务时需要调用
  private void Accomplish()
  {
   //还可以进行其他的一些完任务完成之后的逻辑处理
   MessageBox.Show("任务完成");
  }

L'effet est le suivant :

Résumé

Mettre en œuvre mise à jour asynchrone de l'interface utilisateur Il existe de nombreuses méthodes, mais je pense que cette méthode est plus flexible et peut obtenir l'état de la tâche en temps réel et la traiter en conséquence. Ce mode convient également à l'utilisation de plusieurs threads pour écrire différentes données dans différents fichiers en même temps.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!