WorkflowInvoker.InvokeAsync Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Activities

Zestaw:: System.Activities.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Wywołuje asynchronicznie przepływ pracy przy użyciu asynchronicznego wzorca projektowego opartego na zdarzeniach.

Przeciążenia

InvokeAsync(TimeSpan, Object)	Wywołuje przepływ pracy asynchronicznie z określonym interwałem limitu czasu i unikatowym identyfikatorem.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Wywołuje przepływ pracy asynchronicznie z określonymi IDictionary<TKey,TValue> parametrami wejściowymi i określonym interwałem limitu czasu.
InvokeAsync(IDictionary<String,Object>, Object)	Wywołuje przepływ pracy asynchronicznie przy użyciu określonych IDictionary<TKey,TValue> parametrów wejściowych i unikatowego identyfikatora.
InvokeAsync()	Asynchronicznie wywołuje przepływ pracy.
InvokeAsync(Object)	Wywołuje przepływ pracy asynchronicznie przy użyciu określonego unikatowego identyfikatora.
InvokeAsync(IDictionary<String,Object>)	Wywołuje przepływ pracy asynchronicznie przy użyciu określonych IDictionary<TKey,TValue> parametrów wejściowych.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Wywołuje przepływ pracy asynchronicznie z określonymi IDictionary<TKey,TValue> parametrami wejściowymi, określonym interwałem limitu czasu i unikatowym identyfikatorem.
InvokeAsync(TimeSpan)	Wywołuje przepływ pracy asynchronicznie z określonym interwałem limitu czasu.

Uwagi

Aby powiadomić o zakończeniu przepływu pracy, obsłuż polecenie InvokeCompleted. Aby skonfigurować interwał limitu czasu, w którym przepływ pracy musi zostać ukończony, użyj jednego z InvokeAsync przeciążeń, które zajmują wartość TimeSpan.

Ta metoda wywołuje asynchronicznie przepływ pracy przy użyciu asynchronicznego wzorca projektowego opartego na zdarzeniach. Aby uzyskać więcej informacji, zobacz Omówienie wzorca asynchronicznego opartego na zdarzeniach.

InvokeAsync(TimeSpan, Object)

Wywołuje przepływ pracy asynchronicznie z określonym interwałem limitu czasu i unikatowym identyfikatorem.

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)

Parametry

timeout: TimeSpan

Interwał, w którym przepływ pracy musi zostać zakończony przed przerwaniem i TimeoutException jest zgłaszany.

userState: Object

Obiekt dostarczony przez użytkownika służący do odróżnienia tej konkretnej operacji asynchronicznego wywołania z innych bieżących operacji asynchronicznego wywołania.

Przykłady

Poniższy przykład wywołuje przepływ pracy składający się z LongRunningDiceRoll działania. Działanie LongRunningDiceRoll ma dwa argumenty wyjściowe reprezentujące wyniki operacji rzutowania kostką. Po zakończeniu przepływu pracy są one pobierane w procedurze InvokeCompleted obsługi.

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

Uwagi

Parametr userState musi być unikatowy dla wszystkich aktualnie uruchomionych InvokeAsync operacji dla bieżącego działania. Jeśli userState parametr nie jest unikatowy, ArgumentException jest zgłaszany. userState służy do identyfikowania przepływu pracy w InvokeCompletedprogramie i anulowania przepływu pracy przy użyciu polecenia CancelAsync.

Aby powiadomić o zakończeniu przepływu pracy, obsłuż polecenie InvokeCompleted. Jeśli przepływ pracy nie zostanie ukończony w określonym interwale limitu czasu, przepływ pracy zostanie przerwany i TimeoutException zostanie zgłoszony.

Uwaga

Parametr TimeoutException jest zgłaszany tylko wtedy, gdy upłynie interwał limitu czasu, a przepływ pracy stanie się bezczynny podczas wykonywania. Przepływ pracy, który trwa dłużej niż określony interwał przekroczenia limitu czasu, zostanie ukończony pomyślnie, jeśli przepływ pracy nie stanie się bezczynny.

Dotyczy

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Wywołuje przepływ pracy asynchronicznie z określonymi IDictionary<TKey,TValue> parametrami wejściowymi i określonym interwałem limitu czasu.

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)

Parametry

inputs: IDictionary<String,Object>

Słownik parametrów wejściowych przepływu pracy, do których kluczem jest nazwa argumentu.

timeout: TimeSpan

Interwał, w którym przepływ pracy musi zostać zakończony przed przerwaniem i TimeoutException jest zgłaszany.

Przykłady

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

Uwagi

Uwaga

Ta metoda jest przechowywana w zadaniu, które zwraca wszystkie wyjątki nieużytowe, które może zgłosić synchroniczna odpowiednik metody. Jeśli wyjątek jest przechowywany w zwracanym zadaniu, ten wyjątek zostanie zgłoszony podczas oczekiwania zadania. Wyjątki użycia, takie jak ArgumentException, są nadal zgłaszane synchronicznie. W przypadku przechowywanych wyjątków zobacz wyjątki zgłoszone przez Invoke(IDictionary<String,Object>, TimeSpan)usługę .

Dotyczy

InvokeAsync(IDictionary<String,Object>, Object)

Wywołuje przepływ pracy asynchronicznie przy użyciu określonych IDictionary<TKey,TValue> parametrów wejściowych i unikatowego identyfikatora.

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)

Parametry

inputs: IDictionary<String,Object>

Słownik parametrów wejściowych przepływu pracy, do których kluczem jest nazwa argumentu.

userState: Object

Obiekt dostarczony przez użytkownika służący do odróżnienia tej konkretnej operacji asynchronicznego wywołania z innych bieżących operacji asynchronicznego wywołania.

Przykłady

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

Uwagi

Dotyczy

InvokeAsync()

Asynchronicznie wywołuje przepływ pracy.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Przykłady

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

Uwagi

Dotyczy

InvokeAsync(Object)

Wywołuje przepływ pracy asynchronicznie przy użyciu określonego unikatowego identyfikatora.

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parametry

userState: Object

Obiekt dostarczony przez użytkownika służący do odróżnienia tej konkretnej operacji asynchronicznego wywołania z innych bieżących operacji asynchronicznego wywołania.

Przykłady

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

Uwagi

Parametr userState musi być unikatowy dla wszystkich aktualnie uruchomionych InvokeAsync operacji dla bieżącego działania. userState Jeśli parametr nie jest unikatowy, ArgumentException zgłaszany jest parametr . userState służy do identyfikowania przepływu pracy w InvokeCompletedprogramie i anulowania przepływu pracy przy użyciu polecenia CancelAsync.

Dotyczy

InvokeAsync(IDictionary<String,Object>)

Wywołuje przepływ pracy asynchronicznie przy użyciu określonych IDictionary<TKey,TValue> parametrów wejściowych.

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

Parametry

inputs: IDictionary<String,Object>

Słownik parametrów wejściowych przepływu pracy, do których kluczem jest nazwa argumentu.

Przykłady

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

Uwagi

Dotyczy

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

Wywołuje przepływ pracy asynchronicznie z określonymi IDictionary<TKey,TValue> parametrami wejściowymi, określonym interwałem limitu czasu i unikatowym identyfikatorem.

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)

Parametry

inputs: IDictionary<String,Object>

Słownik parametrów wejściowych przepływu pracy, do których kluczem jest nazwa argumentu.

timeout: TimeSpan

Interwał, w którym przepływ pracy musi zostać zakończony przed przerwaniem i TimeoutException jest zgłaszany.

userState: Object

Obiekt dostarczony przez użytkownika służący do odróżnienia tej konkretnej operacji asynchronicznego wywołania z innych bieżących operacji asynchronicznego wywołania.

Przykłady

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

Uwagi

Uwaga

Dotyczy

InvokeAsync(TimeSpan)

Wywołuje przepływ pracy asynchronicznie z określonym interwałem limitu czasu.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parametry

timeout: TimeSpan

Interwał, w którym przepływ pracy musi zostać zakończony przed przerwaniem i TimeoutException jest zgłaszany.

Przykłady

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

Uwagi

Uwaga

Dotyczy

Udostępnij za pośrednictwem

WorkflowInvoker.InvokeAsync Metoda

Definicja

Przeciążenia

Uwagi

InvokeAsync(TimeSpan, Object)

Parametry

Przykłady

Uwagi

Dotyczy

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Parametry

Przykłady

Uwagi

Dotyczy

InvokeAsync(IDictionary<String,Object>, Object)

Parametry

Przykłady

Uwagi

Dotyczy

InvokeAsync()

Przykłady

Uwagi

Dotyczy

InvokeAsync(Object)

Parametry

Przykłady

Uwagi

Dotyczy

InvokeAsync(IDictionary<String,Object>)

Parametry

Przykłady

Uwagi

Dotyczy

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

Parametry

Przykłady

Uwagi

Dotyczy

InvokeAsync(TimeSpan)

Parametry

Przykłady

Uwagi

Dotyczy

Dodatkowe zasoby