Partager via


WorkflowInvoker.InvokeAsync Méthode

Définition

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.

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.

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

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

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.

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.

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

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

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

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

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.

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

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

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

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.

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

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

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.

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

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

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.

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.

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

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

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.

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.

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(TimeSpan).

S’applique à