WorkflowInvoker.InvokeAsync Méthode

Référence

Définition

Espace de noms:: System.Activities

Assembly:: System.Activities.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Appelle de façon asynchrone un flux de travail à l’aide du modèle de conception asynchrone basé sur les événements.

Surcharges

InvokeAsync(TimeSpan, Object)	Appelle de façon asynchrone un flux de travail avec l'intervalle de délai d'attente spécifié et un identificateur unique.
InvokeAsync(IDictionary<String,Object>, TimeSpan)	Appelle de façon asynchrone un flux de travail avec l'objet IDictionary<TKey,TValue> des paramètres d'entrée et l'intervalle de délai d'attente qui ont été spécifiés.
InvokeAsync(IDictionary<String,Object>, Object)	Appelle de façon asynchrone un flux de travail à l'aide de l'objet IDictionary<TKey,TValue> des paramètres d'entrée qui est spécifié et d'un identificateur unique.
InvokeAsync()	Appelle un flux de travail de façon asynchrone.
InvokeAsync(Object)	Appelle de façon asynchrone un flux de travail à l'aide de l'identificateur unique spécifié.
InvokeAsync(IDictionary<String,Object>)	Appelle de façon asynchrone un flux de travail à l'aide de l'objet IDictionary<TKey,TValue> spécifié des paramètres d'entrée.
InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)	Appelle de façon asynchrone un flux de travail avec l'objet IDictionary<TKey,TValue> des paramètres d'entrée qui est spécifié, l'intervalle de délai d'attente indiqué et un identificateur unique.
InvokeAsync(TimeSpan)	Appelle de façon asynchrone un flux de travail avec l'intervalle de délai d'attente spécifié.

Remarques

Pour être informé de la fin du flux de travail, gérez l'événement InvokeCompleted. Pour configurer un intervalle de délai d'attente au cours duquel le flux de travail doit être exécuté, utilisez l'une des surcharges de InvokeAsync acceptant un objet TimeSpan.

Cette méthode appelle de façon asynchrone un flux de travail à l’aide du modèle de conception asynchrone basé sur les événements. Pour plus d’informations, consultez l’article Vue d’ensemble du modèle asynchrone basé sur les événements.

InvokeAsync(TimeSpan, Object)

Appelle de façon asynchrone un flux de travail avec l'intervalle de délai d'attente spécifié et un identificateur unique.

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)

Paramètres

timeout: TimeSpan

Intervalle pendant lequel le flux de travail doit s'exécuter avant qu'il ne soit interrompu et qu'une exception TimeoutException ne soit levée.

userState: Object

Objet fourni par l'utilisateur permettant de distinguer cet appel asynchrone particulier des autres opérations courantes d'appel asynchrone.

Exemples

L'exemple suivant appelle un flux de travail composé d'une activité LongRunningDiceRoll. L’activité LongRunningDiceRoll a deux arguments de sortie qui représentent les résultats du jet de dés. Lorsque le flux de travail se termine, ces arguments sont récupérés dans le gestionnaire d'événements 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.");

Remarques

Le paramètre userState doit être unique à travers toutes les opérations InvokeAsync en cours d'exécution pour l'activité actuelle. Si userState n'est pas unique, une exception ArgumentException est levée userState permet d'identifier le flux de travail dans l'événement InvokeCompleted et d'annuler le flux de travail à l'aide de la méthode CancelAsync.

Pour être informé de la fin du flux de travail, gérez l'événement InvokeCompleted. Si le flux de travail ne se termine pas dans le délai spécifié, le flux de travail est interrompu et une exception TimeoutException est levée.

Notes

TimeoutException est levée uniquement si l'intervalle de délai d'attente est écoulé et que le workflow devient inactif pendant l'exécution. Un flux de travail dont le délai d'exécution dépasse l'intervalle de délai d'attente spécifié se termine correctement s'il ne devient pas inactif.

S’applique à

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Appelle de façon asynchrone un flux de travail avec l'objet IDictionary<TKey,TValue> des paramètres d'entrée et l'intervalle de délai d'attente qui ont été spécifiés.

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)

Paramètres

inputs: IDictionary<String,Object>

Dictionnaire des paramètres d’entrée du flux de travail, indexés par nom d’argument.

timeout: TimeSpan

Intervalle pendant lequel le flux de travail doit s'exécuter avant qu'il ne soit interrompu et qu'une exception TimeoutException ne soit levée.

Exemples

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

Remarques

Notes

Cette méthode stocke dans la tâche toutes les exceptions de non-utilisation que le équivalent synchrone de la méthode peut lever. Si une exception est stockée dans la tâche retournée, cette exception est levée lorsque la tâche est attendue. Les exceptions d’utilisation, telles que ArgumentException, sont toujours levées de manière synchrone. Pour les exceptions stockées, consultez les exceptions levées par Invoke(IDictionary<String,Object>, TimeSpan).

S’applique à

InvokeAsync(IDictionary<String,Object>, Object)

Appelle de façon asynchrone un flux de travail à l'aide de l'objet IDictionary<TKey,TValue> des paramètres d'entrée qui est spécifié et d'un identificateur unique.

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)

Paramètres

inputs: IDictionary<String,Object>

Dictionnaire des paramètres d’entrée du flux de travail, indexés par nom d’argument.

userState: Object

Objet fourni par l'utilisateur permettant de distinguer cet appel asynchrone particulier des autres opérations courantes d'appel asynchrone.

Exemples

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

Remarques

S’applique à

InvokeAsync()

Appelle un flux de travail de façon asynchrone.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Exemples

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

Remarques

S’applique à

InvokeAsync(Object)

Appelle de façon asynchrone un flux de travail à l'aide de l'identificateur unique spécifié.

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

public void InvokeAsync (object userState);

member this.InvokeAsync : obj -> unit

Public Sub InvokeAsync (userState As Object)

Paramètres

userState: Object

Objet fourni par l'utilisateur permettant de distinguer cet appel asynchrone particulier des autres opérations courantes d'appel asynchrone.

Exemples

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

Remarques

Le paramètre userState doit être unique à travers toutes les opérations InvokeAsync en cours d'exécution pour l'activité actuelle. Si le paramètre userState n'est pas unique, une exception ArgumentException est levée userState permet d'identifier le flux de travail dans l'événement InvokeCompleted et d'annuler le flux de travail à l'aide de la méthode CancelAsync.

S’applique à

InvokeAsync(IDictionary<String,Object>)

Appelle de façon asynchrone un flux de travail à l'aide de l'objet IDictionary<TKey,TValue> spécifié des paramètres d'entrée.

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

Paramètres

inputs: IDictionary<String,Object>

Dictionnaire des paramètres d’entrée du flux de travail, indexés par nom d’argument.

Exemples

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

Remarques

S’applique à

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

Appelle de façon asynchrone un flux de travail avec l'objet IDictionary<TKey,TValue> des paramètres d'entrée qui est spécifié, l'intervalle de délai d'attente indiqué et un identificateur unique.

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)

Paramètres

inputs: IDictionary<String,Object>

Dictionnaire des paramètres d’entrée du flux de travail, indexés par nom d’argument.

timeout: TimeSpan

Intervalle pendant lequel le flux de travail doit s'exécuter avant qu'il ne soit interrompu et qu'une exception TimeoutException ne soit levée.

userState: Object

Objet fourni par l'utilisateur permettant de distinguer cet appel asynchrone particulier des autres opérations courantes d'appel asynchrone.

Exemples

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

Remarques

Notes

S’applique à

InvokeAsync(TimeSpan)

Appelle de façon asynchrone un flux de travail avec l'intervalle de délai d'attente spécifié.

public:
 void InvokeAsync(TimeSpan timeout);

public void InvokeAsync (TimeSpan timeout);

member this.InvokeAsync : TimeSpan -> unit

Public Sub InvokeAsync (timeout As TimeSpan)

Paramètres

timeout: TimeSpan

Intervalle pendant lequel le flux de travail doit s'exécuter avant qu'il ne soit interrompu et qu'une exception TimeoutException ne soit levée.

Exemples

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

Remarques

Notes

S’applique à

WorkflowInvoker.InvokeAsync Méthode

Définition

Surcharges

Remarques

InvokeAsync(TimeSpan, Object)

Paramètres

Exemples

Remarques

S’applique à

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Paramètres

Exemples

Remarques

S’applique à

InvokeAsync(IDictionary<String,Object>, Object)

Paramètres

Exemples

Remarques

S’applique à

InvokeAsync()

Exemples

Remarques

S’applique à

InvokeAsync(Object)

Paramètres

Exemples

Remarques

S’applique à

InvokeAsync(IDictionary<String,Object>)

Paramètres

Exemples

Remarques

S’applique à

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

Paramètres

Exemples

Remarques

S’applique à

InvokeAsync(TimeSpan)

Paramètres

Exemples

Remarques

S’applique à

Commentaires

Ressources supplémentaires