WorkflowInvoker.Invoke Metodo

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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro che contiene due attività WriteLine e un'attività Delay configurato con un Duration di un minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda volta con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma non il secondo, che genera un'eccezione TimeoutException.

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

Per un esempio di utilizzo Invoke con argomenti di input e output, vedere l'overload di con gli stessi parametri di questo overload senza l'intervallo di Invoke timeout.

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro che contiene due attività WriteLine e un'attività Delay configurato con un Duration di un minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda volta con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma non il secondo, che genera un'eccezione TimeoutException.

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

Per un esempio di uso Invoke con gli argomenti di output, vedere l'overload di con gli stessi parametri di questo overload senza l'intervallo di Invoke timeout.

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro composto da una singola attività Divide che dispone di due argomenti di input e due di output. Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando la chiamata a Invoke restituisce un valore, ogni argomento di output viene restituito nel dizionario outputs, anche con chiavi in base al nome dell'argomento.

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

Se il flusso di lavoro deriva da ActivityWithResult, ad esempio o Activity<TResult>e sono presenti argomenti di output oltre all'argomento di output ben definitoResult, è necessario usare un overload non generico di Invoke, ad esempio CodeActivity<TResult> questo, per recuperare gli argomenti aggiuntivi. A tale scopo, la definizione del flusso di lavoro passata in Invoke deve essere di tipo Activity. In questo esempio l'attività Divide deriva da CodeActivity<int>, ma viene dichiarata come Activity in modo che questo overload di Invoke, che restituisce un dizionario di argomenti anziché un singolo valore restituito, viene usato.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro che contiene due attività WriteLine e un'attività Delay configurato con un Duration di un minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda volta con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma non il secondo, che genera un'eccezione TimeoutException. Viene visualizzato il seguente messaggio.

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

Per un esempio di utilizzo Invoke con argomenti di input e output, vedere l'overload di con gli stessi parametri di questo overload senza l'intervallo di Invoke timeout.

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro composto da una singola attività Divide che dispone di due argomenti di input e due di output. Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando la chiamata a Invoke restituisce un valore, ogni argomento di output viene restituito nel dizionario outputs, anche con chiavi in base al nome dell'argomento.

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

Se il flusso di lavoro deriva da ActivityWithResult, ad esempio o Activity<TResult>e sono presenti argomenti di output oltre all'argomento di output ben definitoResult, è necessario usare un overload non generico di Invoke, ad esempio CodeActivity<TResult> questo, per recuperare gli argomenti aggiuntivi. A tale scopo, la definizione del flusso di lavoro passata al WorkflowInvoker costruttore deve essere di tipo Activity. In questo esempio l'attività Divide deriva da CodeActivity<int>, ma viene dichiarata come Activity in modo che questo overload di Invoke, che restituisce un dizionario di argomenti anziché un singolo valore restituito, viene usato.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro composto da una singola attività DiceRoll. L'attività DiceRoll dispone di due argomenti di output che rappresentano i risultati dell'operazione di lancio dei dadi. Nella restituzione della chiamata a Invoke, ogni argomento di output viene restituito nel dizionario di output, con chiave basata sul nome dell'argomento.

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

Se l'attività radice del flusso di lavoro non dispone di argomenti di output o se non sono necessari per l'host, è possibile ignorarli. Nell'esempio seguente viene richiamato un flusso di lavoro composto da una sola attività WriteLine che non dispone di argomenti di output.

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

WorkflowInvoker.Invoke(wf);

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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)

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro composto da una singola attività DiceRoll. L'attività DiceRoll dispone di due argomenti di output che rappresentano i risultati dell'operazione di lancio dei dadi. Nella restituzione della chiamata a Invoke, ogni argomento di output viene restituito nel dizionario di output, con chiave basata sul nome dell'argomento. Il flusso di lavoro viene richiamato due volte, usando la definizione del flusso di lavoro passata nel WorkflowInvoker costruttore.

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

Se l'attività radice del flusso di lavoro non dispone di argomenti di output o se non sono necessari per l'host, è possibile ignorarli. Nell'esempio seguente viene richiamato un flusso di lavoro composto da una sola attività WriteLine che non dispone di argomenti di output.

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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)

Parametri

Restituisce

Un dizionario dei valori OutArgument e InOutArgument dell'attività radice con chiave basata sul nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro che contiene due attività WriteLine e un'attività Delay configurato con un Duration di un minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda volta con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma non il secondo, che genera un'eccezione TimeoutException. Viene visualizzato il seguente messaggio.

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

Per un esempio di utilizzo Invoke con gli argomenti di output, vedere l'overload di Invoke con gli stessi parametri di questo overload senza l'intervallo di timeout.

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

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

Parametri di tipo

Parametri

Restituisce

Un valore di tipo TResult con il risultato dell'esecuzione dell'attività.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola Add attività con due argomenti di input e poiché deriva da CodeActivity<int> esso è presente un argomento di output ben definito Result . Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke , viene restituito il valore dell'argomento Result di output.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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

Parametri di tipo

Parametri

Restituisce

Un valore di tipo TResult con il risultato dell'esecuzione dell'attività.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola Add attività con due argomenti di input e poiché deriva da CodeActivity<int> esso è presente un argomento di output ben definito Result . Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke , viene restituito il valore dell'argomento Result di output.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Per configurare un intervallo di timeout nel quale il flusso di lavoro deve essere completato, usare uno degli overload Invoke che accettano un oggetto 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

Parametri di tipo

Parametri

Restituisce

Un valore di tipo TResult con il risultato dell'esecuzione dell'attività.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola Add attività con due argomenti di input e poiché deriva da CodeActivity<int> esso è presente un argomento di output ben definito Result . Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke , viene restituito il valore dell'argomento Result di output.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.

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

Parametri di tipo

Parametri

Restituisce

Un valore di tipo TResult con il risultato dell'esecuzione dell'attività.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola Add attività con due argomenti di input e poiché deriva da CodeActivity<int> esso è presente un argomento di output ben definito Result . Quando viene richiamato il flusso di lavoro, viene passato il dizionario arguments che contiene i valori per ogni argomento di input, con chiavi in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke , viene restituito il valore dell'argomento Result di output.

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

Commenti

Questo metodo si blocca fino a che il flusso di lavoro è stato completato, mentre include tempo di inattività. Ogni esecuzione del flusso di lavoro è garantita per essere eseguita sul thread di chiamata. Se il flusso di lavoro non è completato nell'intervallo di timeout specificato il flusso di lavoro è interrotto e un TimeoutException viene generato.