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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro contenente due WriteLine attività e un'attività Delay configurata con un Duration minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma il secondo non viene generato e viene generato un .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 Invoke con gli stessi parametri di questo overload senza l'intervallo di timeout.

Commenti

Questo metodo si blocca fino al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .

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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro contenente due WriteLine attività e un'attività Delay configurata con un Duration minuto. Questo flusso di lavoro viene richiamato due volte; la prima volta con un intervallo di timeout di due minuti e la seconda con un intervallo di timeout di 30 secondi. Il primo flusso di lavoro viene completato correttamente, ma il secondo non viene generato e viene generato un .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 output, vedere l'overload di Invoke con gli stessi parametri di questo overload senza l'intervallo di timeout.

Commenti

Questo metodo si blocca fino al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .

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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola attività Divide con due argomenti di input e due argomenti di output. Quando viene richiamato il flusso di lavoro, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke, ogni argomento di output viene restituito nel dizionario outputs, anche con chiave 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 CodeActivity<TResult> o Activity<TResult>e sono presenti argomenti di output oltre all'argomento di output ben definito Result , è necessario usare un overload non generico di Invoke, ad esempio 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 venga usato questo overload di Invoke, che restituisce un dizionario di argomenti anziché un singolo valore restituito.

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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

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

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 Invoke con gli stessi parametri di questo overload senza l'intervallo di timeout.

Commenti

Questo metodo si blocca fino al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .

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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola attività Divide con due argomenti di input e due argomenti di output. Quando viene richiamato il flusso di lavoro, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave in base al nome dell'argomento. Quando viene restituita la chiamata a Invoke, ogni argomento di output viene restituito nel dizionario outputs, anche con chiave 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 CodeActivity<TResult> o Activity<TResult>e sono presenti argomenti di output oltre all'argomento di output ben definito Result , è necessario usare un overload non generico di Invoke, ad esempio questo, per recuperare gli argomenti aggiuntivi. A tale scopo, la definizione del flusso di lavoro passata nel 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 venga usato questo overload di Invoke, che restituisce un dizionario di argomenti anziché un singolo valore restituito.

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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola DiceRoll attività. L'attività DiceRoll ha due argomenti di output che rappresentano i risultati dell'operazione di lancio dei dadi. Quando viene restituita la chiamata a Invoke , ogni argomento di output viene restituito nel dizionario output, con chiave in base al 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 include argomenti di output o non sono necessari per l'host, è possibile ignorarli. Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola WriteLine attività che non dispone di argomenti di output.

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

WorkflowInvoker.Invoke(wf);

Commenti

Questo metodo si blocca fino al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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)

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola DiceRoll attività. L'attività DiceRoll ha due argomenti di output che rappresentano i risultati dell'operazione di lancio dei dadi. Quando viene restituita la chiamata a Invoke , ogni argomento di output viene restituito nel dizionario output, con chiave in base al 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 include argomenti di output o non sono necessari per l'host, è possibile ignorarli. Nell'esempio seguente viene richiamato un flusso di lavoro costituito da una singola WriteLine attività 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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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

Valori restituiti

Dizionario dei valori e OutArgument dell'attività InOutArgument radice con chiave in base al nome dell'argomento che rappresentano gli output del flusso di lavoro.

Esempio

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

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 output, vedere l'overload di Invoke con gli stessi parametri di questo overload senza l'intervallo di timeout.

Commenti

Questo metodo si blocca fino al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .

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

Valori restituiti

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, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave 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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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

Valori restituiti

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, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave 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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Per configurare un intervallo di timeout in cui il flusso di lavoro deve essere completato, usare uno degli Invoke overload 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

Valori restituiti

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, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave 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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .

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

Valori restituiti

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, il arguments dizionario viene passato che contiene i valori per ogni argomento di input, con chiave 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 al completamento del flusso di lavoro, incluso il tempo di inattività. Tutte le esecuzioni del flusso di lavoro sono garantite per l'esecuzione sul thread chiamante. Se il flusso di lavoro non viene completato entro l'intervallo di timeout specificato, il flusso di lavoro viene interrotto e viene generata un'eccezione TimeoutException .