WorkflowInvoker.InvokeAsync Método

Definição

Espaço de Nomes:: System.Activities

Assemblagem:: System.Activities.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Invoca um fluxo de trabalho assíncrono usando o padrão de design assíncrono baseado em eventos.

Sobrecargas

Name	Description
InvokeAsync(TimeSpan, Object)	Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo especificado e um identificador único.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Invoca um fluxo de trabalho de forma assíncrona com os parâmetros de entrada especificados IDictionary<TKey,TValue> e o intervalo de time-out especificado.
InvokeAsync(IDictionary<String,Object>, Object)	Invoca um fluxo de trabalho assíncrono usando os parâmetros de entrada especificados IDictionary<TKey,TValue> e um identificador único.
InvokeAsync()	Invoca um fluxo de trabalho de forma assíncrona.
InvokeAsync(Object)	Invoca um fluxo de trabalho de forma assíncrona usando o identificador único especificado.
InvokeAsync(IDictionary<String,Object>)	Invoca um fluxo de trabalho assíncrono usando os parâmetros de entrada especificados IDictionary<TKey,TValue> .
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Invoca um fluxo de trabalho de forma assíncrona com os parâmetros de entrada especificados IDictionary<TKey,TValue> , o intervalo de tempo especificado e um identificador único.
InvokeAsync(TimeSpan)	Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo especificado.

Observações

Para ser notificado quando o fluxo de trabalho estiver concluído, trate InvokeCompletedde . Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que ocupam um TimeSpan.

Este método invoca um fluxo de trabalho assíncrono usando o padrão de design assíncrono baseado em eventos. Para obter mais informações, consulte Visão geral do padrão assíncrono baseado em eventos.

InvokeAsync(TimeSpan, Object)

Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo especificado e um identificador único.

public:
 void InvokeAsync(TimeSpan timeout, System::Object ^ userState);

public void InvokeAsync(TimeSpan timeout, object userState);

member this.InvokeAsync : TimeSpan * obj -> unit

Public Sub InvokeAsync (timeout As TimeSpan, userState As Object)

Parâmetros

timeout: TimeSpan

O intervalo em que o fluxo de trabalho deve ser concluído antes de ser abortado e a TimeoutException ser lançado.

userState: Object

Um objeto fornecido pelo utilizador usado para distinguir esta operação de invocação assíncrona em particular de outras operações de invocação assíncronas atuais.

Exemplos

O exemplo seguinte invoca um fluxo de trabalho composto por uma LongRunningDiceRoll atividade. A atividade LongRunningDiceRoll tem dois argumentos de saída que representam os resultados da operação de rolagem de dados. Quando o fluxo de trabalho termina, estes são recolhidos no InvokeCompleted handler.

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

O userState parâmetro deve ser único em todas as operações atualmente em execução InvokeAsync para a atividade atual. Se userState não for único, um ArgumentException é lançado. userState é usado para identificar o fluxo de trabalho em InvokeCompleted, e para cancelar o fluxo de trabalho usando CancelAsync.

Para ser notificado quando o fluxo de trabalho estiver concluído, trate InvokeCompletedde . Se o fluxo de trabalho não for concluído dentro do intervalo de tempo especificado, o fluxo de trabalho é abortado e a TimeoutException é lançado.

Note

O TimeoutException só é lançado se o intervalo de tempo de espera decorrer e o fluxo de trabalho ficar ocioso durante a execução. Um fluxo de trabalho que leva mais tempo do que o intervalo de tempo limite especificado para ser concluído com êxito se o fluxo de trabalho não ficar ocioso.

Aplica-se a

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho de forma assíncrona com os parâmetros de entrada especificados IDictionary<TKey,TValue> e o intervalo de time-out especificado.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan)

Parâmetros

inputs: IDictionary<String,Object>

O dicionário dos parâmetros de entrada do fluxo de trabalho, indexado pelo nome do argumento.

timeout: TimeSpan

O intervalo em que o fluxo de trabalho deve ser concluído antes de ser abortado e a TimeoutException ser lançado.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Note

Este método armazena na tarefa que devolve todas as exceções de não-utilização que o equivalente síncrono do método pode lançar. Se uma exceção for armazenada na tarefa devolvida, essa exceção será lançada quando a tarefa for aguardada. As exceções de uso, como ArgumentException, ainda são lançadas de forma síncrona. Para as exceções armazenadas, veja as exceções lançadas por Invoke(IDictionary<String,Object>, TimeSpan).

Aplica-se a

InvokeAsync(IDictionary<String,Object>, Object)

Invoca um fluxo de trabalho assíncrono usando os parâmetros de entrada especificados IDictionary<TKey,TValue> e um identificador único.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, System::Object ^ userState);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, object userState);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * obj -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), userState As Object)

Parâmetros

inputs: IDictionary<String,Object>

O dicionário dos parâmetros de entrada do fluxo de trabalho, indexado pelo nome do argumento.

userState: Object

Um objeto fornecido pelo utilizador usado para distinguir esta operação de invocação assíncrona em particular de outras operações de invocação assíncronas atuais.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Aplica-se a

InvokeAsync()

Invoca um fluxo de trabalho de forma assíncrona.

public:
 void InvokeAsync();

public void InvokeAsync();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Aplica-se a

InvokeAsync(Object)

Invoca um fluxo de trabalho de forma assíncrona usando o identificador único especificado.

public:
 void InvokeAsync(System::Object ^ userState);

public void InvokeAsync(object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parâmetros

userState: Object

Um objeto fornecido pelo utilizador usado para distinguir esta operação de invocação assíncrona em particular de outras operações de invocação assíncronas atuais.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

O userState parâmetro deve ser único em todas as operações atualmente em execução InvokeAsync para a atividade atual. Se o userState parâmetro não for único, um ArgumentException é lançado. userState é usado para identificar o fluxo de trabalho em InvokeCompleted, e para cancelar o fluxo de trabalho usando CancelAsync.

Aplica-se a

InvokeAsync(IDictionary<String,Object>)

Invoca um fluxo de trabalho assíncrono usando os parâmetros de entrada especificados IDictionary<TKey,TValue> .

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object))

Parâmetros

inputs: IDictionary<String,Object>

O dicionário dos parâmetros de entrada do fluxo de trabalho, indexado pelo nome do argumento.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Aplica-se a

InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)

Invoca um fluxo de trabalho de forma assíncrona com os parâmetros de entrada especificados IDictionary<TKey,TValue> , o intervalo de tempo especificado e um identificador único.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout, System::Object ^ userState);

public void InvokeAsync(System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout, object userState);

member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan * obj -> unit

Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan, userState As Object)

Parâmetros

inputs: IDictionary<String,Object>

O dicionário dos parâmetros de entrada do fluxo de trabalho, indexado pelo nome do argumento.

timeout: TimeSpan

O intervalo em que o fluxo de trabalho deve ser concluído antes de ser abortado e a TimeoutException ser lançado.

userState: Object

Um objeto fornecido pelo utilizador usado para distinguir esta operação de invocação assíncrona em particular de outras operações de invocação assíncronas atuais.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Note

Aplica-se a

InvokeAsync(TimeSpan)

Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo especificado.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync(TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parâmetros

timeout: TimeSpan

O intervalo em que o fluxo de trabalho deve ser concluído antes de ser abortado e a TimeoutException ser lançado.

Exemplos

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))
                }
            }
        };
    }
}

AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Observações

Note

Aplica-se a

Comentários

Esta página foi útil?