WorkflowInvoker.InvokeAsync 方法

参考

定义

命名空间:: System.Activities

程序集:: System.Activities.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

使用基于事件的异步设计模式以异步方式调用工作流。

重载

InvokeAsync(TimeSpan, Object)	使用指定的超时间隔和唯一标识符以异步方式调用工作流。
InvokeAsync(IDictionary<String,Object>, TimeSpan)	使用指定的输入参数的 IDictionary<TKey,TValue> 和指定的超时间隔以异步方式调用工作流。
InvokeAsync(IDictionary<String,Object>, Object)	使用指定的输入参数的 IDictionary<TKey,TValue> 和唯一标识符以异步方式调用工作流。
InvokeAsync()	以异步方式调用工作流。
InvokeAsync(Object)	使用指定的唯一标识符以异步方式调用工作流。
InvokeAsync(IDictionary<String,Object>)	使用指定的输入参数的 IDictionary<TKey,TValue> 以异步方式调用工作流。
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	使用指定的输入参数的 IDictionary<TKey,TValue>、指定的超时间隔和唯一标识符以异步方式调用工作流。
InvokeAsync(TimeSpan)	使用指定的超时间隔以异步方式调用工作流。

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。若要配置工作流必须在其间完成的超时间隔，请使用一种采用 InvokeAsync 的 TimeSpan 重载。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

InvokeAsync(TimeSpan, Object)

使用指定的超时间隔和唯一标识符以异步方式调用工作流。

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)

参数

timeout: TimeSpan

工作流必须在被中止和引发 TimeoutException 之前在其中完成的时间间隔。

userState: Object

一个用户提供的对象，该对象用于将此特定的异步调用操作与其他当前的异步调用操作区别开来。

示例

下面的示例调用包含单个 LongRunningDiceRoll 活动的工作流。 LongRunningDiceRoll 活动包含两个表示掷骰子操作结果的输出自变量。当工作流完成时，将在 InvokeCompleted 处理程序中检索这些参数。

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

注解

userState 参数在所有当前对当前活动运行的 InvokeAsync 操作中必须是唯一的。如果 userState 不唯一，则引发 ArgumentException。 userState 用于标识处于 InvokeCompleted 状态的工作流以及使用 CancelAsync 取消工作流。

若要在工作流完成后得到通知，请处理 InvokeCompleted。如果工作流未在指定的超时间隔内完成，那么工作流就会被中止，并且会引发 TimeoutException。

注意

仅在达到超时间隔且工作流在执行期间进入空闲状态时才会引发 TimeoutException。如果工作流未进入空闲状态，那么完成时间超过指定超时间隔的工作流将会成功完成。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

适用于

InvokeAsync(IDictionary<String,Object>, TimeSpan)

使用指定的输入参数的 IDictionary<TKey,TValue> 和指定的超时间隔以异步方式调用工作流。

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)

参数

inputs: IDictionary<String,Object>

由自变量名称键控的工作流输入参数字典。

timeout: TimeSpan

工作流必须在被中止和引发 TimeoutException 之前在其中完成的时间间隔。

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。如果工作流未在指定的超时间隔内完成，那么工作流就会被中止，并且会引发 TimeoutException。

注意

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

此方法将存储在任务中，它返回该方法的同步对应项可能引发的所有非使用异常。如果异常存储在返回的任务中，则在等待任务时将引发该异常。使用异常（如 ArgumentException）仍会同步引发。有关存储的异常，请参阅引发的 Invoke(IDictionary<String,Object>, TimeSpan)异常。

适用于

InvokeAsync(IDictionary<String,Object>, Object)

使用指定的输入参数的 IDictionary<TKey,TValue> 和唯一标识符以异步方式调用工作流。

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)

参数

inputs: IDictionary<String,Object>

由自变量名称键控的工作流输入参数字典。

userState: Object

一个用户提供的对象，该对象用于将此特定的异步调用操作与其他当前的异步调用操作区别开来。

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。若要配置工作流必须在其间完成的超时间隔，请使用一种采用 InvokeAsync 的 TimeSpan 重载。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

适用于

InvokeAsync()

以异步方式调用工作流。

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。若要配置工作流必须在其间完成的超时间隔，请使用一种采用 InvokeAsync 的 TimeSpan 重载。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

此方法将存储在任务中，它返回该方法的同步对应项可能引发的所有非使用异常。如果异常存储在返回的任务中，则在等待任务时将引发该异常。使用异常（如 ArgumentException）仍会同步引发。有关存储的异常，请参阅引发的 Invoke()异常。

适用于

InvokeAsync(Object)

使用指定的唯一标识符以异步方式调用工作流。

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

参数

userState: Object

一个用户提供的对象，该对象用于将此特定的异步调用操作与其他当前的异步调用操作区别开来。

示例

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

注解

userState 参数在所有当前对当前活动运行的 InvokeAsync 操作中必须是唯一的。如果 userState 参数不唯一，则引发 ArgumentException。 userState 用于标识处于 InvokeCompleted 状态的工作流以及使用 CancelAsync 取消工作流。

若要在工作流完成后得到通知，请处理 InvokeCompleted。若要配置工作流必须在其间完成的超时间隔，请使用一种采用 InvokeAsync 的 TimeSpan 重载。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

适用于

InvokeAsync(IDictionary<String,Object>)

使用指定的输入参数的 IDictionary<TKey,TValue> 以异步方式调用工作流。

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

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

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

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

参数

inputs: IDictionary<String,Object>

由自变量名称键控的工作流输入参数字典。

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。若要配置工作流必须在其间完成的超时间隔，请使用一种采用 InvokeAsync 的 TimeSpan 重载。

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

此方法将存储在任务中，它返回该方法的同步对应项可能引发的所有非使用异常。如果异常存储在返回的任务中，则在等待任务时将引发该异常。使用异常（如 ArgumentException）仍会同步引发。有关存储的异常，请参阅引发的 Invoke(IDictionary<String,Object>)异常。

适用于

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

使用指定的输入参数的 IDictionary<TKey,TValue>、指定的超时间隔和唯一标识符以异步方式调用工作流。

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)

参数

inputs: IDictionary<String,Object>

由自变量名称键控的工作流输入参数字典。

timeout: TimeSpan

工作流必须在被中止和引发 TimeoutException 之前在其中完成的时间间隔。

userState: Object

一个用户提供的对象，该对象用于将此特定的异步调用操作与其他当前的异步调用操作区别开来。

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。如果工作流未在指定的超时间隔内完成，那么工作流就会被中止，并且会引发 TimeoutException。

注意

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

适用于

InvokeAsync(TimeSpan)

使用指定的超时间隔以异步方式调用工作流。

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

参数

timeout: TimeSpan

工作流必须在被中止和引发 TimeoutException 之前在其中完成的时间间隔。

示例

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

注解

若要在工作流完成后得到通知，请处理 InvokeCompleted。如果工作流未在指定的超时间隔内完成，那么工作流就会被中止，并且会引发 TimeoutException。

注意

此方法使用基于事件的异步设计模式以异步方式调用工作流。有关详细信息，请参阅基于事件的异步模式概述。

此方法将存储在任务中，它返回该方法的同步对应项可能引发的所有非使用异常。如果异常存储在返回的任务中，则在等待任务时将引发该异常。使用异常（如 ArgumentException）仍会同步引发。有关存储的异常，请参阅引发的 Invoke(TimeSpan)异常。

适用于

通过

WorkflowInvoker.InvokeAsync 方法

定义

重载

注解

InvokeAsync(TimeSpan, Object)

参数

示例

注解

适用于

InvokeAsync(IDictionary<String,Object>, TimeSpan)

参数

示例

注解

适用于

InvokeAsync(IDictionary<String,Object>, Object)

参数

示例

注解

适用于

InvokeAsync()

示例

注解

适用于

InvokeAsync(Object)

参数

示例

注解

适用于

InvokeAsync(IDictionary<String,Object>)

参数

示例

注解

适用于

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

参数

示例

注解

适用于

InvokeAsync(TimeSpan)

参数

示例

注解

适用于

其他资源