Uredi

Deli z drugimi prek


AsyncOperationManager.CreateOperation(Object) Method

Definition

Returns an AsyncOperation for tracking the duration of a particular asynchronous operation.

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

Parameters

userSuppliedState
Object

An object used to associate a piece of client state, such as a task ID, with a particular asynchronous operation.

Returns

An AsyncOperation that you can use to track the duration of an asynchronous method invocation.

Examples

The following code example demonstrates using the CreateOperation method to create an System.ComponentModel.AsyncOperation for tracking the duration of asynchronous operations. This code example is part of a larger example provided for the AsyncOperationManager class.

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

Remarks

The CreateOperation method returns an System.ComponentModel.AsyncOperation that you can use to track the duration of a particular asynchronous operation and to alert the application model when the operation completes. You can also use it to post progress updates and incremental results without terminating the operation. The System.ComponentModel.AsyncOperation will correctly marshal these calls to the appropriate thread or context for the application model.

If you implement a class that supports the Event-based Asynchronous Pattern, your class should call CreateOperation each time your MethodNameAsync method is called. The client application that makes calls to the method can use the userSuppliedState parameter to uniquely identify each invocation, so as to distinguish events raised during the execution of the asynchronous operation.

Caution

Client code must provide a unique value for the userSuppliedState parameter. Non-unique task IDs may cause your implementation to report progress and other events incorrectly. Your code should check for a non-unique task ID and throw an System.ArgumentException if one is detected.

Your code should track every System.ComponentModel.AsyncOperation returned by CreateOperation and use the object in the corresponding underlying asynchronous operation to post updates and terminate the operation. This tracking can be as simple as passing the System.ComponentModel.AsyncOperation as a parameter among delegates. In more sophisticated designs, your class can maintain a collection of System.ComponentModel.AsyncOperation objects, adding objects when tasks are started and removing them when tasks are completed or canceled. This approach allows you to check for unique userSuppliedState parameter values, and is the method you should use when working with classes that support multiple concurrent invocations.

For more information about implementing asynchronous classes, see Implementing the Event-based Asynchronous Pattern.

Applies to

See also