WorkflowInvoker.Invoke Metoda

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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který obsahuje dvě WriteLine aktivity a aktivitu nakonfigurovanou Delay s minutou Duration . Tento pracovní postup je vyvolán dvakrát; poprvé s intervalem časového limitu dvě minuty a podruhé s časovým limitem 30 sekund. První pracovní postup se úspěšně dokončí, ale druhý ne a TimeoutException vyvolá se.

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

Příklad použití Invoke se vstupními a výstupními argumenty najdete v tématu Přetížení Invoke se stejnými parametry jako toto přetížení bez intervalu časového limitu.

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který obsahuje dvě WriteLine aktivity a aktivitu nakonfigurovanou Delay s minutou Duration . Tento pracovní postup je vyvolán dvakrát; poprvé s intervalem časového limitu dvě minuty a podruhé s časovým limitem 30 sekund. První pracovní postup se úspěšně dokončí, ale druhý ne a TimeoutException vyvolá se.

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

Příklad použití Invoke s výstupními argumenty, viz přetížení Invoke se stejnými parametry jako toto přetížení bez intervalu časového limitu.

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Divide aktivity, která má dva vstupní argumenty a dva výstupní argumenty. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Při volání se Invoke vrátí každý výstupní argument ve slovníku outputs , který je také označený názvem argumentu.

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

Pokud se pracovní postup odvozuje od ActivityWithResult, například CodeActivity<TResult> nebo Activity<TResult>, a kromě správně definovaného Result výstupního Invokeargumentu existují výstupní argumenty, musí se k načtení dalších argumentů použít jiné než obecné přetížení typu , jako je tento. K tomu musí být definice pracovního postupu předaná do Invoke typu Activity. V tomto příkladu Divide je aktivita odvozena od CodeActivity<int>, ale je deklarována tak Activity , aby se použilo toto přetížení Invoke, které vrací slovník argumentů místo jedné návratové hodnoty.

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který obsahuje dvě WriteLine aktivity a aktivitu nakonfigurovanou Delay s minutou Duration . Tento pracovní postup je vyvolán dvakrát; poprvé s intervalem časového limitu dvě minuty a podruhé s časovým limitem 30 sekund. První pracovní postup se úspěšně dokončí, ale druhý ne a TimeoutException vyvolá se a zobrazí se následující zpráva.

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

Příklad použití Invoke se vstupními a výstupními argumenty najdete v tématu Přetížení Invoke se stejnými parametry jako toto přetížení bez intervalu časového limitu.

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Divide aktivity, která má dva vstupní argumenty a dva výstupní argumenty. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Při volání se Invoke vrátí každý výstupní argument ve slovníku outputs , který je také označený názvem argumentu.

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

Pokud se pracovní postup odvozuje od ActivityWithResult, například CodeActivity<TResult> nebo Activity<TResult>, a kromě správně definovaného Result výstupního Invokeargumentu existují výstupní argumenty, musí se k načtení dalších argumentů použít jiné než obecné přetížení typu , jako je tento. K tomu musí být definice pracovního postupu předaná do WorkflowInvoker konstruktoru typu Activity. V tomto příkladu Divide je aktivita odvozena od CodeActivity<int>, ale je deklarována tak Activity , aby se použilo toto přetížení Invoke, které vrací slovník argumentů místo jedné návratové hodnoty.

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné DiceRoll aktivity. Aktivita DiceRoll má dva výstupní argumenty, které představují výsledky operace hodu kostkou. Při volání se Invoke vrátí každý výstupní argument ve slovníku outputs s klíčem podle názvu argumentu.

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

Pokud kořenová aktivita pracovního postupu neobsahuje žádné výstupní argumenty nebo je hostitel nepotřebuje, můžete je ignorovat. Následující příklad vyvolá pracovní postup, který se skládá z jedné WriteLine aktivity, která nemá žádné výstupní argumenty.

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

WorkflowInvoker.Invoke(wf);

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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)

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné DiceRoll aktivity. Aktivita DiceRoll má dva výstupní argumenty, které představují výsledky operace hodu kostkou. Při volání se Invoke vrátí každý výstupní argument ve slovníku outputs s klíčem podle názvu argumentu. Pracovní postup je vyvolán dvakrát pomocí definice pracovního postupu předané konstruktoru WorkflowInvoker .

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

Pokud kořenová aktivita pracovního postupu neobsahuje žádné výstupní argumenty nebo je hostitel nepotřebuje, můžete je ignorovat. Následující příklad vyvolá pracovní postup, který se skládá z jedné WriteLine aktivity, která nemá žádné výstupní argumenty.

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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)

Parametry

Návraty

Slovník kořenových aktivit OutArgument a InOutArgument hodnot s klíčem podle názvu argumentu, který představuje výstupy pracovního postupu.

Příklady

Následující příklad vyvolá pracovní postup, který obsahuje dvě WriteLine aktivity a aktivitu nakonfigurovanou Delay s minutou Duration . Tento pracovní postup je vyvolán dvakrát; poprvé s intervalem časového limitu dvě minuty a podruhé s časovým limitem 30 sekund. První pracovní postup se úspěšně dokončí, ale druhý ne a TimeoutException vyvolá se a zobrazí se následující zpráva.

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

Příklad použití Invoke s výstupními argumenty, viz přetížení Invoke se stejnými parametry jako toto přetížení bez intervalu časového limitu.

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

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

Parametry typu

Parametry

Návraty

Hodnota typu TResult s výsledkem provedení aktivity.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Add aktivity, která má dva vstupní argumenty a protože odvozuje z CodeActivity<int> něj jeden dobře definovaný Result výstupní argument. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Když volání Invoke vrátí, vrátí se hodnota výstupního argumentu Result .

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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

Parametry typu

Parametry

Návraty

Hodnota typu TResult s výsledkem provedení aktivity.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Add aktivity, která má dva vstupní argumenty a protože odvozuje z CodeActivity<int> něj jeden dobře definovaný Result výstupní argument. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Když volání Invoke vrátí, vrátí se hodnota výstupního argumentu Result .

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud chcete nakonfigurovat interval časového limitu, ve kterém se musí pracovní postup dokončit, použijte jedno z Invoke přetížení, které zabírají 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

Parametry typu

Parametry

Návraty

Hodnota typu TResult s výsledkem provedení aktivity.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Add aktivity, která má dva vstupní argumenty a protože odvozuje z CodeActivity<int> něj jeden dobře definovaný Result výstupní argument. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Když volání Invoke vrátí, vrátí se hodnota výstupního argumentu Result .

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.

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

Parametry typu

Parametry

Návraty

Hodnota typu TResult s výsledkem provedení aktivity.

Příklady

Následující příklad vyvolá pracovní postup, který se skládá z jedné Add aktivity, která má dva vstupní argumenty a protože odvozuje z CodeActivity<int> něj jeden dobře definovaný Result výstupní argument. Při vyvolání pracovního postupu se předá slovník, arguments který obsahuje hodnoty pro každý vstupní argument, který je označen názvem argumentu. Když volání Invoke vrátí, vrátí se hodnota výstupního argumentu Result .

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

Poznámky

Tato metoda blokuje, dokud se pracovní postup nedokončil, včetně doby nečinnosti. Veškeré spuštění pracovního postupu je zaručeno na vyvolání vlákna. Pokud se pracovní postup nedokončí v zadaném intervalu časového limitu, pracovní postup se přeruší a TimeoutException vyvolá se.