AsyncOperationManager.CreateOperation(Object) Método

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

Parâmetros

Retornos

Um AsyncOperation que pode ser usado para acompanhar a duração de uma invocação de método assíncrono.

Exemplos

O exemplo de código a seguir demonstra como usar o CreateOperation método para criar um System.ComponentModel.AsyncOperation para acompanhar a duração das operações assíncronas. Este exemplo de código faz parte de um exemplo maior fornecido para a 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

Comentários

O CreateOperation método retorna um System.ComponentModel.AsyncOperation que você pode usar para acompanhar a duração de uma operação assíncrona específica e alertar o modelo de aplicativo quando a operação for concluída. Você também pode usá-lo para postar atualizações de progresso e resultados incrementais sem encerrar a operação. O System.ComponentModel.AsyncOperation realizará marshaling correto dessas chamadas para o thread ou contexto apropriado para o modelo de aplicativo.

Se você implementar uma classe que dê suporte ao Padrão Assíncrono baseado em Evento, sua classe deverá chamar CreateOperation cada vez que o método MethodNameAsync for chamado. O aplicativo cliente que faz chamadas para o método pode usar o userSuppliedState parâmetro para identificar exclusivamente cada invocação, de modo a distinguir eventos gerados durante a execução da operação assíncrona.

Seu código deve acompanhar cada System.ComponentModel.AsyncOperation retornado por CreateOperation e usar o objeto na operação assíncrona subjacente correspondente para postar atualizações e encerrar a operação. Esse acompanhamento pode ser tão simples quanto passar o System.ComponentModel.AsyncOperation como um parâmetro entre delegados. Em designs mais sofisticados, sua classe pode manter uma coleção de System.ComponentModel.AsyncOperation objetos, adicionando objetos quando as tarefas são iniciadas e removendo-os quando as tarefas são concluídas ou canceladas. Essa abordagem permite que você marcar para valores de parâmetro exclusivos userSuppliedState e é o método que você deve usar ao trabalhar com classes que dão suporte a várias invocações simultâneas.

Para obter mais informações sobre como implementar classes assíncronas, consulte Implementando o padrão assíncrono baseado em evento.

Aplica-se a

Confira também

• AsyncOperation
• Implementando o padrão assíncrono baseado em evento
• Práticas recomendadas de threading gerenciado