WorkflowInvoker.Invoke Método

Referência

Definição

Namespace:: System.Activities

Assembly:: System.Activities.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Invoca um fluxo de trabalho de forma síncrona e retorna um dicionário de OutArgument da atividade raiz e valores de InOutArgument inseridos por nome de argumento que representam as saídas do fluxo de trabalho.

Sobrecargas

Invoke(Activity, IDictionary<String,Object>, TimeSpan)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada e o intervalo de tempo limite especificados.
Invoke(Activity, TimeSpan)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho e o intervalo de tempo limite especificados.
Invoke(Activity, IDictionary<String,Object>)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho especificada e IDictionary<TKey,TValue> de parâmetros de entrada.
Invoke(IDictionary<String,Object>, TimeSpan)	Invoca a atividade passada para o construtor de WorkflowInvoker(Activity) de forma síncrona com os parâmetros de entrada de IDictionary<TKey,TValue> especificados e o intervalo de tempo limite especificado.
Invoke(IDictionary<String,Object>)	Invoca a atividade passada para o construtor WorkflowInvoker(Activity) de forma síncrona com o IDictionary<TKey,TValue> especificado dos parâmetros de entrada.
Invoke(Activity)	Invoca um fluxo de trabalho usando a definição de fluxo de trabalho especificada.
Invoke()	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho passada para o construtor de WorkflowInvoker(Activity).
Invoke(TimeSpan)	Invoca um fluxo de trabalho de forma síncrona com o intervalo de tempo limite especificado.
Invoke<TResult>(Activity<TResult>)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho passada para o construtor de WorkflowInvoker(Activity).
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho especificada e IDictionary<TKey,TValue> de parâmetros de entrada.
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, TimeSpan)	Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada e o intervalo de tempo limite especificados.
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, IDictionary<String,Object>, TimeSpan)	Invoca um fluxo de trabalho usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada, o IDictionary<TKey,TValue> de parâmetros de saída adicionais e o intervalo de tempo limite especificados.

Comentários

Esse método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread invocação. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que levam um TimeSpan.

Invoke(Activity, IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada e o intervalo de tempo limite especificados.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity * System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, inputs As IDictionary(Of String, Object), timeout As TimeSpan) As IDictionary(Of String, Object)

Parâmetros

workflow: Activity

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

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.

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 contém duas WriteLine atividades e uma Delay atividade configurada com um Duration de um minuto. Esse fluxo de trabalho é invocado duas vezes; a primeira vez com um intervalo de tempo limite de dois minutos e a segunda vez com um intervalo de tempo limite de 30 segundos. O primeiro fluxo de trabalho é concluído com êxito, mas o segundo não e um TimeoutException é lançado.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

// This workflow completes successfully.
WorkflowInvoker.Invoke(wf, TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    WorkflowInvoker.Invoke(wf, TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Para obter um exemplo de como usar Invoke com argumentos de entrada e saída, consulte a sobrecarga de Invoke com os mesmos parâmetros que essa sobrecarga sem o intervalo de tempo limite.

Comentários

Esse método é bloqueado até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread de invocação. 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.

Aplica-se a

Invoke(Activity, TimeSpan)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho e o intervalo de tempo limite especificados.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, TimeSpan timeout);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, TimeSpan timeout);

static member Invoke : System.Activities.Activity * TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, timeout As TimeSpan) As IDictionary(Of String, Object)

Parâmetros

workflow: Activity

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

timeout: TimeSpan

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

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

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

// This workflow completes successfully.
WorkflowInvoker.Invoke(wf, TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    WorkflowInvoker.Invoke(wf, TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Para obter um exemplo de uso Invoke com argumentos de saída, consulte a sobrecarga de Invoke com os mesmos parâmetros que essa sobrecarga sem o intervalo de tempo limite.

Comentários

Observação

Aplica-se a

Invoke(Activity, IDictionary<String,Object>)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho especificada e IDictionary<TKey,TValue> de parâmetros de entrada.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, System.Collections.Generic.IDictionary<string,object> inputs);

static member Invoke : System.Activities.Activity * System.Collections.Generic.IDictionary<string, obj> -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, inputs As IDictionary(Of String, Object)) As IDictionary(Of String, Object)

Parâmetros

workflow: Activity

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

inputs: IDictionary<String,Object>

O dicionário de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

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 chama um fluxo de trabalho que consiste em uma única atividade de Divide que tem dois argumentos conectados e dois argumentos de saída. Quando o fluxo de trabalho é chamado, o dicionário de arguments é passado que contém os valores para cada argumento de entrada, fechado pelo nome do argumento. Quando o Invoke a chamada retorna, cada argumento de saída é retornado no dicionário de outputs , também fechado pelo nome do argumento.

public sealed class Divide : CodeActivity
{
    [RequiredArgument]
    public InArgument<int> Dividend { get; set; }

    [RequiredArgument]
    public InArgument<int> Divisor { get; set; }

    public OutArgument<int> Remainder { get; set; }
    public OutArgument<int> Result { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Result.Set(context, quotient);
        Remainder.Set(context, remainder);
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(new Divide(), arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Se o fluxo de trabalho derivar de ActivityWithResult, como CodeActivity<TResult> ou Activity<TResult>, e houver argumentos de saída além do argumento de saída bem definido Result , uma sobrecarga não genérica de Invoke, como esta, deverá ser usada para recuperar os argumentos adicionais. Para fazer isso, a definição de fluxo de trabalho passada em Invoke deve ser do tipo Activity. Neste exemplo, a Divide atividade deriva de CodeActivity<int>, mas é declarada como Activity para que essa sobrecarga de Invoke, que retorna um dicionário de argumentos em vez de um único valor retornado, seja usada.

public sealed class Divide : CodeActivity<int>
{
    public InArgument<int> Dividend { get; set; }
    public InArgument<int> Divisor { get; set; }
    public OutArgument<int> Remainder { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Remainder.Set(context, remainder);

        return quotient;
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

Activity wf = new Divide();

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(wf, arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Comentários

Esse método é bloqueado até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread de invocação. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que usam um TimeSpan.

Aplica-se a

Invoke(IDictionary<String,Object>, TimeSpan)

Invoca a atividade passada para o construtor de WorkflowInvoker(Activity) de forma síncrona com os parâmetros de entrada de IDictionary<TKey,TValue> especificados e o intervalo de tempo limite especificado.

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

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

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

Public Function Invoke (inputs As IDictionary(Of String, Object), timeout As TimeSpan) 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.

timeout: TimeSpan

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

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

The operation did not complete within the allotted timeout of 00:00:30.   
The time allotted to this operation may have been a portion of a longer timeout.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

// This workflow completes successfully.
invoker.Invoke(TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    invoker.Invoke(TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Para obter um exemplo de como usar Invoke com argumentos de entrada e saída, consulte a sobrecarga de Invoke com os mesmos parâmetros que essa sobrecarga sem o intervalo de tempo limite.

Comentários

Observação

Aplica-se a

Invoke(IDictionary<String,Object>)

Invoca a atividade passada para o construtor WorkflowInvoker(Activity) de forma síncrona com o IDictionary<TKey,TValue> especificado dos parâmetros de entrada.

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

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

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

Public Function Invoke (inputs As IDictionary(Of String, Object)) 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.

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

public sealed class Divide : CodeActivity
{
    [RequiredArgument]
    public InArgument<int> Dividend { get; set; }

    [RequiredArgument]
    public InArgument<int> Divisor { get; set; }

    public OutArgument<int> Remainder { get; set; }
    public OutArgument<int> Result { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Result.Set(context, quotient);
        Remainder.Set(context, remainder);
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

WorkflowInvoker invoker = new WorkflowInvoker(new Divide());

IDictionary<string, object> outputs = invoker.Invoke(arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Se o fluxo de trabalho derivar de ActivityWithResult, como CodeActivity<TResult> ou Activity<TResult>, e houver argumentos de saída além do argumento de saída bem definido Result , uma sobrecarga não genérica de Invoke, como esta, deverá ser usada para recuperar os argumentos adicionais. Para fazer isso, a definição de fluxo de trabalho passada para o WorkflowInvoker construtor deve ser do tipo Activity. Neste exemplo, a Divide atividade deriva de CodeActivity<int>, mas é declarada como Activity para que essa sobrecarga de Invoke, que retorna um dicionário de argumentos em vez de um único valor retornado, seja usada.

public sealed class Divide : CodeActivity<int>
{
    public InArgument<int> Dividend { get; set; }
    public InArgument<int> Divisor { get; set; }
    public OutArgument<int> Remainder { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Remainder.Set(context, remainder);

        return quotient;
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

Activity wf = new Divide();

WorkflowInvoker invoker = new WorkflowInvoker(wf);

IDictionary<string, object> outputs = invoker.Invoke(arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Comentários

Esse método é bloqueado até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread de invocação. Para configurar um intervalo de tempo limite no qual o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que usam um TimeSpan.

Aplica-se a

Invoke(Activity)

Invoca um fluxo de trabalho usando a definição de fluxo de trabalho especificada.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow);

static member Invoke : System.Activities.Activity -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity) As IDictionary(Of String, Object)

Parâmetros

workflow: Activity

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

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 única DiceRoll atividade. A atividade de DiceRoll tem dois argumentos de saída que representam os resultados da operação de rolagem de dados. Quando a chamada para Invoke retorna, cada argumento de saída é retornado no dicionário de saídas, com chave pelo nome do argumento.

public sealed class DiceRoll : CodeActivity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    static Random r = new Random();

    protected override void Execute(CodeActivityContext context)
    {
        D1.Set(context, r.Next(1, 7));
        D2.Set(context, r.Next(1, 7));
    }
}

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(new DiceRoll());

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

Se a atividade raiz do fluxo de trabalho não tiver argumentos de saída ou eles não forem necessários para o host, eles poderão ser desconsiderados. O exemplo a seguir invoca um fluxo de trabalho que consiste em uma única WriteLine atividade que não tem argumentos de saída.

Activity wf = new WriteLine
{
    Text = "Hello World."
};

WorkflowInvoker.Invoke(wf);

Comentários

Aplica-se a

Invoke()

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho passada para o construtor de WorkflowInvoker(Activity).

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke();

public System.Collections.Generic.IDictionary<string,object> Invoke ();

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

Public Function Invoke () As IDictionary(Of String, Object)

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

public sealed class DiceRoll : CodeActivity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    static Random r = new Random();

    protected override void Execute(CodeActivityContext context)
    {
        D1.Set(context, r.Next(1, 7));
        D2.Set(context, r.Next(1, 7));
    }
}

WorkflowInvoker invoker = new WorkflowInvoker(new DiceRoll());

IDictionary<string, object> outputs =
    invoker.Invoke();

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

outputs = invoker.Invoke();

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

Se a atividade raiz do fluxo de trabalho não tiver argumentos de saída ou eles não forem necessários pelo host, eles poderão ser desconsiderados. O exemplo a seguir invoca um fluxo de trabalho que consiste em uma única WriteLine atividade que não tem argumentos de saída.

Activity wf = new WriteLine
{
    Text = "Hello World."
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Comentários

Aplica-se a

Invoke(TimeSpan)

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

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

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

member this.Invoke : TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Function Invoke (timeout As TimeSpan) As IDictionary(Of String, 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.

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

The operation did not complete within the allotted timeout of 00:00:30.   
The time allotted to this operation may have been a portion of a longer timeout.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

// This workflow completes successfully.
invoker.Invoke(TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    invoker.Invoke(TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Para obter um exemplo de uso Invoke com argumentos de saída, consulte a sobrecarga de Invoke com os mesmos parâmetros que essa sobrecarga sem o intervalo de tempo limite.

Comentários

Esse método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread invocação. 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

Aplica-se a

Invoke<TResult>(Activity<TResult>)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho passada para o construtor de WorkflowInvoker(Activity).

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow);

static member Invoke : System.Activities.Activity<'Result> -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult)) As TResult

Parâmetros de tipo

TResult

O tipo do fluxo de trabalho.

Parâmetros

workflow: Activity<TResult>

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado. A definição de fluxo de trabalho precisa ser derivada de ActivityWithResult.

Retornos

TResult

Um valor do tipo TResult com o resultado da execução da atividade.

Exemplos

O exemplo a seguir invoca um fluxo de trabalho que consiste em uma única Add atividade que tem dois argumentos de entrada e, como ele deriva dele CodeActivity<int> , tem um argumento de saída bem definido Result . Quando o fluxo de trabalho é chamado, o dicionário de arguments é passado que contém os valores para cada argumento de entrada, fechado pelo nome do argumento. Quando a chamada para Invoke retorna, o valor do Result argumento de saída é retornado.

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Comentários

Aplica-se a

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho especificada e IDictionary<TKey,TValue> de parâmetros de entrada.

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object)) As TResult

Parâmetros de tipo

TResult

O tipo do fluxo de trabalho.

Parâmetros

workflow: Activity<TResult>

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

inputs: IDictionary<String,Object>

O dicionário de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

Retornos

TResult

Um valor do tipo TResult com o resultado da execução da atividade.

Exemplos

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Comentários

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 leva mais tempo do que o intervalo de tempo limite especificado para ser concluído, é concluído com êxito se o fluxo de trabalho não ficar ocioso.

Aplica-se a

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho de forma síncrona usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada e o intervalo de tempo limite especificados.

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object), timeout As TimeSpan) As TResult

Parâmetros de tipo

TResult

O tipo do fluxo de trabalho.

Parâmetros

workflow: Activity<TResult>

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

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.

Retornos

TResult

Um valor do tipo TResult com o resultado da execução da atividade.

Exemplos

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Comentários

Esse método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread invocação. 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

Aplica-se a

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, IDictionary<String,Object>, TimeSpan)

Invoca um fluxo de trabalho usando a definição de fluxo de trabalho, o IDictionary<TKey,TValue> de parâmetros de entrada, o IDictionary<TKey,TValue> de parâmetros de saída adicionais e o intervalo de tempo limite especificados.

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, [Runtime::InteropServices::Out] System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ % additionalOutputs, TimeSpan timeout);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs, out System.Collections.Generic.IDictionary<string,object> additionalOutputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> * IDictionary * TimeSpan -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object), ByRef additionalOutputs As IDictionary(Of String, Object), timeout As TimeSpan) As TResult

Parâmetros de tipo

TResult

O tipo do fluxo de trabalho.

Parâmetros

workflow: Activity<TResult>

A definição de fluxo de trabalho do fluxo de trabalho a ser invocado.

inputs: IDictionary<String,Object>

O dicionário de parâmetros de entrada para o fluxo de trabalho, inseridos por nome de argumento.

additionalOutputs: IDictionary<String,Object>

O dicionário de parâmetros de saída adicionais do 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.

Retornos

TResult

Um valor do tipo TResult com o resultado da execução da atividade.

Exemplos

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Comentários

Esse método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo ocioso. Toda a execução do fluxo de trabalho tem a garantia de ser executada no thread invocação. 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

Aplica-se a