WorkflowInvoker.Invoke 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 un flux de travail de façon synchrone et retourne un dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Surcharges

Invoke(Activity, IDictionary<String,Object>, TimeSpan)	Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail, de l'objet IDictionary<TKey,TValue> des paramètres d'entrée et de l'intervalle de délai d'attente qui ont été spécifiés.
Invoke(Activity, TimeSpan)	Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail et de l'intervalle de délai d'attente qui ont été spécifiés.
Invoke(Activity, IDictionary<String,Object>)	Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail et de l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui ont été spécifiés.
Invoke(IDictionary<String,Object>, TimeSpan)	Appelle l'activité passée au constructeur de WorkflowInvoker(Activity) de façon synchrone 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.
Invoke(IDictionary<String,Object>)	Appelle l’activité passée au constructeur de WorkflowInvoker(Activity) de façon synchrone avec l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui est spécifié.
Invoke(Activity)	Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail spécifiée.
Invoke()	Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail passée au constructeur de WorkflowInvoker(Activity).
Invoke(TimeSpan)	Appelle de façon synchrone un flux de travail avec l’intervalle de délai d’attente spécifié.
Invoke<TResult>(Activity<TResult>)	Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail passée au constructeur de WorkflowInvoker(Activity).
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>)	Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail et de l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui ont été spécifiés.
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, TimeSpan)	Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail, de l'objet IDictionary<TKey,TValue> des paramètres d'entrée et de l'intervalle de délai d'attente qui ont été spécifiés.
Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, IDictionary<String,Object>, TimeSpan)	Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail, de l'objet IDictionary<TKey,TValue> des paramètres d'entrée, de l'objet IDictionary<TKey,TValue> des paramètres de sortie supplémentaires et de l'intervalle de délai d'attente qui ont été spécifiés.

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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 Invoke acceptant un objet TimeSpan.

Invoke(Activity, IDictionary<String,Object>, TimeSpan)

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

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity * System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, inputs As IDictionary(Of String, Object), timeout As TimeSpan) As IDictionary(Of String, Object)

Paramètres

workflow: Activity

Définition du flux de travail à appeler.

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.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

L'exemple suivant appelle un flux de travail qui contient deux activités WriteLine et une activité Delay configurée avec une propriété Duration égale à une minute. Ce flux de travail est appelé deux fois ; la première fois avec un intervalle de délai d'attente de 2 minutes et la deuxième fois avec un intervalle de délai d'attente de 30 secondes. Le premier flux de travail se termine correctement, mais pas le deuxième, et une exception TimeoutException est levée.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

// This workflow completes successfully.
WorkflowInvoker.Invoke(wf, TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    WorkflowInvoker.Invoke(wf, TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Pour obtenir un exemple d’utilisation Invoke des arguments d’entrée et de sortie avec, consultez la surcharge de Invoke avec les mêmes paramètres que cette surcharge sans l’intervalle de délai d’attente.

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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 à

Invoke(Activity, TimeSpan)

Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail et de l'intervalle de délai d'attente qui ont été spécifiés.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, TimeSpan timeout);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, TimeSpan timeout);

static member Invoke : System.Activities.Activity * TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, timeout As TimeSpan) As IDictionary(Of String, Object)

Paramètres

workflow: Activity

Définition du flux de travail à appeler.

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.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

// This workflow completes successfully.
WorkflowInvoker.Invoke(wf, TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    WorkflowInvoker.Invoke(wf, TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Pour obtenir un exemple d’utilisation Invoke d’arguments avec avec des arguments de sortie, consultez la surcharge de Invoke avec les mêmes paramètres que cette surcharge sans l’intervalle de délai d’attente.

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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

S’applique à

Invoke(Activity, IDictionary<String,Object>)

Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail et de l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui ont été spécifiés.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow, System.Collections.Generic.IDictionary<string,object> inputs);

static member Invoke : System.Activities.Activity * System.Collections.Generic.IDictionary<string, obj> -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity, inputs As IDictionary(Of String, Object)) As IDictionary(Of String, Object)

Paramètres

workflow: Activity

Définition du flux de travail à appeler.

inputs: IDictionary<String,Object>

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

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

L’exemple suivant appelle un workflow composé d’une activité Divide unique qui a deux arguments d’entrée et deux arguments de sortie. Lorsque le workflow est appelé, le dictionnaire d'arguments (arguments) est passé ; il contient les valeurs de chaque argument d'entrée, indexées par nom d'argument. Lors du retour de l'appel à Invoke, chaque argument de sortie, également indexé par nom d'argument, est retourné dans le dictionnaire outputs.

public sealed class Divide : CodeActivity
{
    [RequiredArgument]
    public InArgument<int> Dividend { get; set; }

    [RequiredArgument]
    public InArgument<int> Divisor { get; set; }

    public OutArgument<int> Remainder { get; set; }
    public OutArgument<int> Result { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Result.Set(context, quotient);
        Remainder.Set(context, remainder);
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(new Divide(), arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Si le workflow dérive de ActivityWithResult, comme CodeActivity<TResult> ou Activity<TResult>, et qu’il existe des arguments de sortie en plus de l’argument de sortie bien défini Result , une surcharge non générique de Invoke, telle que celle-ci, doit être utilisée pour récupérer les arguments supplémentaires. Pour ce faire, la définition de workflow passée dans Invoke doit être de type Activity. Dans cet exemple, l’activité Divide dérive de CodeActivity<int>, mais est déclarée comme Activity telle que cette surcharge de Invoke, qui retourne un dictionnaire d’arguments au lieu d’une valeur de retour unique, est utilisée.

public sealed class Divide : CodeActivity<int>
{
    public InArgument<int> Dividend { get; set; }
    public InArgument<int> Divisor { get; set; }
    public OutArgument<int> Remainder { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Remainder.Set(context, remainder);

        return quotient;
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

Activity wf = new Divide();

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(wf, arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Remarques

S’applique à

Invoke(IDictionary<String,Object>, TimeSpan)

Appelle l'activité passée au constructeur de WorkflowInvoker(Activity) de façon synchrone 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:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public System.Collections.Generic.IDictionary<string,object> Invoke (System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

member this.Invoke : System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Function Invoke (inputs As IDictionary(Of String, Object), timeout As TimeSpan) 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.

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.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

The operation did not complete within the allotted timeout of 00:00:30.   
The time allotted to this operation may have been a portion of a longer timeout.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

// This workflow completes successfully.
invoker.Invoke(TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    invoker.Invoke(TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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

S’applique à

Invoke(IDictionary<String,Object>)

Appelle l’activité passée au constructeur de WorkflowInvoker(Activity) de façon synchrone avec l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui est spécifié.

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public System.Collections.Generic.IDictionary<string,object> Invoke (System.Collections.Generic.IDictionary<string,object> inputs);

member this.Invoke : System.Collections.Generic.IDictionary<string, obj> -> System.Collections.Generic.IDictionary<string, obj>

Public Function Invoke (inputs As IDictionary(Of String, Object)) 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.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

public sealed class Divide : CodeActivity
{
    [RequiredArgument]
    public InArgument<int> Dividend { get; set; }

    [RequiredArgument]
    public InArgument<int> Divisor { get; set; }

    public OutArgument<int> Remainder { get; set; }
    public OutArgument<int> Result { get; set; }

    protected override void Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Result.Set(context, quotient);
        Remainder.Set(context, remainder);
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

WorkflowInvoker invoker = new WorkflowInvoker(new Divide());

IDictionary<string, object> outputs = invoker.Invoke(arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Si le workflow dérive de ActivityWithResult, comme CodeActivity<TResult> ou Activity<TResult>, et qu’il existe des arguments de sortie en plus de l’argument de sortie bien défini Result , une surcharge non générique de Invoke, telle que celle-ci, doit être utilisée pour récupérer les arguments supplémentaires. Pour ce faire, la définition de workflow passée au WorkflowInvoker constructeur doit être de type Activity. Dans cet exemple, l’activité Divide dérive de CodeActivity<int>, mais est déclarée comme Activity telle que cette surcharge de Invoke, qui retourne un dictionnaire d’arguments au lieu d’une valeur de retour unique, est utilisée.

public sealed class Divide : CodeActivity<int>
{
    public InArgument<int> Dividend { get; set; }
    public InArgument<int> Divisor { get; set; }
    public OutArgument<int> Remainder { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int quotient = Dividend.Get(context) / Divisor.Get(context);
        int remainder = Dividend.Get(context) % Divisor.Get(context);

        Remainder.Set(context, remainder);

        return quotient;
    }
}

int dividend = 500;
int divisor = 36;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("Dividend", dividend);
arguments.Add("Divisor", divisor);

Activity wf = new Divide();

WorkflowInvoker invoker = new WorkflowInvoker(wf);

IDictionary<string, object> outputs = invoker.Invoke(arguments);

Console.WriteLine("{0} / {1} = {2} Remainder {3}",
    dividend, divisor, outputs["Result"], outputs["Remainder"]);

Remarques

S’applique à

Invoke(Activity)

Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail spécifiée.

public:
 static System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(System::Activities::Activity ^ workflow);

public static System.Collections.Generic.IDictionary<string,object> Invoke (System.Activities.Activity workflow);

static member Invoke : System.Activities.Activity -> System.Collections.Generic.IDictionary<string, obj>

Public Shared Function Invoke (workflow As Activity) As IDictionary(Of String, Object)

Paramètres

workflow: Activity

Définition du flux de travail à appeler.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

L'exemple suivant appelle un flux de travail composé d'une activité DiceRoll unique. L’activité DiceRoll a deux arguments de sortie qui représentent les résultats du jet de dés. Lors du retour de l’appel à Invoke, chaque argument de sortie, indexé par nom d’argument, est retourné dans le dictionnaire de sorties.

public sealed class DiceRoll : CodeActivity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    static Random r = new Random();

    protected override void Execute(CodeActivityContext context)
    {
        D1.Set(context, r.Next(1, 7));
        D2.Set(context, r.Next(1, 7));
    }
}

IDictionary<string, object> outputs =
    WorkflowInvoker.Invoke(new DiceRoll());

Console.WriteLine("The two dice are {0} and {1}.",
    outputs["D1"], outputs["D2"]);

Si l’activité racine du flux de travail n’a pas d’arguments de sortie ou si ces derniers ne sont pas requis par l’hôte, ils peuvent être ignorés. L’exemple suivant appelle un flux de travail composé d’une activité WriteLine unique qui n’a pas d’arguments de sortie.

Activity wf = new WriteLine
{
    Text = "Hello World."
};

WorkflowInvoker.Invoke(wf);

Remarques

S’applique à

Invoke()

Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail passée au constructeur de WorkflowInvoker(Activity).

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke();

public System.Collections.Generic.IDictionary<string,object> Invoke ();

member this.Invoke : unit -> System.Collections.Generic.IDictionary<string, obj>

Public Function Invoke () As IDictionary(Of String, Object)

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

public sealed class DiceRoll : CodeActivity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    static Random r = new Random();

    protected override void Execute(CodeActivityContext context)
    {
        D1.Set(context, r.Next(1, 7));
        D2.Set(context, r.Next(1, 7));
    }
}

WorkflowInvoker invoker = new WorkflowInvoker(new DiceRoll());

IDictionary<string, object> outputs =
    invoker.Invoke();

Console.WriteLine("The two dice are {0} and {1}.",
    outputs["D1"], outputs["D2"]);

outputs = invoker.Invoke();

Console.WriteLine("The next two dice are {0} and {1}.",
    outputs["D1"], outputs["D2"]);

Activity wf = new WriteLine
{
    Text = "Hello World."
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Remarques

S’applique à

Invoke(TimeSpan)

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

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ Invoke(TimeSpan timeout);

public System.Collections.Generic.IDictionary<string,object> Invoke (TimeSpan timeout);

member this.Invoke : TimeSpan -> System.Collections.Generic.IDictionary<string, obj>

Public Function Invoke (timeout As TimeSpan) As IDictionary(Of String, 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.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

The operation did not complete within the allotted timeout of 00:00:30.   
The time allotted to this operation may have been a portion of a longer timeout.

Activity wf = new Sequence()
{
    Activities =
    {
        new WriteLine()
        {
            Text = "Before the 1 minute delay."
        },
        new Delay()
        {
            Duration = TimeSpan.FromMinutes(1)
        },
        new WriteLine()
        {
            Text = "After the 1 minute delay."
        }
    }
};

WorkflowInvoker invoker = new WorkflowInvoker(wf);

// This workflow completes successfully.
invoker.Invoke(TimeSpan.FromMinutes(2));

// This workflow does not complete and a TimeoutException
// is thrown.
try
{
    invoker.Invoke(TimeSpan.FromSeconds(30));
}
catch (TimeoutException ex)
{
    Console.WriteLine(ex.Message);
}

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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

S’applique à

Invoke<TResult>(Activity<TResult>)

Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail passée au constructeur de WorkflowInvoker(Activity).

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow);

static member Invoke : System.Activities.Activity<'Result> -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult)) As TResult

Paramètres de type

TResult

Type de flux de travail.

Paramètres

workflow: Activity<TResult>

Définition du flux de travail à appeler. La définition du flux de travail doit dériver de l'objet ActivityWithResult.

Retours

TResult

Valeur de type TResult avec le résultat de l'exécution de l'activité.

Exemples

L’exemple suivant appelle un workflow constitué d’une seule Add activité qui a deux arguments d’entrée et, étant donné qu’il en dérive CodeActivity<int> , a un argument de sortie bien défini Result . Lorsque le workflow est appelé, le dictionnaire d'arguments (arguments) est passé ; il contient les valeurs de chaque argument d'entrée, indexées par nom d'argument. Lorsque l’appel à Invoke retourne, la valeur de l’argument Result de sortie est retournée.

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Remarques

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>)

Appelle de façon synchrone un flux de travail à l’aide de la définition de flux de travail et de l’objet IDictionary<TKey,TValue> des paramètres d’entrée qui ont été spécifiés.

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object)) As TResult

Paramètres de type

TResult

Type de flux de travail.

Paramètres

workflow: Activity<TResult>

Définition du flux de travail à appeler.

inputs: IDictionary<String,Object>

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

Retours

TResult

Valeur de type TResult avec le résultat de l'exécution de l'activité.

Exemples

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Remarques

Notes

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, TimeSpan)

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object), timeout As TimeSpan) As TResult

Paramètres de type

TResult

Type de flux de travail.

Paramètres

workflow: Activity<TResult>

Définition du flux de travail à appeler.

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.

Retours

TResult

Valeur de type TResult avec le résultat de l'exécution de l'activité.

Exemples

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, IDictionary<String,Object>, TimeSpan)

Appelle de façon synchrone un flux de travail à l'aide de la définition de flux de travail, de l'objet IDictionary<TKey,TValue> des paramètres d'entrée, de l'objet IDictionary<TKey,TValue> des paramètres de sortie supplémentaires et de l'intervalle de délai d'attente qui ont été spécifiés.

public:
generic <typename TResult>
 static TResult Invoke(System::Activities::Activity<TResult> ^ workflow, System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, [Runtime::InteropServices::Out] System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ % additionalOutputs, TimeSpan timeout);

public static TResult Invoke<TResult> (System.Activities.Activity<TResult> workflow, System.Collections.Generic.IDictionary<string,object> inputs, out System.Collections.Generic.IDictionary<string,object> additionalOutputs, TimeSpan timeout);

static member Invoke : System.Activities.Activity<'Result> * System.Collections.Generic.IDictionary<string, obj> * IDictionary * TimeSpan -> 'Result

Public Shared Function Invoke(Of TResult) (workflow As Activity(Of TResult), inputs As IDictionary(Of String, Object), ByRef additionalOutputs As IDictionary(Of String, Object), timeout As TimeSpan) As TResult

Paramètres de type

TResult

Type de flux de travail.

Paramètres

workflow: Activity<TResult>

Définition du flux de travail à appeler.

inputs: IDictionary<String,Object>

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

additionalOutputs: IDictionary<String,Object>

Dictionnaire des paramètres de sortie supplémentaires 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.

Retours

TResult

Valeur de type TResult avec le résultat de l'exécution de l'activité.

Exemples

public sealed class Add : CodeActivity<int>
{
    public InArgument<int> X { get; set; }
    public InArgument<int> Y { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        int x = X.Get(context);
        int y = Y.Get(context);

        return x + y;
    }
}

int x = 1;
int y = 2;

Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("X", x);
arguments.Add("Y", y);

Console.WriteLine("Invoking Add.");

int result = WorkflowInvoker.Invoke(new Add(), arguments);

Console.WriteLine("{0} + {1} = {2}", x, y, result);

Remarques

Cette méthode s'interrompt jusqu'à ce que le flux de travail soit terminé, durée d'inactivité incluse. L'exécution du flux de travail se déroule toujours intégralement sur le thread appelant. 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

S’applique à

Partager via

WorkflowInvoker.Invoke Méthode

Définition

Surcharges

Remarques

Invoke(Activity, IDictionary<String,Object>, TimeSpan)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke(Activity, TimeSpan)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke(Activity, IDictionary<String,Object>)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke(IDictionary<String,Object>, TimeSpan)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke(IDictionary<String,Object>)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke(Activity)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke()

Retours

Exemples

Remarques

S’applique à

Invoke(TimeSpan)

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke<TResult>(Activity<TResult>)

Paramètres de type

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>)

Paramètres de type

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, TimeSpan)

Paramètres de type

Paramètres

Retours

Exemples

Remarques

S’applique à

Invoke<TResult>(Activity<TResult>, IDictionary<String,Object>, IDictionary<String,Object>, TimeSpan)

Paramètres de type

Paramètres

Retours

Exemples

Remarques

S’applique à