AsyncOperationManager.CreateOperation(Object) Methode

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

public static System.ComponentModel.AsyncOperation CreateOperation (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

Parameter

Gibt zurück

Eine AsyncOperation, die Sie verwenden können, um die Dauer eines asynchronen Methodenaufrufs zu verfolgen.

Beispiele

Das folgende Codebeispiel veranschaulicht die Verwendung der CreateOperation -Methode zum Erstellen eines System.ComponentModel.AsyncOperation zum Nachverfolgen der Dauer asynchroner Vorgänge. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die AsyncOperationManager-Klasse bereitgestellt wird.

// 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

Hinweise

Die CreateOperation -Methode gibt einen System.ComponentModel.AsyncOperation zurück, mit dem Sie die Dauer eines bestimmten asynchronen Vorgangs nachverfolgen und das Anwendungsmodell nach Abschluss des Vorgangs benachrichtigen können. Sie können es auch verwenden, um Statusaktualisierungen und inkrementelle Ergebnisse zu veröffentlichen, ohne den Vorgang zu beenden. Die System.ComponentModel.AsyncOperation marshallt diese Aufrufe ordnungsgemäß an den entsprechenden Thread oder Kontext für das Anwendungsmodell.

Wenn Sie eine Klasse implementieren, die das ereignisbasierte asynchrone Muster unterstützt, sollte Ihre Klasse jedes Mal aufrufen CreateOperation , wenn Ihre MethodName-MethodeAsync aufgerufen wird. Die Clientanwendung, die Aufrufe der -Methode durchführt, kann den userSuppliedState Parameter verwenden, um jeden Aufruf eindeutig zu identifizieren, um Ereignisse zu unterscheiden, die während der Ausführung des asynchronen Vorgangs ausgelöst werden.

Ihr Code sollte alle System.ComponentModel.AsyncOperation von CreateOperation zurückgegebenen Daten nachverfolgen und das -Objekt im entsprechenden zugrunde liegenden asynchronen Vorgang verwenden, um Updates zu veröffentlichen und den Vorgang zu beenden. Diese Nachverfolgung kann so einfach sein, wie die Übergabe von System.ComponentModel.AsyncOperation als Parameter zwischen Delegaten. In komplexeren Designs kann Ihre Klasse eine Auflistung von System.ComponentModel.AsyncOperation Objekten verwalten, Objekte hinzufügen, wenn Aufgaben gestartet werden, und sie entfernen, wenn Aufgaben abgeschlossen oder abgebrochen werden. Dieser Ansatz ermöglicht es Ihnen, nach eindeutigen userSuppliedState Parameterwerten zu suchen, und ist die Methode, die Sie verwenden sollten, wenn Sie mit Klassen arbeiten, die mehrere gleichzeitige Aufrufe unterstützen.

Weitere Informationen zum Implementieren asynchroner Klassen finden Sie unter Implementieren des ereignisbasierten asynchronen Musters.

Gilt für:

Weitere Informationen

• AsyncOperation
• Implementieren des ereignisbasierten asynchronen Entwurfsmusters
• Empfohlene Vorgehensweise für das verwaltete Threading