WorkflowInvoker.Invoke Método

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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo que contiene dos actividades de la clase WriteLine y una actividad de la clase Delay configurada con una propiedad Duration de un minuto. Este flujo de trabajo se invoca dos veces; la primera vez con un intervalo de tiempo de espera de dos minutos y la segunda con un intervalo de tiempo de espera de 30 segundos. El primer flujo de trabajo se completa correctamente, pero el segundo no y se produce una excepción 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);
}

Para obtener un ejemplo de uso Invoke con argumentos de entrada y salida, consulte la sobrecarga de Invoke con los mismos parámetros que esta sobrecarga sin el intervalo de tiempo de espera.

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo que contiene dos actividades de la clase WriteLine y una actividad de la clase Delay configurada con una propiedad Duration de un minuto. Este flujo de trabajo se invoca dos veces; la primera vez con un intervalo de tiempo de espera de dos minutos y la segunda con un intervalo de tiempo de espera de 30 segundos. El primer flujo de trabajo se completa correctamente, pero el segundo no y se produce una excepción 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);
}

Para obtener un ejemplo de uso Invoke con argumentos de salida, consulte la sobrecarga de Invoke con los mismos parámetros que esta sobrecarga sin el intervalo de tiempo de espera.

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad Divide que tiene dos argumentos de entrada y dos argumentos de salida. Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando la llamada a Invoke devuelve resultados, cada uno de los argumentos de salida se devuelve en el diccionario outputs, ordenados por nombre de argumento.

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

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

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

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

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

int dividend = 500;
int divisor = 36;

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

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

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

Si el flujo de trabajo deriva de ActivityWithResult, como CodeActivity<TResult> o Activity<TResult>, y hay argumentos de salida además del argumento de salida bien definido Result , se debe usar una sobrecarga no genérica de Invoke, como esta, para recuperar los argumentos adicionales. Para ello, la definición de flujo de trabajo pasada a Invoke debe ser de tipo Activity. En este ejemplo, la Divide actividad deriva de CodeActivity<int>, pero se declara como Activity para que se use esta sobrecarga de Invoke, que devuelve un diccionario de argumentos en lugar de un único valor devuelto.

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

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo que contiene dos actividades de la clase WriteLine y una actividad de la clase Delay configurada con una propiedad Duration de un minuto. Este flujo de trabajo se invoca dos veces; la primera vez con un intervalo de tiempo de espera de dos minutos y la segunda con un intervalo de tiempo de espera de 30 segundos. El primer flujo de trabajo se completa correctamente, pero el segundo no y se produce una excepción TimeoutException, mostrándose además el siguiente mensaje.

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

Para obtener un ejemplo de uso Invoke con argumentos de entrada y salida, consulte la sobrecarga de Invoke con los mismos parámetros que esta sobrecarga sin el intervalo de tiempo de espera.

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad Divide que tiene dos argumentos de entrada y dos argumentos de salida. Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando la llamada a Invoke devuelve resultados, cada uno de los argumentos de salida se devuelve en el diccionario outputs, ordenados por nombre de argumento.

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

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

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

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

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

int dividend = 500;
int divisor = 36;

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

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

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

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

Si el flujo de trabajo deriva de ActivityWithResult, como CodeActivity<TResult> o Activity<TResult>, y hay argumentos de salida además del argumento de salida bien definido Result , se debe usar una sobrecarga no genérica de Invoke, como esta, para recuperar los argumentos adicionales. Para ello, la definición de flujo de trabajo pasada al WorkflowInvoker constructor debe ser de tipo Activity. En este ejemplo, la Divide actividad deriva de CodeActivity<int>, pero se declara como Activity para que se use esta sobrecarga de Invoke, que devuelve un diccionario de argumentos en lugar de un único valor devuelto.

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

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad DiceRoll. La actividad DiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados. Cuando la llamada al método Invoke devuelve resultados, cada uno de los argumentos de salida se devuelve en el diccionario de salidas, ordenados por nombre de argumento.

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

    static Random r = new Random();

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

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

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

Si la actividad raíz del flujo de trabajo no tiene argumentos de salida o no los necesita el host, se pueden omitir. En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad de la clase WriteLine que no tiene argumentos de salida.

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

WorkflowInvoker.Invoke(wf);

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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)

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad DiceRoll. La actividad DiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados. Cuando la llamada al método Invoke devuelve resultados, cada uno de los argumentos de salida se devuelve en el diccionario de salidas, ordenados por nombre de argumento. El flujo de trabajo se invoca dos veces mediante la definición de flujo de trabajo que se pasa al WorkflowInvoker constructor.

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

    static Random r = new Random();

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

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

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

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

outputs = invoker.Invoke();

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

Si la actividad raíz del flujo de trabajo no tiene argumentos de salida o no los necesita el host, se pueden omitir. En el siguiente ejemplo se invoca un flujo de trabajo formado por una sola actividad de la clase WriteLine que no tiene argumentos de salida.

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

WorkflowInvoker invoker = new WorkflowInvoker(wf);

invoker.Invoke();

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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)

Parámetros

Devoluciones

Diccionario de los valores OutArgument e InOutArgument de la actividad raíz ordenados por nombre de argumento que representan las salidas del flujo de trabajo.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo que contiene dos actividades de la clase WriteLine y una actividad de la clase Delay configurada con una propiedad Duration de un minuto. Este flujo de trabajo se invoca dos veces; la primera vez con un intervalo de tiempo de espera de dos minutos y la segunda con un intervalo de tiempo de espera de 30 segundos. El primer flujo de trabajo se completa correctamente, pero el segundo no y se produce una excepción TimeoutException, mostrándose además el siguiente mensaje.

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

Para obtener un ejemplo del uso Invoke con argumentos de salida, consulte la sobrecarga de Invoke con los mismos parámetros que esta sobrecarga sin el intervalo de tiempo de espera.

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción 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

Parámetros de tipo

Parámetros

Devoluciones

Valor de tipo TResult que tiene el resultado de la ejecución de la actividad.

Ejemplos

En el ejemplo siguiente se invoca un flujo de trabajo que consta de una sola Add actividad que tiene dos argumentos de entrada y, dado que se deriva de CodeActivity<int> él, tiene un argumento de salida bien definido Result . Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando se devuelve la llamada a Invoke , se devuelve el valor del Result argumento 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);

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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

Parámetros de tipo

Parámetros

Devoluciones

Valor de tipo TResult que tiene el resultado de la ejecución de la actividad.

Ejemplos

En el ejemplo siguiente se invoca un flujo de trabajo que consta de una sola Add actividad que tiene dos argumentos de entrada y, dado que se deriva de CodeActivity<int> él, tiene un argumento de salida bien definido Result . Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando se devuelve la llamada a Invoke , se devuelve el valor del Result argumento 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);

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas Invoke que toman una estructura 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

Parámetros de tipo

Parámetros

Devoluciones

Valor de tipo TResult que tiene el resultado de la ejecución de la actividad.

Ejemplos

En el ejemplo siguiente se invoca un flujo de trabajo que consta de una sola Add actividad que tiene dos argumentos de entrada y, dado que se deriva de CodeActivity<int> él, tiene un argumento de salida bien definido Result . Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando se devuelve la llamada a Invoke , se devuelve el valor del Result argumento 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);

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción 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

Parámetros de tipo

Parámetros

Devoluciones

Valor de tipo TResult que tiene el resultado de la ejecución de la actividad.

Ejemplos

En el ejemplo siguiente se invoca un flujo de trabajo que consta de una sola Add actividad que tiene dos argumentos de entrada y, dado que se deriva de CodeActivity<int> él, tiene un argumento de salida bien definido Result . Cuando se invoca el flujo de trabajo, se pasa el diccionario de arguments que contiene los valores de cada argumento de entrada, ordenados por nombre de argumento. Cuando se devuelve la llamada a Invoke , se devuelve el valor del Result argumento 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);

Comentarios

Este método se bloquea hasta que se ha completado el flujo de trabajo, incluido el tiempo de inactividad. Se garantiza que toda la ejecución del flujo de trabajo se realiza en el subproceso que lo invoca. Si el flujo de trabajo no se completa dentro del intervalo de tiempo de espera especificado, se anula el flujo de trabajo y se produce una excepción TimeoutException.