WorkflowInvoker.InvokeAsync Methode

Definition

Namespace:

System.Activities

Assembly:

System.Activities.dll

Ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf.

Überlädt

InvokeAsync(TimeSpan, Object)	Ruft einen Workflow mit dem angegebenen Timeoutintervall und einem eindeutigen Bezeichner asynchron auf.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern und des angegebenen Timeoutintervalls asynchron auf.
InvokeAsync(IDictionary<String,Object>, Object)	Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern und einem eindeutigen Bezeichner asynchron auf.
InvokeAsync()	Ruft einen Workflow asynchron auf.
InvokeAsync(Object)	Ruft einen Workflow mithilfe des angegebenen eindeutigen Bezeichners asynchron auf.
InvokeAsync(IDictionary<String,Object>)	Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern asynchron auf.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern, des angegebenen Timeoutintervalls und einem eindeutigen Bezeichner asynchron auf.
InvokeAsync(TimeSpan)	Ruft einen Workflow mit dem angegebenen Timeoutintervall asynchron auf.

Hinweise

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Um ein anderes Timeoutintervall für den Abschluss des Workflows zu konfigurieren, verwenden Sie eine der InvokeAsync-Überladungen, die einen TimeSpan annehmen.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

InvokeAsync(TimeSpan, Object)

Ruft einen Workflow mit dem angegebenen Timeoutintervall und einem eindeutigen Bezeichner asynchron auf.

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)

Parameter

timeout

TimeSpan

Das Intervall, in dem der Workflow abgeschlossen werden muss, bevor er abgebrochen und eine TimeoutException ausgelöst wird.

userState

Object

Ein vom Benutzer bereitgestelltes Objekt, mit dem dieser spezielle asynchrone Aufrufvorgang von anderen aktuellen asynchronen Aufrufvorgängen unterschieden wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Der userState-Parameter muss in allen gerade ausgeführten InvokeAsync-Vorgängen für die aktuelle Aktivität eindeutig sein. Wenn userState nicht eindeutig ist, wird eine ArgumentException ausgelöst. Mit userState wird der Workflow in InvokeCompleted identifiziert und mit CancelAsync abgebrochen.

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Falls der Workflow innerhalb des angegebenen Timeoutintervalls nicht abgeschlossen wird, wird der Workflow abgebrochen, und eine TimeoutException wird ausgelöst.

Hinweis

Das TimeoutException-Objekt wird nur ausgelöst, wenn das Timeoutintervall verstreicht und der Workflow während der Ausführung in den Leerlauf wechselt. Ein Workflow, der erst nach dem angegebenen Timeoutintervall abgeschlossen wird, wird dennoch erfolgreich beendet, wenn der Workflow nicht in den Leerlauf wechselt.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern und des angegebenen Timeoutintervalls asynchron auf.

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)

Parameter

inputs

IDictionary<String,Object>

Das Wörterbuch von Eingabeparametern für den Workflow, nach Argumentname geordnet.

timeout

TimeSpan

Das Intervall, in dem der Workflow abgeschlossen werden muss, bevor er abgebrochen und eine TimeoutException ausgelöst wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Falls der Workflow innerhalb des angegebenen Timeoutintervalls nicht abgeschlossen wird, wird der Workflow abgebrochen, und eine TimeoutException wird ausgelöst.

Hinweis

Das TimeoutException-Objekt wird nur ausgelöst, wenn das Timeoutintervall verstreicht und der Workflow während der Ausführung in den Leerlauf wechselt. Ein Workflow, der erst nach dem angegebenen Timeoutintervall abgeschlossen wird, wird dennoch erfolgreich beendet, wenn der Workflow nicht in den Leerlauf wechselt.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

Diese Methode speichert in der Aufgabe, die sie alle Nichtverwendungsausnahmen zurückgibt, die die synchrone Entsprechung der Methode auslösen kann. Wenn eine Ausnahme in der zurückgegebenen Aufgabe gespeichert wird, wird diese Ausnahme ausgelöst, wenn die Aufgabe erwartet wird. Nutzungsausnahmen, z. B ArgumentException. , werden weiterhin synchron ausgelöst. Informationen zu den gespeicherten Ausnahmen finden Sie unter die von ausgelösten Invoke(IDictionary<String,Object>, TimeSpan)Ausnahmen.

InvokeAsync(IDictionary<String,Object>, Object)

Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern und einem eindeutigen Bezeichner asynchron auf.

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)

Parameter

inputs

IDictionary<String,Object>

Das Wörterbuch von Eingabeparametern für den Workflow, nach Argumentname geordnet.

userState

Object

Ein vom Benutzer bereitgestelltes Objekt, mit dem dieser spezielle asynchrone Aufrufvorgang von anderen aktuellen asynchronen Aufrufvorgängen unterschieden wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Der userState-Parameter muss in allen gerade ausgeführten InvokeAsync-Vorgängen für die aktuelle Aktivität eindeutig sein. Wenn userState nicht eindeutig ist, wird eine ArgumentException ausgelöst. Mit userState wird der Workflow in InvokeCompleted identifiziert und mit CancelAsync abgebrochen.

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Um ein anderes Timeoutintervall für den Abschluss des Workflows zu konfigurieren, verwenden Sie eine der InvokeAsync-Überladungen, die einen TimeSpan annehmen.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

InvokeAsync()

Ruft einen Workflow asynchron auf.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Um ein anderes Timeoutintervall für den Abschluss des Workflows zu konfigurieren, verwenden Sie eine der InvokeAsync-Überladungen, die einen TimeSpan annehmen.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

Diese Methode speichert in der Aufgabe, die sie alle Nichtverwendungsausnahmen zurückgibt, die die synchrone Entsprechung der Methode auslösen kann. Wenn eine Ausnahme in der zurückgegebenen Aufgabe gespeichert wird, wird diese Ausnahme ausgelöst, wenn die Aufgabe erwartet wird. Nutzungsausnahmen, z. B ArgumentException. , werden weiterhin synchron ausgelöst. Informationen zu den gespeicherten Ausnahmen finden Sie unter die von ausgelösten Invoke()Ausnahmen.

InvokeAsync(Object)

Ruft einen Workflow mithilfe des angegebenen eindeutigen Bezeichners asynchron auf.

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parameter

userState

Object

Ein vom Benutzer bereitgestelltes Objekt, mit dem dieser spezielle asynchrone Aufrufvorgang von anderen aktuellen asynchronen Aufrufvorgängen unterschieden wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Der userState-Parameter muss in allen gerade ausgeführten InvokeAsync-Vorgängen für die aktuelle Aktivität eindeutig sein. Wenn der userState-Parameter nicht eindeutig ist, wird eine ArgumentException ausgelöst. Mit userState wird der Workflow in InvokeCompleted identifiziert und mit CancelAsync abgebrochen.

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Um ein anderes Timeoutintervall für den Abschluss des Workflows zu konfigurieren, verwenden Sie eine der InvokeAsync-Überladungen, die einen TimeSpan annehmen.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

InvokeAsync(IDictionary<String,Object>)

Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern asynchron auf.

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

Parameter

inputs

IDictionary<String,Object>

Das Wörterbuch von Eingabeparametern für den Workflow, nach Argumentname geordnet.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Um ein anderes Timeoutintervall für den Abschluss des Workflows zu konfigurieren, verwenden Sie eine der InvokeAsync-Überladungen, die einen TimeSpan annehmen.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

Diese Methode speichert in der Aufgabe, die sie alle Nichtverwendungsausnahmen zurückgibt, die die synchrone Entsprechung der Methode auslösen kann. Wenn eine Ausnahme in der zurückgegebenen Aufgabe gespeichert wird, wird diese Ausnahme ausgelöst, wenn die Aufgabe erwartet wird. Nutzungsausnahmen, z. B ArgumentException. , werden weiterhin synchron ausgelöst. Informationen zu den gespeicherten Ausnahmen finden Sie unter ausnahmen, die von ausgelöst werden Invoke(IDictionary<String,Object>).

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

Ruft einen Workflow mithilfe des angegebenen IDictionary<TKey,TValue> von Eingabeparametern, des angegebenen Timeoutintervalls und einem eindeutigen Bezeichner asynchron auf.

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)

Parameter

inputs

IDictionary<String,Object>

Das Wörterbuch von Eingabeparametern für den Workflow, nach Argumentname geordnet.

timeout

TimeSpan

Das Intervall, in dem der Workflow abgeschlossen werden muss, bevor er abgebrochen und eine TimeoutException ausgelöst wird.

userState

Object

Ein vom Benutzer bereitgestelltes Objekt, mit dem dieser spezielle asynchrone Aufrufvorgang von anderen aktuellen asynchronen Aufrufvorgängen unterschieden wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Der userState-Parameter muss in allen gerade ausgeführten InvokeAsync-Vorgängen für die aktuelle Aktivität eindeutig sein. Wenn userState nicht eindeutig ist, wird eine ArgumentException ausgelöst. Mit userState wird der Workflow in InvokeCompleted identifiziert und mit CancelAsync abgebrochen.

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Falls der Workflow innerhalb des angegebenen Timeoutintervalls nicht abgeschlossen wird, wird der Workflow abgebrochen, und eine TimeoutException wird ausgelöst.

Hinweis

Das TimeoutException-Objekt wird nur ausgelöst, wenn das Timeoutintervall verstreicht und der Workflow während der Ausführung in den Leerlauf wechselt. Ein Workflow, der erst nach dem angegebenen Timeoutintervall abgeschlossen wird, wird dennoch erfolgreich beendet, wenn der Workflow nicht in den Leerlauf wechselt.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

InvokeAsync(TimeSpan)

Ruft einen Workflow mit dem angegebenen Timeoutintervall asynchron auf.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parameter

timeout

TimeSpan

Das Intervall, in dem der Workflow abgeschlossen werden muss, bevor er abgebrochen und eine TimeoutException ausgelöst wird.

Beispiele

Im folgenden Beispiel wird ein Workflow aufgerufen, der aus einer LongRunningDiceRoll-Aktivität besteht. Die LongRunningDiceRoll-Aktivität verfügt über zwei Ausgabeargumente, die die Ergebnisse des Würfelvorgangs darstellen. Wenn der Workflow abgeschlossen ist, werden diese im InvokeCompleted-Handler abgerufen.

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

Hinweise

Um benachrichtigt zu werden, wenn der Workflow abgeschlossen wurde, verarbeiten Sie InvokeCompleted. Falls der Workflow innerhalb des angegebenen Timeoutintervalls nicht abgeschlossen wird, wird der Workflow abgebrochen, und eine TimeoutException wird ausgelöst.

Hinweis

Das TimeoutException-Objekt wird nur ausgelöst, wenn das Timeoutintervall verstreicht und der Workflow während der Ausführung in den Leerlauf wechselt. Ein Workflow, der erst nach dem angegebenen Timeoutintervall abgeschlossen wird, wird dennoch erfolgreich beendet, wenn der Workflow nicht in den Leerlauf wechselt.

Diese Methode ruft einen Workflow mithilfe des ereignisbasierten asynchronen Entwurfsmusters asynchron auf. Weitere Informationen finden Sie unter Übersicht über ereignisbasierte asynchrone Muster.

Diese Methode speichert in der Aufgabe, die alle Nichtverwendungsausnahmen zurückgibt, die die synchrone Entsprechung der Methode auslösen kann. Wenn eine Ausnahme in der zurückgegebenen Aufgabe gespeichert wird, wird diese Ausnahme ausgelöst, wenn die Aufgabe erwartet wird. Verwendungsausnahmen wie ArgumentExceptionwerden weiterhin synchron ausgelöst. Informationen zu den gespeicherten Ausnahmen finden Sie unter ausnahmen, die von ausgelöst werden Invoke(TimeSpan).