Comment utiliser async awati asynchrone Task Handling au lieu de backgroundworker?

InWinFormParfois, nous développons pour ne pas influencer le SeigneurUITraitement des fils,Avant, on utilisait des fils de fondBackgroundWorkerPour gérer certaines opérations de la Mission,Mais avec la commodité du traitement asynchrone,On peut utiliserAsync-AwatiLe traitement asynchrone des tâches remplace le fil de fond originalBackgroundWorkerMode de traitement,Plus simple et plus clair.

Au cours d'une opération longue,Cela peut entraîner une interface utilisateur pendant de longues périodes (UI) Dans l'état de réponse d'arrêt,Par conséquent, utilisezAsync-AwatiTraitement asynchrone des tâches ou filetage de fondBackgroundWorkerIl est nécessaire de gérer certaines opérations de la Mission.

En serviceBackgroundWorkerEn cours,Nous pouvons définir nos propres paramètres d'état,Cela permet un suivi en temps réel de l'état du fil et des conseils de progression et d'information,Pour nous permettre d'informer rapidementUIMise à jour.

Utiliser maintenantAsync-AwatiTraitement asynchrone des tâches,Il en va de même pour la notification pendant le traitementUIMise à jour des progrès et des conseils.

Cliquez pourDevExpress Winformv21.2Version officielle

1. RétrospectiveBackgroundWorker Code de traitement du fil de fond

Voyons voir.BackgroundWorker Code d'opération du fil de fond , L'utilisation est décrite ci - dessous. Async-Awati Traitement asynchrone des tâches et notification des opérations .

En général, le Code d'utilisation est nécessaire pour initialiser l'objet Thread de fond ,Le code ci - dessous.

public partial class MainFrame : BaseForm
{
/// <summary>
///  Ajouter une variable pour enregistrer l'état du fil 
/// </summary>
private bool IsThreadRunning = false;
private BackgroundWorker worker = new BackgroundWorker();

public MainFrame()
{
InitializeComponent();

Portal.gc.InitData();

worker.WorkerSupportsCancellation = true; //Soutien à l'annulation
worker.WorkerReportsProgress = true; // Rapports d'étape à l'appui 
worker.DoWork += worker_DoWork; //Processus de traitement
worker.RunWorkerCompleted += worker_RunWorkerCompleted; //Terminer l'opération
worker.ProgressChanged += worker_ProgressChanged; //Rapport d'étape
}

Par exemple, notification de la barre de progression , Il s'agit principalement de calculer le nombre total de tâches , Et utilisé pour afficher les informations actuelles sur l'avancement des tâches ,Les codes d'exemple sont les suivants:：

/// <summary>
///  Notification de la barre de progression 
/// </summary>
void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
this.barProgress.EditValue = e.ProgressPercentage;
CollectStateInfo stateInfo = e.UserState as CollectStateInfo;
if (stateInfo != null)
{
var message = string.Format("Collecte {0} De {1} , Le nom du projet est:{2}", stateInfo.TotalRecords, stateInfo.CompletedRecord + 1, stateInfo.CurrentItemName);
this.lblTips.Text = message;
this.barTips.Caption = message;

// Enregistrer la position de fonctionnement 
JobParameterHelper.SaveData(new CurrentJobParameter(stateInfo));
}
}

L'événement clé que le démon gère est l'implémentation de Code du processus de traitement , Quand il s'occupe des tâches , Informer l'état actuel par événement UIAfficher.

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
Random r = new Random();
int numCount = 0;
while (worker.CancellationPending == false)
{
int num = r.Next(0, 10000);
if (num % 5 == 0)
{
numCount++;
worker.ReportProgress(0, num);
Thread.Sleep(1000);
}
}
e.Result = numCount;
}

Au début de la tâche de déclenchement , Nous appelons le Code comme suit .

if (!worker.IsBusy)
{
worker.RunWorkerAsync(stateInfo);
}

Une fois la tâche terminée, Aviser l'interface de mise à jour .

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
// Restaurer l'état du bouton 
InitCollectState();
IsThreadRunning = false;

string message = " Opération d'acquisition terminée ";
MessageDxUtil.ShowTips(message);
}

2. UtiliserAsync-Awati Remplacement asynchrone du traitement des tâches BackgroundWorker

Pour les essais Asyn-AwaitTraitement asynchrone, Je crée un DemoProcédure, Pour tester ses effets .

Il y a un bouton dans le formulaire , Déclenchez le bouton pour effectuer l'opération de tâche , Et demander des informations sur la barre de progression étape par étape , Demander la fin de la tâche une fois terminée .

Pour demander des informations sur les progrès dans le traitement asynchrone ,Nous avons introduitProgress Objet de notification thread .

Définir une notification thread ProgressObjet,Comme suit.Ici.int Vous pouvez également passer à une classe d'objets personnalisée , Pour faciliter le transport de plus d'informations .

var reporter = new Progress<int>(progressChanged);

Parmi euxprogressChanged C'est une notification que nous définissons UI Gestionnaire pour afficher les progrès ,Comme suit.

/// <summary>
/// Rapport d'étape
/// </summary>
/// <param name="percentage">Progrès actuels</param>
void progressChanged(int percentage)
{
this.progressBar1.EditValue = percentage;

this.progressPanel.Caption = percentage == 100 ? "Tâche accomplie": " Tâche en cours ";
this.progressPanel.Description = String.Format("Terminé.【{0}%】", percentage);
}

Ensuite, nous définissons un WorkStartMéthodes,Recevoir unProgressObjet,Le code ci - dessous.

var reporter = new Progress<int>(progressChanged);
var result = await this.WorkStart(reporter);

Pour les appels asynchrones de style simple , On vient de retarder la tâche , Si elle est effectivement traitée , Appelez la méthode asynchrone. .

/// <summary>
/// Exécution des tâches
/// </summary>
private async Task<CommonResult> WorkStart(IProgress<int> progress)
{
var result = new CommonResult();
for(int i = 0; i < 100; i++)
{
await Task.Delay(100);
progress.Report(i + 1);
}
result.Success = true;

return result;
}

Nous pouvons voir, La tâche est exécutée à un noeud à la fois , La méthode objet est appelée Report Traitement des notifications .

Et une fois la tâche terminée, , Notre simple traitement de notification peut .L'ensemble du Code est le suivant:.

/// <summary>
/// Async Await Traitement asynchrone des fils 
/// </summary>
public partial class FrmAsyncAwaitDemo : DevExpress.XtraEditors.XtraForm
{
public FrmAsyncAwaitDemo()
{
InitializeComponent();

this.progressBar1.Visible = false;
this.progressPanel.Visible = false;
}

private async void btnStart_Click(object sender, EventArgs e)
{
this.btnStart.Enabled = false;
this.progressBar1.Visible = true;
this.progressPanel.Visible = true;

var reporter = new Progress<int>(progressChanged);
var result = await this.WorkStart(reporter);
this.WorkCompleted(result);
}

/// <summary>
/// Mission accomplie
/// </summary>
/// <param name="result">Retour aux résultatsCommonResult</param>
void WorkCompleted(CommonResult result)
{
if (result.Success)
{
// Traitement réussi de l'opération 
}

var alert = new AlertControl();
alert.FormLocation = AlertFormLocation.TopRight;
alert.AutoFormDelay = 2000;
alert.Show(this, " Conseils de mission ", result.Success ? "Traitement des tâches terminé,Opération réussie" : result.ErrorMessage);

this.progressBar1.Visible = false;
this.progressPanel.Visible = false;
this.btnStart.Enabled = true;
}

/// <summary>
/// Rapport d'étape
/// </summary>
/// <param name="percentage">Progrès actuels</param>
void progressChanged(int percentage)
{
this.progressBar1.EditValue = percentage;

this.progressPanel.Caption = percentage == 100 ? "Tâche accomplie": " Tâche en cours ";
this.progressPanel.Description = String.Format("Terminé.【{0}%】", percentage);
}

/// <summary>
/// Exécution des tâches
/// </summary>
private async Task<CommonResult> WorkStart(IProgress<int> progress)
{
var result = new CommonResult();
for(int i = 0; i < 100; i++)
{
await Task.Delay(100);
progress.Report(i + 1);
}
result.Success = true;

return result;
}
}

Dans notre cas réel , Le processus de téléchargement de fichiers utilise cette méthode pour aviser UIThread, .Les codes de traitement des tâches sont les suivants .

Par conséquent,Async-Awati Remplacement asynchrone du traitement des tâches BackgroundWorker, Code plus simple ,Et utiliser IProgress Classe d'interface pour traiter les notifications ,C'est très pratique..

DevExpress WinForm | Télécharger l'essai

DevExpress WinFormPropriété180+Composants etUIBibliothèque,Oui.Windows Forms La plateforme crée des solutions commerciales influentes .DevExpress WinForms Construit parfaitement et en douceur 、 Application esthétique et facile à utiliser ,Que ce soitOfficeInterface stylistique, Ou analyser et traiter de grandes quantités de données commerciales ,C'est facile à faire！

Cet article est reproduit à partir de：La blogosphère - Wu huacong

---

DevExpressGroupe d'échange technique6：600715373      Bienvenue au Groupe de discussion

PlusDevExpressCours ouverts en ligne、Veuillez consulter le site Web chinois pour obtenir des renseignements sur les tutoriels chinois.