WorkflowInvoker.Invoke Méthode

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail qui contient deux WriteLine activités et une Delay activité configurée avec une Duration minute. Ce flux de travail est appelé deux fois ; la première fois avec un intervalle de délai d’attente de deux 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 le deuxième n’est pas et il 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 avec des arguments d’entrée et de sortie, consultez la surcharge avec Invoke les mêmes paramètres que cette surcharge sans l’intervalle de délai d’attente.

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail qui contient deux WriteLine activités et une Delay activité configurée avec une Duration minute. Ce flux de travail est appelé deux fois ; la première fois avec un intervalle de délai d’attente de deux 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 le deuxième n’est pas et il 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 avec des arguments de sortie, consultez la surcharge avec Invoke les mêmes paramètres que cette surcharge sans l’intervalle de délai d’attente.

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail constitué d’une activité unique Divide qui a deux arguments d’entrée et deux arguments de sortie. Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourne, chaque argument de sortie est retourné dans le dictionnaire outputs, également indexé par nom d’argument.

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 flux de travail dérive de ActivityWithResult, tel que 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 flux de travail passée Invoke doit être de type Activity. Dans cet exemple, l’activité Divide dérive de CodeActivity<int>, mais est déclarée de Activity telle sorte 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un TimeSpan.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail qui contient deux WriteLine activités et une Delay activité configurée avec une Duration minute. Ce flux de travail est appelé deux fois ; la première fois avec un intervalle de délai d’attente de deux 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 le deuxième n’est pas levée et TimeoutException le message suivant s’affiche.

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

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

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail constitué d’une activité unique Divide qui a deux arguments d’entrée et deux arguments de sortie. Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourne, chaque argument de sortie est retourné dans le dictionnaire outputs, également indexé par nom d’argument.

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 flux de travail dérive de ActivityWithResult, tel que 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 flux de travail passée dans le WorkflowInvoker constructeur doit être de type Activity. Dans cet exemple, l’activité Divide dérive de CodeActivity<int>, mais est déclarée de Activity telle sorte 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un TimeSpan.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule DiceRoll activité. L’activité DiceRoll a deux arguments de sortie qui représentent les résultats de l’opération de lancement de dés. Lorsque l’appel à Invoke retourner, chaque argument de sortie est retourné dans le dictionnaire de sorties, clé par nom d’argument.

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 aucun argument de sortie ou qu’elle n’est pas nécessaire par l’hôte, elle peut être ignorée. L’exemple suivant appelle un flux de travail constitué d’une seule WriteLine activité qui n’a aucun argument de sortie.

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

WorkflowInvoker.Invoke(wf);

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un TimeSpan.

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

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule DiceRoll activité. L’activité DiceRoll a deux arguments de sortie qui représentent les résultats de l’opération de lancement de dés. Lorsque l’appel à Invoke retourner, chaque argument de sortie est retourné dans le dictionnaire de sorties, clé par nom d’argument. Le flux de travail est appelé deux fois, à l’aide de la définition de flux de travail passée dans le WorkflowInvoker constructeur.

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

Si l’activité racine du flux de travail n’a aucun argument de sortie ou qu’elle n’est pas nécessaire par l’hôte, elle peut être ignorée. L’exemple suivant appelle un flux de travail constitué d’une seule WriteLine activité qui n’a aucun argument de sortie.

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un TimeSpan.

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

Retours

Dictionnaire des valeurs et OutArgument des InOutArgument valeurs de l’activité racine clé par nom d’argument qui représentent les sorties du flux de travail.

Exemples

L’exemple suivant appelle un flux de travail qui contient deux WriteLine activités et une Delay activité configurée avec une Duration minute. Ce flux de travail est appelé deux fois ; la première fois avec un intervalle de délai d’attente de deux 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 le deuxième n’est pas levée et TimeoutException le message suivant s’affiche.

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

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

Remarques

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.

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

Paramètres

Retours

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

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule Add activité qui a deux arguments d’entrée et, étant donné qu’il dérive de CodeActivity<int> celui-ci, il a un argument de sortie bien défini Result . Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourner, 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un TimeSpan.

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

Paramètres

Retours

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

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule Add activité qui a deux arguments d’entrée et, étant donné qu’il dérive de CodeActivity<int> celui-ci, il a un argument de sortie bien défini Result . Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourner, 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Pour configurer un intervalle de délai d’attente dans lequel le flux de travail doit se terminer, utilisez l’une Invoke des surcharges qui prennent un 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

Paramètres

Retours

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

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule Add activité qui a deux arguments d’entrée et, étant donné qu’il dérive de CodeActivity<int> celui-ci, il a un argument de sortie bien défini Result . Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourner, 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.

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

Paramètres

Retours

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

Exemples

L’exemple suivant appelle un flux de travail constitué d’une seule Add activité qui a deux arguments d’entrée et, étant donné qu’il dérive de CodeActivity<int> celui-ci, il a un argument de sortie bien défini Result . Lorsque le flux de travail est appelé, le arguments dictionnaire est passé qui contient les valeurs de chaque argument d’entrée, clé par nom d’argument. Lorsque l’appel à Invoke retourner, 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

Cette méthode se bloque jusqu’à ce que le flux de travail soit terminé, y compris le temps d’inactivité. Toutes les exécutions de flux de travail sont garanties pour s’exécuter sur le thread appelant. Si le flux de travail ne se termine pas dans l’intervalle de délai d’attente spécifié, le flux de travail est abandonné et un TimeoutException est levée.