WorkflowInvoker.InvokeAsync Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Activities

Assembly:: System.Activities.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Richiama un flusso di lavoro in modo asincrono usando il modello di struttura asincrono basato su eventi.

Overload

InvokeAsync(TimeSpan, Object)	Richiama in modo asincrono un flusso di lavoro con intervallo di timeout specificato e un identificatore univoco.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Richiama in modo asincrono con il IDictionary<TKey,TValue> specificato dei parametri di input e dell'intervallo di timeout specificato.
InvokeAsync(IDictionary<String,Object>, Object)	Richiama in modo asincrono un flusso di lavoro usando la definizione di flusso di lavoro e il IDictionary<TKey,TValue> specificato dei parametri di input e un identificatore univoco.
InvokeAsync()	Richiama in modo asincrono un flusso di lavoro.
InvokeAsync(Object)	Richiama in modo asincrono un flusso di lavoro utilizzando l'identificatore univoco specificato.
InvokeAsync(IDictionary<String,Object>)	Richiama un flusso di lavoro in modo asincrono utilizzando il IDictionary<TKey,TValue> specificato dei parametri di input.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Richiama un flusso di lavoro in modo asincrono con il IDictionary<TKey,TValue> specificato dei parametri di input, l'intervallo di timeout specificato e un identificatore univoco.
InvokeAsync(TimeSpan)	Richiama in modo asincrono un flusso di lavoro con intervallo di timeout specificato.

Commenti

Per ricevere una notifica quando il flusso di lavoro è completo, gestire il InvokeCompleted. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload InvokeAsync che accettano un oggetto TimeSpan.

Questo metodo richiama un flusso di lavoro in modo asincrono usando il modello di struttura asincrono basato su eventi. Per ulteriori informazioni, vedere Cenni preliminari sul modello asincrono basato su eventi.

InvokeAsync(TimeSpan, Object)

Richiama in modo asincrono un flusso di lavoro con intervallo di timeout specificato e un identificatore univoco.

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)

Parametri

timeout: TimeSpan

L'intervallo nel quale deve essere completato il flusso di lavoro prima che sia interrotto e un TimeoutException venga generato.

userState: Object

Un oggetto fornito dall'utente utilizzato per distinguere questa particolare operazione invoke asincrona dalle altre operazioni invoke asincrone correnti.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro composto da un'attività LongRunningDiceRoll. L'attività LongRunningDiceRoll dispone di due argomenti di output che rappresentano i risultati dell'operazione di lancio dei dadi. Quando il flusso di lavoro viene completato questi vengono recuperati nel gestore 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.");

Commenti

Il parametro userState deve essere univoco attraverso tutto le operazioni attualmente in esecuzione InvokeAsync per l'attività corrente. Se userState non è univoco, viene generato un ArgumentException. userState viene utilizzato per identificare il flusso di lavoro in InvokeCompleted e per annullare il flusso di lavoro utilizzando CancelAsync.

Per ricevere una notifica quando il flusso di lavoro è completo, gestire il InvokeCompleted. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

Nota

L'eccezione TimeoutException viene generata solo se l'intervallo di timeout scade e il flusso di lavoro diventa inattivo durante l'esecuzione. Un flusso di lavoro il cui completamento richiede più tempo rispetto all'intervallo di timeout specificato viene completato correttamente se non diventa inattivo.

Si applica a

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Richiama in modo asincrono con il IDictionary<TKey,TValue> specificato dei parametri di input e dell'intervallo di timeout specificato.

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)

Parametri

inputs: IDictionary<String,Object>

Il dizionario di parametri di input al flusso di lavoro codificati dal nome dell'argomento.

timeout: TimeSpan

L'intervallo nel quale deve essere completato il flusso di lavoro prima che sia interrotto e un TimeoutException venga generato.

Esempio

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

Commenti

Nota

Questo metodo archivia nell'attività restituisce tutte le eccezioni non di utilizzo che la controparte sincrona del metodo può generare. Se un'eccezione viene archiviata nell'attività restituita, tale eccezione verrà generata quando l'attività è attesa. Le eccezioni di utilizzo, ad esempio ArgumentException, vengono comunque generate in modo sincrono. Per le eccezioni archiviate, vedere le eccezioni generate da Invoke(IDictionary<String,Object>, TimeSpan).

Si applica a

InvokeAsync(IDictionary<String,Object>, Object)

Richiama in modo asincrono un flusso di lavoro usando la definizione di flusso di lavoro e il IDictionary<TKey,TValue> specificato dei parametri di input e un identificatore univoco.

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)

Parametri

inputs: IDictionary<String,Object>

Il dizionario di parametri di input al flusso di lavoro codificati dal nome dell'argomento.

userState: Object

Un oggetto fornito dall'utente utilizzato per distinguere questa particolare operazione invoke asincrona dalle altre operazioni invoke asincrone correnti.

Esempio

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

Commenti

Si applica a

InvokeAsync()

Richiama in modo asincrono un flusso di lavoro.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Esempio

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

Commenti

Si applica a

InvokeAsync(Object)

Richiama in modo asincrono un flusso di lavoro utilizzando l'identificatore univoco specificato.

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Parametri

userState: Object

Un oggetto fornito dall'utente utilizzato per distinguere questa particolare operazione invoke asincrona dalle altre operazioni invoke asincrone correnti.

Esempio

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

Commenti

Il parametro userState deve essere univoco attraverso tutto le operazioni attualmente in esecuzione InvokeAsync per l'attività corrente. Se il parametro userState non è univoco, viene generato un ArgumentException. userState viene utilizzato per identificare il flusso di lavoro in InvokeCompleted e per annullare il flusso di lavoro utilizzando CancelAsync.

Si applica a

InvokeAsync(IDictionary<String,Object>)

Richiama un flusso di lavoro in modo asincrono utilizzando il IDictionary<TKey,TValue> specificato dei parametri di input.

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

Parametri

inputs: IDictionary<String,Object>

Il dizionario di parametri di input al flusso di lavoro codificati dal nome dell'argomento.

Esempio

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

Commenti

Si applica a

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

Richiama un flusso di lavoro in modo asincrono con il IDictionary<TKey,TValue> specificato dei parametri di input, l'intervallo di timeout specificato e un identificatore univoco.

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)

Parametri

inputs: IDictionary<String,Object>

Il dizionario di parametri di input al flusso di lavoro codificati dal nome dell'argomento.

timeout: TimeSpan

L'intervallo nel quale deve essere completato il flusso di lavoro prima che sia interrotto e un TimeoutException venga generato.

userState: Object

Un oggetto fornito dall'utente utilizzato per distinguere questa particolare operazione invoke asincrona dalle altre operazioni invoke asincrone correnti.

Esempio

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

Commenti

Nota

Si applica a

InvokeAsync(TimeSpan)

Richiama in modo asincrono un flusso di lavoro con intervallo di timeout specificato.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Parametri

timeout: TimeSpan

L'intervallo nel quale deve essere completato il flusso di lavoro prima che sia interrotto e un TimeoutException venga generato.

Esempio

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

Commenti

Nota

Si applica a

Condividi tramite

WorkflowInvoker.InvokeAsync Metodo

Definizione

Overload

Commenti

InvokeAsync(TimeSpan, Object)

Parametri

Esempio

Commenti

Si applica a

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Parametri

Esempio

Commenti

Si applica a

InvokeAsync(IDictionary<String,Object>, Object)

Parametri

Esempio

Commenti

Si applica a

InvokeAsync()

Esempio

Commenti

Si applica a

InvokeAsync(Object)

Parametri

Esempio

Commenti

Si applica a

InvokeAsync(IDictionary<String,Object>)

Parametri

Esempio

Commenti

Si applica a

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

Parametri

Esempio

Commenti

Si applica a

InvokeAsync(TimeSpan)

Parametri

Esempio

Commenti

Si applica a

Risorse aggiuntive