WorkflowInvoker.Invoke Método

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

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que contém duas WriteLine atividades e uma Delay atividade configurada com a Duration de um minuto. Este fluxo de trabalho é invocado duas vezes; a primeira vez com um intervalo de tempo morto de dois minutos, e a segunda com um intervalo de tempo morto de 30 segundos. O primeiro fluxo de trabalho é concluído com sucesso, mas o segundo não, e é lançado um a TimeoutException .

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 um exemplo de utilização Invoke com argumentos de entrada e saída, veja a sobrecarga de Invoke com os mesmos parâmetros desta sobrecarga sem o intervalo de time-out.

Observações

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

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

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que contém duas WriteLine atividades e uma Delay atividade configurada com a Duration de um minuto. Este fluxo de trabalho é invocado duas vezes; a primeira vez com um intervalo de tempo morto de dois minutos, e a segunda com um intervalo de tempo morto de 30 segundos. O primeiro fluxo de trabalho é concluído com sucesso, mas o segundo não, e é lançado um a TimeoutException .

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 um exemplo de utilização Invoke com argumentos de saída, veja a sobrecarga de Invoke com os mesmos parâmetros desta sobrecarga sem o intervalo de time-out.

Observações

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

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

Devoluções

Um dicionário das atividades OutArgument raiz e InOutArgument dos valores indexados 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 Divide atividade que tem dois argumentos de entrada e dois argumentos de saída. Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada para Invoke retorna, cada argumento de saída é retornado no dicionário outputs, também associado ao 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 existirem argumentos de saída além do argumento de saída bem definido Result , deve ser usada uma sobrecarga não genérica de Invoke, como esta, para recuperar os argumentos adicionais. Para fazer isso, a definição de fluxo de trabalho passada para Invoke deve ser do tipo Activity. Neste exemplo, a Divide atividade deriva de CodeActivity<int>, mas é declarada como Activity tal que esta sobrecarga de Invoke, que devolve um dicionário de argumentos em vez de um único valor de retorno, é 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"]);

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que contém duas WriteLine atividades e uma Delay atividade configurada com a Duration de um minuto. Este fluxo de trabalho é invocado duas vezes; a primeira vez com um intervalo de tempo morto de dois minutos, e a segunda com um intervalo de tempo morto de 30 segundos. O primeiro fluxo de trabalho é concluído com sucesso, mas o segundo não, e a TimeoutException é lançado e a mensagem seguinte é exibida.

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 um exemplo de utilização Invoke com argumentos de entrada e saída, veja a sobrecarga de Invoke com os mesmos parâmetros desta sobrecarga sem o intervalo de time-out.

Observações

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

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

Devoluções

Um dicionário das atividades OutArgument raiz e InOutArgument dos valores indexados 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 Divide atividade que tem dois argumentos de entrada e dois argumentos de saída. Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada para Invoke retorna, cada argumento de saída é retornado no dicionário outputs, também associado ao 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);

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 existirem argumentos de saída além do argumento de saída bem definido Result , deve ser usada uma sobrecarga não genérica de Invoke, como esta, para recuperar os argumentos adicionais. Para isso, a definição do fluxo de trabalho passada ao WorkflowInvoker construtor deve ser do tipo Activity. Neste exemplo, a Divide atividade deriva de CodeActivity<int>, mas é declarada como Activity tal que esta sobrecarga de Invoke, que devolve um dicionário de argumentos em vez de um único valor de retorno, é 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"]);

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho composto por uma única DiceRoll atividade. A atividade DiceRoll tem dois argumentos de saída que representam os resultados da operação de rolagem de dados. Quando a chamada retorna Invoke , cada argumento de saída é devolvido no dicionário de saídas, indexado 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 não forem necessários pelo anfitrião, podem ser ignorados. O exemplo seguinte invoca um fluxo de trabalho composto por uma única WriteLine atividade que não tem quaisquer argumentos de saída.

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

WorkflowInvoker.Invoke(wf);

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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)

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho composto por uma única DiceRoll atividade. A atividade DiceRoll tem dois argumentos de saída que representam os resultados da operação de rolagem de dados. Quando a chamada retorna Invoke , cada argumento de saída é devolvido no dicionário de saídas, indexado pelo nome do argumento. O fluxo de trabalho é invocado duas vezes, usando a definição do fluxo de trabalho passada ao WorkflowInvoker construtor.

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 não forem necessários pelo anfitrião, podem ser ignorados. O exemplo seguinte invoca um fluxo de trabalho composto por uma única WriteLine atividade que não tem quaisquer argumentos de saída.

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que contém duas WriteLine atividades e uma Delay atividade configurada com a Duration de um minuto. Este fluxo de trabalho é invocado duas vezes; a primeira vez com um intervalo de tempo morto de dois minutos, e a segunda com um intervalo de tempo morto de 30 segundos. O primeiro fluxo de trabalho é concluído com sucesso, mas o segundo não, e a TimeoutException é lançado e a mensagem seguinte é exibida.

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 um exemplo de utilização Invoke com argumentos de saída, veja a sobrecarga de Invoke com os mesmos parâmetros desta sobrecarga sem o intervalo de time-out.

Observações

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

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 Genérico

Parâmetros

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que consiste numa única Add atividade que tem dois argumentos de entrada e, como deriva dela CodeActivity<int> , tem um argumento de saída bem definido Result . Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada retorna Invoke , o valor do Result argumento de saída é devolvido.

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

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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 Genérico

Parâmetros

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que consiste numa única Add atividade que tem dois argumentos de entrada e, como deriva dela CodeActivity<int> , tem um argumento de saída bem definido Result . Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada retorna Invoke , o valor do Result argumento de saída é devolvido.

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

Observações

Este método bloqueia até que o fluxo de trabalho seja concluído, incluindo o tempo de inatividade. Toda a execução do fluxo de trabalho é garantida para ser executada no thread de invocação. Para configurar um intervalo de tempo limite em que o fluxo de trabalho deve ser concluído, use uma das Invoke sobrecargas que ocupam um TimeSpan.

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 Genérico

Parâmetros

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que consiste numa única Add atividade que tem dois argumentos de entrada e, como deriva dela CodeActivity<int> , tem um argumento de saída bem definido Result . Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada retorna Invoke , o valor do Result argumento de saída é devolvido.

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

Observações

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

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 Genérico

Parâmetros

Devoluções

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

Exemplos

O exemplo seguinte invoca um fluxo de trabalho que consiste numa única Add atividade que tem dois argumentos de entrada e, como deriva dela CodeActivity<int> , tem um argumento de saída bem definido Result . Quando o fluxo de trabalho é invocado, é passado o arguments dicionário que contém os valores de cada argumento de entrada, codificados pelo nome do argumento. Quando a chamada retorna Invoke , o valor do Result argumento de saída é devolvido.

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

Observações

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