AsyncOperationManager Classe

Définition

Espace de noms:

System.ComponentModel

Assembly:

System.ComponentModel.EventBasedAsync.dll

Source:

AsyncOperationManager.cs

Fournit la gestion de l'accès concurrentiel pour les classes qui prennent en charge des appels de méthode asynchrone. Cette classe ne peut pas être héritée.

public ref class AsyncOperationManager abstract sealed

public static class AsyncOperationManager

type AsyncOperationManager = class

Public Class AsyncOperationManager

Héritage

Object

AsyncOperationManager

Exemples

L’exemple de code suivant illustre l’utilisation de la AsyncOperationManager classe pour créer une classe qui prend en charge les opérations asynchrones pour n’importe quel modèle d’application. Il montre comment implémenter une classe qui teste un nombre pour déterminer s’il est premier. Ce calcul peut prendre du temps. Il est donc effectué sur un thread distinct. Les rapports d’avancement, les résultats incrémentiels et les notifications d’achèvement sont gérés par la AsyncOperation classe, ce qui garantit que les gestionnaires d’événements du client sont appelés sur le thread ou le contexte approprié.

Pour obtenir la liste complète de code, consultez Comment : implémenter un composant qui prend en charge le modèle asynchrone basé sur événement. Pour obtenir la liste complète du code d’un formulaire client, consultez Guide pratique pour implémenter un client du modèle asynchrone basé sur les événements.

// This method starts an asynchronous calculation. 
// First, it checks the supplied task ID for uniqueness.
// If taskId is unique, it creates a new WorkerEventHandler 
// and calls its BeginInvoke method to start the calculation.
public virtual void CalculatePrimeAsync(
    int numberToTest,
    object taskId)
{
    // Create an AsyncOperation for taskId.
    AsyncOperation asyncOp =
        AsyncOperationManager.CreateOperation(taskId);

    // Multiple threads will access the task dictionary,
    // so it must be locked to serialize access.
    lock (userStateToLifetime.SyncRoot)
    {
        if (userStateToLifetime.Contains(taskId))
        {
            throw new ArgumentException(
                "Task ID parameter must be unique", 
                "taskId");
        }

        userStateToLifetime[taskId] = asyncOp;
    }

    // Start the asynchronous operation.
    WorkerEventHandler workerDelegate = new WorkerEventHandler(CalculateWorker);
    workerDelegate.BeginInvoke(
        numberToTest,
        asyncOp,
        null,
        null);
}

' This method starts an asynchronous calculation. 
' First, it checks the supplied task ID for uniqueness.
' If taskId is unique, it creates a new WorkerEventHandler 
' and calls its BeginInvoke method to start the calculation.
Public Overridable Sub CalculatePrimeAsync( _
    ByVal numberToTest As Integer, _
    ByVal taskId As Object)

    ' Create an AsyncOperation for taskId.
    Dim asyncOp As AsyncOperation = _
        AsyncOperationManager.CreateOperation(taskId)

    ' Multiple threads will access the task dictionary,
    ' so it must be locked to serialize access.
    SyncLock userStateToLifetime.SyncRoot
        If userStateToLifetime.Contains(taskId) Then
            Throw New ArgumentException( _
                "Task ID parameter must be unique", _
                "taskId")
        End If

        userStateToLifetime(taskId) = asyncOp
    End SyncLock

    ' Start the asynchronous operation.
    Dim workerDelegate As New WorkerEventHandler( _
        AddressOf CalculateWorker)

    workerDelegate.BeginInvoke( _
        numberToTest, _
        asyncOp, _
        Nothing, _
        Nothing)

End Sub

Remarques

Si votre classe doit fournir un comportement asynchrone en fonction de la vue d’ensemble du modèle asynchrone basé sur les événements, vous rencontrerez un certain nombre de problèmes de gestion de la concurrence. Parmi ceux-ci figure la nécessité de s’assurer que les gestionnaires d’événements sont appelés sur un thread ou un contexte approprié pour le modèle d’application (par exemple, Windows Forms applications, ASP.NET applications, applications console, etc.). Fournit AsyncOperationManager un moyen pratique de créer une classe qui s’exécute correctement sous tous les modèles d’application pris en charge par .NET Framework.

La AsyncOperationManager classe a une méthode, CreateOperation, qui retourne un System.ComponentModel.AsyncOperation qui peut être utilisé pour suivre la durée d’une tâche asynchrone particulière. Le System.ComponentModel.AsyncOperation pour une tâche peut être utilisé pour alerter les clients lorsqu’une tâche se termine. Il peut également être utilisé pour publier des mises à jour de progression et des résultats incrémentiels sans mettre fin à l’opération.

Pour plus d’informations sur l’implémentation de classes asynchrones, consultez Implémentation du modèle asynchrone basé sur les événements.

Propriétés

SynchronizationContext

Obtient ou définit le contexte de synchronisation pour l'opération asynchrone.

Méthodes

CreateOperation(Object)

Retourne AsyncOperation permettant de suivre la durée d'une opération asynchrone particulière.

Voir aussi

• AsyncOperation
• Implémentation du modèle asynchrone basé sur des événements
• Meilleures pratiques pour le threading managé