WorkflowInvoker.InvokeAsync Método

  • Referência

Definição

Namespace:
System.Activities
Assembly:
System.Activities.dll

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

Sobrecargas

InvokeAsync(TimeSpan, Object)

Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo limite especificado e um identificador exclusivo.
InvokeAsync(IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho de forma assíncrona com o IDictionary<TKey,TValue> de parâmetros de entrada especificado e o intervalo de tempo limite especificado.
InvokeAsync(IDictionary<String,Object>, Object)

Invoca um fluxo de trabalho de forma assíncrona usando o IDictionary<TKey,TValue> de parâmetros de entrada especificado e um identificador exclusivo.
InvokeAsync()

Invoca um fluxo de trabalho de forma assíncrona.
InvokeAsync(Object)

Invoca um fluxo de trabalho de forma assíncrona usando o identificador exclusivo especificado.
InvokeAsync(IDictionary<String,Object>)

Invoca um fluxo de trabalho de forma assíncrona usado o IDictionary<TKey,TValue> de parâmetros de entrada especificado.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)

Invoca um fluxo de trabalho de forma assíncrona com o IDictionary<TKey,TValue> de parâmetros de entrada especificado, o intervalo de tempo limite especificado e um identificador exclusivo.
InvokeAsync(TimeSpan)

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

Comentários

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que levam um TimeSpan.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

InvokeAsync(TimeSpan, Object)

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

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 no qual o fluxo de trabalho deve ser concluído antes de ele ser anulado e um TimeoutException ser gerado.

userState
Object

Um objeto fornecido pelo usuário usado para distinguir esta operação de invocação assíncrona específica das outras operações de invocação assíncrona atuais.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

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

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Se o fluxo de trabalho não for concluído dentro do intervalo de tempo limite especificado, o fluxo de trabalho será anulado e um TimeoutException será gerado.

Observação

TimeoutException é acionada somente se o intervalo de tempo limite decorre e fluxo de trabalho se torna ocioso durante a execução. Um fluxo de trabalho que recebe mais tempo do intervalo de tempo limite especificado para concluir concluída com êxito se o fluxo de trabalho não se torna ocioso.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Aplica-se a

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho de forma assíncrona com o IDictionary<TKey,TValue> de parâmetros de entrada especificado e o intervalo de tempo limite 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 de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

timeout
TimeSpan

O intervalo no qual o fluxo de trabalho deve ser concluído antes de ele ser anulado e um TimeoutException ser gerado.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Se o fluxo de trabalho não for concluído dentro do intervalo de tempo limite especificado, o fluxo de trabalho será anulado e um TimeoutException será gerado.

Observação

TimeoutException é acionada somente se o intervalo de tempo limite decorre e fluxo de trabalho se torna ocioso durante a execução. Um fluxo de trabalho que recebe mais tempo do intervalo de tempo limite especificado para concluir concluída com êxito se o fluxo de trabalho não se torna ocioso.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Esse método armazena na tarefa que retorna todas as exceções de não uso que a contraparte síncrona do método pode gerar. Se uma exceção for armazenada na tarefa retornada, essa exceção será gerada quando a tarefa for aguardada. Exceções de uso, como ArgumentException, ainda são geradas de forma síncrona. Para as exceções armazenadas, consulte as exceções geradas por Invoke(IDictionary<String,Object>, TimeSpan).

Aplica-se a

InvokeAsync(IDictionary<String,Object>, Object)

Invoca um fluxo de trabalho de forma assíncrona usando o IDictionary<TKey,TValue> de parâmetros de entrada especificado e um identificador exclusivo.

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 de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

userState
Object

Um objeto fornecido pelo usuário usado para distinguir esta operação de invocação assíncrona específica das outras operações de invocação assíncrona atuais.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

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

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que usam um TimeSpan.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

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

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que usam um TimeSpan.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Esse método armazena na tarefa que retorna todas as exceções de não uso que a contraparte síncrona do método pode gerar. Se uma exceção for armazenada na tarefa retornada, essa exceção será gerada quando a tarefa for aguardada. Exceções de uso, como ArgumentException, ainda são geradas de forma síncrona. Para as exceções armazenadas, consulte as exceções geradas por Invoke().

Aplica-se a

InvokeAsync(Object)

Invoca um fluxo de trabalho de forma assíncrona usando o identificador exclusivo 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 usuário usado para distinguir esta operação de invocação assíncrona específica das outras operações de invocação assíncrona atuais.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

O userState parâmetro deve ser exclusivo em todas as operações em execução InvokeAsync no momento para a atividade atual. Se o userState parâmetro não for exclusivo, um ArgumentException será gerado. userState é usado para identificar o fluxo de trabalho em InvokeCompletede para cancelar o fluxo de trabalho usando CancelAsync.

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que usam um TimeSpan.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Aplica-se a

InvokeAsync(IDictionary<String,Object>)

Invoca um fluxo de trabalho de forma assíncrona usado o IDictionary<TKey,TValue> de parâmetros de entrada especificado.

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 de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das InvokeAsync sobrecargas que usam um TimeSpan.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Esse método armazena na tarefa que retorna todas as exceções de não uso que a contraparte síncrona do método pode gerar. Se uma exceção for armazenada na tarefa retornada, essa exceção será gerada quando a tarefa for aguardada. Exceções de uso, como ArgumentException, ainda são geradas de forma síncrona. Para as exceções armazenadas, consulte as exceções geradas por Invoke(IDictionary<String,Object>).

Aplica-se a

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

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

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 de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

timeout
TimeSpan

O intervalo no qual o fluxo de trabalho deve ser concluído antes de ele ser anulado e um TimeoutException ser gerado.

userState
Object

Um objeto fornecido pelo usuário usado para distinguir esta operação de invocação assíncrona específica das outras operações de invocação assíncrona atuais.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

O userState parâmetro deve ser exclusivo em todas as operações em execução InvokeAsync no momento para a atividade atual. Se userState não for exclusivo, um ArgumentException será gerado. userState é usado para identificar o fluxo de trabalho no InvokeCompletede para cancelar o fluxo de trabalho usando CancelAsync.

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Se o fluxo de trabalho não for concluído dentro do intervalo de tempo limite especificado, o fluxo de trabalho será anulado e um TimeoutException será gerado.

Observação

TimeoutException é acionada somente se o intervalo de tempo limite decorre e fluxo de trabalho se torna ocioso durante a execução. Um fluxo de trabalho que recebe mais tempo do intervalo de tempo limite especificado para concluir concluída com êxito se o fluxo de trabalho não se torna ocioso.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Aplica-se a

InvokeAsync(TimeSpan)

Invoca um fluxo de trabalho de forma assíncrona com o intervalo de tempo limite 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 no qual o fluxo de trabalho deve ser concluído antes de ele ser anulado e um TimeoutException ser gerado.

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. Quando o fluxo de trabalho é concluído, eles são recuperados no InvokeCompleted manipulador.

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 == true)
    {
        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.");

Comentários

Para ser notificado quando o fluxo de trabalho for concluído, manipule InvokeCompleted. Se o fluxo de trabalho não for concluído dentro do intervalo de tempo limite especificado, o fluxo de trabalho será anulado e um TimeoutException será gerado.

Observação

TimeoutException é acionada somente se o intervalo de tempo limite decorre e fluxo de trabalho se torna ocioso durante a execução. Um fluxo de trabalho que recebe mais tempo do intervalo de tempo limite especificado para concluir concluída com êxito se o fluxo de trabalho não se torna ocioso.

Esse método invoca um fluxo de trabalho de forma assíncrona usando o padrão de design assíncrono baseado em evento. Para mais informações, consulte Visão geral sobre o padrão assíncrono baseado em evento.

Esse método armazena na tarefa que retorna todas as exceções de não uso que o equivalente síncrono do método pode gerar. Se uma exceção for armazenada na tarefa retornada, essa exceção será gerada quando a tarefa for aguardada. Exceções de uso, como ArgumentException, ainda são geradas de forma síncrona. Para as exceções armazenadas, consulte as exceções geradas por Invoke(TimeSpan).

Aplica-se a