AsyncOperationManager.CreateOperation(Object) Méthode

Définition

Espace de noms:

System.ComponentModel

Assembly:

System.dll

Retourne un AsyncOperation pour le suivi de la durée d’une opération asynchrone particulière.

public:
 static System::ComponentModel::AsyncOperation ^ CreateOperation(System::Object ^ userSuppliedState);

public static System.ComponentModel.AsyncOperation CreateOperation(object userSuppliedState);

static member CreateOperation : obj -> System.ComponentModel.AsyncOperation

Public Shared Function CreateOperation (userSuppliedState As Object) As AsyncOperation

Paramètres

userSuppliedState

Object

Objet utilisé pour associer un élément d’état client, tel qu’un ID de tâche, à une opération asynchrone particulière.

Retours

AsyncOperation

Que AsyncOperation vous pouvez utiliser pour suivre la durée d’un appel de méthode asynchrone.

Exemples

L’exemple de code suivant illustre l’utilisation de la CreateOperation méthode pour créer un System.ComponentModel.AsyncOperation suivi de la durée des opérations asynchrones. Cet exemple de code fait partie d’un exemple plus grand fourni pour la AsyncOperationManager classe.

// 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",
                nameof(taskId));
        }

        userStateToLifetime[taskId] = asyncOp;
    }

    // Start the asynchronous operation.
    WorkerEventHandler workerDelegate = new(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

La CreateOperation méthode retourne un System.ComponentModel.AsyncOperation élément que vous pouvez utiliser pour suivre la durée d’une opération asynchrone particulière et pour alerter le modèle d’application une fois l’opération terminée. Vous pouvez également l’utiliser pour publier les mises à jour de progression et les résultats incrémentiels sans terminer l’opération. Le System.ComponentModel.AsyncOperation marshale correctement ces appels vers le thread ou le contexte appropriés pour le modèle d’application.

Si vous implémentez une classe qui prend en charge le modèle asynchrone basé sur les événements, votre classe doit appeler CreateOperation chaque fois que votre méthode MethodNameAsync est appelée. L’application cliente qui effectue des appels à la méthode peut utiliser le userSuppliedState paramètre pour identifier de manière unique chaque appel, afin de distinguer les événements déclenchés pendant l’exécution de l’opération asynchrone.

Avertissement

Le code client doit fournir une valeur unique pour le userSuppliedState paramètre. Les ID de tâche non uniques peuvent entraîner l’état de progression de votre implémentation et d’autres événements de manière incorrecte. Votre code doit rechercher un ID de tâche non unique et lever un System.ArgumentException si un ID de tâche est détecté.

Votre code doit suivre chaque System.ComponentModel.AsyncOperation retour et CreateOperation utiliser l’objet dans l’opération asynchrone sous-jacente correspondante pour publier les mises à jour et arrêter l’opération. Ce suivi peut être aussi simple que de transmettre le System.ComponentModel.AsyncOperation paramètre comme paramètre parmi les délégués. Dans des conceptions plus sophistiquées, votre classe peut gérer une collection d’objets System.ComponentModel.AsyncOperation , en ajoutant des objets au démarrage et en les supprimant lorsque les tâches sont terminées ou annulées. Cette approche vous permet de rechercher des valeurs de paramètre uniques userSuppliedState et est la méthode que vous devez utiliser lors de l’utilisation de classes qui prennent en charge plusieurs appels simultanés.

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

Voir aussi

• AsyncOperation
• Implémentation du modèle asynchrone basé sur les événements
• Bonnes pratiques de threading managé