AsyncOperationManager.CreateOperation(Object) Méthode

Définition

Espace de noms:

System.ComponentModel

Assembly:

System.ComponentModel.EventBasedAsync.dll

Source:

AsyncOperationManager.cs

Retourne AsyncOperation permettant de suivre 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 une portion d'état client, telle qu'un identificateur de tâche, à une opération asynchrone particulière.

Retours

AsyncOperation

AsyncOperation que 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 pour le 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", 
                "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

La CreateOperation méthode retourne un System.ComponentModel.AsyncOperation que vous pouvez utiliser pour suivre la durée d’une opération asynchrone particulière et pour alerter le modèle d’application à la fin de l’opération. Vous pouvez également l’utiliser pour publier des mises à jour de progression et des résultats incrémentiels sans mettre fin à l’opération. le System.ComponentModel.AsyncOperation marshale correctement ces appels vers le thread ou le contexte approprié 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.

Attention

Le code client doit fournir une valeur unique pour le userSuppliedState paramètre. Les ID de tâche non uniques peuvent amener votre implémentation à signaler incorrectement la progression et d’autres événements. Votre code doit case activée pour un ID de tâche non unique et lever un System.ArgumentException si celui-ci est détecté.

Votre code doit suivre chaque System.ComponentModel.AsyncOperation retour par CreateOperation et utiliser l’objet dans l’opération asynchrone sous-jacente correspondante pour publier les mises à jour et mettre fin à l’opération. Ce suivi peut être aussi simple que de passer le System.ComponentModel.AsyncOperation en tant que paramètre entre les délégués. Dans des conceptions plus sophistiquées, votre classe peut conserver une collection d’objets, en ajoutant des System.ComponentModel.AsyncOperation objets lorsque les tâches sont démarrées et en les supprimant lorsque les tâches sont terminées ou annulées. Cette approche vous permet d’case activée pour les valeurs de paramètres uniques userSuppliedState et est la méthode que vous devez utiliser lorsque vous utilisez des 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 des événements
• Meilleures pratiques pour le threading managé