WorkflowInvoker.EndInvoke(IAsyncResult) Método

Definição

Namespace:

System.Activities

Assembly:

System.Activities.dll

Retorna os resultados de um fluxo de trabalho que foi invocado usando uma das sobrecargas de BeginInvoke.

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ EndInvoke(IAsyncResult ^ result);

public System.Collections.Generic.IDictionary<string,object> EndInvoke (IAsyncResult result);

member this.EndInvoke : IAsyncResult -> System.Collections.Generic.IDictionary<string, obj>

Public Function EndInvoke (result As IAsyncResult) As IDictionary(Of String, Object)

Parâmetros

result

IAsyncResult

O IAsyncResult que referencia a operação BeginInvoke que iniciou o fluxo de trabalho.

Retornos

IDictionary<String,Object>

Um dicionário dos valores OutArgument e InOutArgument da atividade raiz inseridos pelo nome do argumento que representam as saídas do fluxo de trabalho.

Exemplos

O exemplo a seguir invoca um fluxo de trabalho que consiste em uma LongRunningDiceRoll atividade . A atividade de LongRunningDiceRoll tem dois argumentos de saída que representam os resultados da operação de rolagem de dados. Eles são recuperados chamando EndInvoke. Quando a chamada para EndInvoke retorna, cada argumento de saída é retornado no dicionário de saídas, com chave pelo nome do argumento.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

static void BeginInvokeExample()
{
    WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

    string userState = "BeginInvoke example";
    IAsyncResult result = invoker.BeginInvoke(new AsyncCallback(WorkflowCompletedCallback), userState);

    // You can inspect result from the host to determine if the workflow
    // is complete.
    Console.WriteLine("result.IsCompleted: {0}", result.IsCompleted);

    // The results of the workflow are retrieved by calling EndInvoke, which
    // can be called from the callback or from the host. If called from the
    // host, it blocks until the workflow completes. If a callback is not
    // required, pass null for the callback parameter.
    Console.WriteLine("Waiting for the workflow to complete.");
    IDictionary<string, object> outputs = invoker.EndInvoke(result);

    Console.WriteLine("The two dice are {0} and {1}.",
        outputs["D1"], outputs["D2"]);
}

static void WorkflowCompletedCallback(IAsyncResult result)
{
    Console.WriteLine("Workflow complete.");
}

Comentários

Para ser notificado quando o fluxo de trabalho for concluído e recuperar os parâmetros de saída do fluxo de trabalho, chame EndInvoke do callback método especificado por BeginInvoke. Se EndInvoke for chamado antes da conclusão do fluxo de trabalho, ele será bloqueado até que o fluxo de trabalho seja concluído.

Esse método retorna o resultado de um fluxo de trabalho invocado de forma assíncrona usando o padrão de design assíncrono IAsyncResult . Para obter mais informações, consulte Visão geral da programação assíncrona.