WorkflowInvoker.Invoke 方法

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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，其中包含两 WriteLine 个活动和一个 Delay 配置了一 Duration 分钟的活动。 此工作流调用两次;第一次超时间隔为两分钟，第二次超时间隔为 30 秒。 第一个工作流成功完成，但第二个工作流未完成，并且会引发 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);
}

有关使用 Invoke 输入和输出参数的示例，请参阅与此重载相同的参数的重载 Invoke ，而不使用超时间隔。

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。

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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，其中包含两 WriteLine 个活动和一个 Delay 配置了一 Duration 分钟的活动。 此工作流调用两次;第一次超时间隔为两分钟，第二次超时间隔为 30 秒。 第一个工作流成功完成，但第二个工作流未完成，并且会引发 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);
}

有关与 Invoke 输出参数一起使用的示例，请参阅与此重载相同的参数的重载 Invoke ，而不使用超时间隔。

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。

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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，该工作流包含一个具有两个输入参数和两个 Divide 输出参数的活动。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 当对 Invoke 的调用返回时，将在 outputs 字典中返回每个输出参数（也由参数名键控）。

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

如果工作流派生自 ActivityWithResult（如 CodeActivity<TResult> 或 Activity<TResult>），并且除了定义 Result 完善的输出参数外，还有输出参数，则必须使用非泛型重载 Invoke（例如此参数）来检索其他参数。 为此，传入的 Invoke 工作流定义的类型必须为类型 Activity。 在此示例中， Divide 活动派生自 CodeActivity<int>该活动，但声明为 Activity 此重载，该重载 Invoke返回参数字典而不是单个返回值。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，其中包含两 WriteLine 个活动和一个 Delay 配置了一 Duration 分钟的活动。 此工作流调用两次;第一次超时间隔为两分钟，第二次超时间隔为 30 秒。 第一个工作流成功完成，但第二个工作流未完成，并且将引发 a TimeoutException 并显示以下消息。

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

有关使用 Invoke 输入和输出参数的示例，请参阅与此重载相同的参数的重载 Invoke ，而不使用超时间隔。

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。

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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，该工作流包含一个具有两个输入参数和两个 Divide 输出参数的活动。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 当对 Invoke 的调用返回时，将在 outputs 字典中返回每个输出参数（也由参数名键控）。

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

如果工作流派生自 ActivityWithResult（如 CodeActivity<TResult> 或 Activity<TResult>），并且除了定义 Result 完善的输出参数外，还有输出参数，则必须使用非泛型重载 Invoke（例如此参数）来检索其他参数。 为此，传入构造函数的 WorkflowInvoker 工作流定义必须是类型 Activity。 在此示例中， Divide 活动派生自 CodeActivity<int>该活动，但声明为 Activity 此重载，该重载 Invoke返回参数字典而不是单个返回值。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用由单个 DiceRoll 活动组成的工作流。 活动 DiceRoll 具有两个输出参数，这些参数表示掷骰子操作的结果。 调用 Invoke 返回时，输出字典中会返回每个输出参数，按参数名称进行键键。

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

如果工作流的根活动没有输出参数，或者主机不需要它们，则可以忽略它们。 以下示例调用一个工作流，该工作流由不包含任何输出参数的单个 WriteLine 活动组成。

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

WorkflowInvoker.Invoke(wf);

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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)

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用由单个 DiceRoll 活动组成的工作流。 活动 DiceRoll 具有两个输出参数，这些参数表示掷骰子操作的结果。 调用 Invoke 返回时，输出字典中会返回每个输出参数，按参数名称进行键键。 使用传递到构造函数的 WorkflowInvoker 工作流定义调用工作流两次。

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

如果工作流的根活动没有输出参数，或者主机不需要它们，则可以忽略它们。 以下示例调用一个工作流，该工作流由不包含任何输出参数的单个 WriteLine 活动组成。

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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)

参数

返回

根活动的 OutArgument 字典和 InOutArgument 由参数名称键控的值，这些参数名称表示工作流的输出。

示例

以下示例调用一个工作流，其中包含两 WriteLine 个活动和一个 Delay 配置了一 Duration 分钟的活动。 此工作流调用两次;第一次超时间隔为两分钟，第二次超时间隔为 30 秒。 第一个工作流成功完成，但第二个工作流未完成，并且将引发 a TimeoutException 并显示以下消息。

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

有关与 Invoke 输出参数一起使用的示例，请参阅与此重载相同的参数的重载 Invoke ，而不使用超时间隔。

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。

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

类型参数

参数

返回

TResult 类型的值，其中包含活动执行的结果。

示例

下面的示例调用一个工作流，该工作流包含一个具有两个输入参数的单个 Add 活动，因为它派生自 CodeActivity<int> 具有一个定义 Result 完善的输出参数。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 调用 Invoke 返回时，将返回输出参数的值 Result 。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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

类型参数

参数

返回

TResult 类型的值，其中包含活动执行的结果。

示例

下面的示例调用一个工作流，该工作流包含一个具有两个输入参数的单个 Add 活动，因为它派生自 CodeActivity<int> 具有一个定义 Result 完善的输出参数。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 调用 Invoke 返回时，将返回输出参数的值 Result 。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 若要配置工作流必须完成的超时间隔，请使用采用的重载之 Invoke 一 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

类型参数

参数

返回

TResult 类型的值，其中包含活动执行的结果。

示例

下面的示例调用一个工作流，该工作流包含一个具有两个输入参数的单个 Add 活动，因为它派生自 CodeActivity<int> 具有一个定义 Result 完善的输出参数。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 调用 Invoke 返回时，将返回输出参数的值 Result 。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。

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

类型参数

参数

返回

TResult 类型的值，其中包含活动执行的结果。

示例

下面的示例调用一个工作流，该工作流包含一个具有两个输入参数的单个 Add 活动，因为它派生自 CodeActivity<int> 具有一个定义 Result 完善的输出参数。 调用工作流时， arguments 将传递包含每个输入参数的值（按参数名称键控）的字典。 调用 Invoke 返回时，将返回输出参数的值 Result 。

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

注解

此方法会阻止工作流完成，包括空闲时间。 所有工作流执行都保证在调用线程上执行。 如果工作流未在指定的超时间隔内完成，则工作流中止并引发一个 TimeoutException 。