WorkflowInvoker.InvokeAsync Método

Definición

Invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.Invokes a workflow asynchronously using the event-based asynchronous design pattern.

Sobrecargas

InvokeAsync(TimeSpan, Object)

Invoca de forma asincrónica un flujo de trabajo con el intervalo de tiempo de espera especificado y un identificador único.Invokes a workflow asynchronously with the specified time-out interval and a unique identifier.

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Invoca de forma asincrónica un flujo de trabajo con la interfaz IDictionary<TKey,TValue> de parámetros de entrada y el intervalo de tiempo de espera especificados.Invokes a workflow asynchronously with the specified IDictionary<TKey,TValue> of input parameters and the specified time-out interval.

InvokeAsync(IDictionary<String,Object>, Object)

Invoca un flujo de trabajo de forma asincrónica usando la interfaz IDictionary<TKey,TValue> de parámetros de entrada especificada y un identificador único.Invokes a workflow asynchronously using the specified IDictionary<TKey,TValue> of input parameters and a unique identifier.

InvokeAsync()

Invoca un flujo de trabajo de forma asincrónica.Invokes a workflow asynchronously.

InvokeAsync(Object)

Invoca un flujo de trabajo de forma asincrónica usando el identificador único especificado.Invokes a workflow asynchronously using the specified unique identifier.

InvokeAsync(IDictionary<String,Object>)

Invoca un flujo de trabajo de forma asincrónica utilizando la IDictionary<TKey,TValue> de parámetros de entrada especificada.Invokes a workflow asynchronously using the specified IDictionary<TKey,TValue> of input parameters.

InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)

Invoca de forma asincrónica un flujo de trabajo con la interfaz IDictionary<TKey,TValue> de parámetros de entrada especificada, el intervalo de tiempo de espera especificado y un identificador único.Invokes a workflow asynchronously with the specified IDictionary<TKey,TValue> of input parameters, the specified time-out interval, and a unique identifier.

InvokeAsync(TimeSpan)

Invoca un flujo de trabajo de forma asincrónica con el intervalo de tiempo de espera especificado.Invokes a workflow asynchronously with the specified time-out interval.

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas InvokeAsync que toman una estructura TimeSpan.To configure a time-out interval in which the workflow must complete, use one of the InvokeAsync overloads that take a TimeSpan.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(TimeSpan, Object)

Invoca de forma asincrónica un flujo de trabajo con el intervalo de tiempo de espera especificado y un identificador único.Invokes a workflow asynchronously with the specified time-out interval and a unique identifier.

public:
 void InvokeAsync(TimeSpan timeout, System::Object ^ userState);
public void InvokeAsync (TimeSpan timeout, object userState);
member this.InvokeAsync : TimeSpan * obj -> unit
Public Sub InvokeAsync (timeout As TimeSpan, userState As Object)

Parámetros

timeout
TimeSpan

Intervalo de tiempo en el que se debe completar el flujo de trabajo antes de quedar anulado y de que se produzca una excepción TimeoutException.The interval in which the workflow must complete before it is aborted and a TimeoutException is thrown.

userState
Object

Objeto proporcionado por el usuario que se utiliza para distinguir esta operación concreta de invocación asincrónica de otras operaciones de invocación asincrónicas actuales.A user-provided object used to distinguish this particular asynchronous invoke operation from other current asynchronous invoke operations.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

El parámetro userState debe ser único para todas las operaciones InvokeAsync que se estén ejecutando en ese momento para la actividad actual.The userState parameter must be unique across all currently running InvokeAsync operations for the current activity. Si userState no es único, se produce ArgumentException.If userState is not unique, an ArgumentException is thrown. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.userState is used to identify the workflow in InvokeCompleted, and to cancel the workflow using CancelAsync.

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. 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.If the workflow does not complete within the specified time-out interval the workflow is aborted and a TimeoutException is thrown.

Nota

La excepción TimeoutException solo se produce si se agota el tiempo de espera y el flujo de trabajo queda inactivo durante la ejecución.The TimeoutException is only thrown if the time-out interval elapses and the workflow becomes idle during execution. Un flujo de trabajo que tarda en completarse más tiempo que el especificado por el intervalo de tiempo de espera se completa correctamente si el flujo de trabajo no queda inactivo.A workflow that takes longer than the specified time-out interval to complete completes successfully if the workflow does not become idle.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Invoca de forma asincrónica un flujo de trabajo con la interfaz IDictionary<TKey,TValue> de parámetros de entrada y el intervalo de tiempo de espera especificados.Invokes a workflow asynchronously with the specified IDictionary<TKey,TValue> of input parameters and the specified time-out interval.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout);
public void InvokeAsync (System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout);
member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan -> unit
Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan)

Parámetros

inputs
IDictionary<String,Object>

El diccionario de parámetros de entrada para el flujo de trabajo, ordenados por nombre de argumento.The dictionary of input parameters to the workflow, keyed by argument name.

timeout
TimeSpan

Intervalo de tiempo en el que se debe completar el flujo de trabajo antes de quedar anulado y de que se produzca una excepción TimeoutException.The interval in which the workflow must complete before it is aborted and a TimeoutException is thrown.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. 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.If the workflow does not complete within the specified time-out interval the workflow is aborted and a TimeoutException is thrown.

Nota

La excepción TimeoutException solo se produce si se agota el tiempo de espera y el flujo de trabajo queda inactivo durante la ejecución.The TimeoutException is only thrown if the time-out interval elapses and the workflow becomes idle during execution. Un flujo de trabajo que tarda en completarse más tiempo que el especificado por el intervalo de tiempo de espera se completa correctamente si el flujo de trabajo no queda inactivo.A workflow that takes longer than the specified time-out interval to complete completes successfully if the workflow does not become idle.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(IDictionary<String,Object>, Object)

Invoca un flujo de trabajo de forma asincrónica usando la interfaz IDictionary<TKey,TValue> de parámetros de entrada especificada y un identificador único.Invokes a workflow asynchronously using the specified IDictionary<TKey,TValue> of input parameters and a unique identifier.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, System::Object ^ userState);
public void InvokeAsync (System.Collections.Generic.IDictionary<string,object> inputs, object userState);
member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * obj -> unit
Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), userState As Object)

Parámetros

inputs
IDictionary<String,Object>

El diccionario de parámetros de entrada para el flujo de trabajo, ordenados por nombre de argumento.The dictionary of input parameters to the workflow, keyed by argument name.

userState
Object

Objeto proporcionado por el usuario que se utiliza para distinguir esta operación concreta de invocación asincrónica de otras operaciones de invocación asincrónicas actuales.A user-provided object used to distinguish this particular asynchronous invoke operation from other current asynchronous invoke operations.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

El parámetro userState debe ser único para todas las operaciones InvokeAsync que se estén ejecutando en ese momento para la actividad actual.The userState parameter must be unique across all currently running InvokeAsync operations for the current activity. Si userState no es único, se produce ArgumentException.If userState is not unique, an ArgumentException is thrown. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.userState is used to identify the workflow in InvokeCompleted, and to cancel the workflow using CancelAsync.

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas InvokeAsync que toman una estructura TimeSpan.To configure a time-out interval in which the workflow must complete, use one of the InvokeAsync overloads that take a TimeSpan.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync()

Invoca un flujo de trabajo de forma asincrónica.Invokes a workflow asynchronously.

public:
 void InvokeAsync();
public void InvokeAsync ();
member this.InvokeAsync : unit -> unit
Public Sub InvokeAsync ()

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas InvokeAsync que toman una estructura TimeSpan.To configure a time-out interval in which the workflow must complete, use one of the InvokeAsync overloads that take a TimeSpan.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(Object)

Invoca un flujo de trabajo de forma asincrónica usando el identificador único especificado.Invokes a workflow asynchronously using the specified unique identifier.

public:
 void InvokeAsync(System::Object ^ userState);
public void InvokeAsync (object userState);
member this.InvokeAsync : obj -> unit
Public Sub InvokeAsync (userState As Object)

Parámetros

userState
Object

Objeto proporcionado por el usuario que se utiliza para distinguir esta operación concreta de invocación asincrónica de otras operaciones de invocación asincrónicas actuales.A user-provided object used to distinguish this particular asynchronous invoke operation from other current asynchronous invoke operations.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

El parámetro userState debe ser único para todas las operaciones InvokeAsync que se estén ejecutando en ese momento para la actividad actual.The userState parameter must be unique across all currently running InvokeAsync operations for the current activity. Si el parámetro userState no es único, se produce ArgumentException.If the userState parameter is not unique, an ArgumentException is thrown. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.userState is used to identify the workflow in InvokeCompleted, and to cancel the workflow using CancelAsync.

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas InvokeAsync que toman una estructura TimeSpan.To configure a time-out interval in which the workflow must complete, use one of the InvokeAsync overloads that take a TimeSpan.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(IDictionary<String,Object>)

Invoca un flujo de trabajo de forma asincrónica utilizando la IDictionary<TKey,TValue> de parámetros de entrada especificada.Invokes a workflow asynchronously using the specified IDictionary<TKey,TValue> of input parameters.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs);
public void InvokeAsync (System.Collections.Generic.IDictionary<string,object> inputs);
member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> -> unit
Public Sub InvokeAsync (inputs As IDictionary(Of String, Object))

Parámetros

inputs
IDictionary<String,Object>

El diccionario de parámetros de entrada para el flujo de trabajo, ordenados por nombre de argumento.The dictionary of input parameters to the workflow, keyed by argument name.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. Para configurar un intervalo de tiempo de espera en el que se debe completar el flujo de trabajo, use una de las sobrecargas InvokeAsync que toman una estructura TimeSpan.To configure a time-out interval in which the workflow must complete, use one of the InvokeAsync overloads that take a TimeSpan.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(IDictionary<String,Object>, TimeSpan, Object)

Invoca de forma asincrónica un flujo de trabajo con la interfaz IDictionary<TKey,TValue> de parámetros de entrada especificada, el intervalo de tiempo de espera especificado y un identificador único.Invokes a workflow asynchronously with the specified IDictionary<TKey,TValue> of input parameters, the specified time-out interval, and a unique identifier.

public:
 void InvokeAsync(System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ inputs, TimeSpan timeout, System::Object ^ userState);
public void InvokeAsync (System.Collections.Generic.IDictionary<string,object> inputs, TimeSpan timeout, object userState);
member this.InvokeAsync : System.Collections.Generic.IDictionary<string, obj> * TimeSpan * obj -> unit
Public Sub InvokeAsync (inputs As IDictionary(Of String, Object), timeout As TimeSpan, userState As Object)

Parámetros

inputs
IDictionary<String,Object>

El diccionario de parámetros de entrada para el flujo de trabajo, ordenados por nombre de argumento.The dictionary of input parameters to the workflow, keyed by argument name.

timeout
TimeSpan

Intervalo de tiempo en el que se debe completar el flujo de trabajo antes de quedar anulado y de que se produzca una excepción TimeoutException.The interval in which the workflow must complete before it is aborted and a TimeoutException is thrown.

userState
Object

Objeto proporcionado por el usuario que se utiliza para distinguir esta operación concreta de invocación asincrónica de otras operaciones de invocación asincrónicas actuales.A user-provided object used to distinguish this particular asynchronous invoke operation from other current asynchronous invoke operations.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

El parámetro userState debe ser único para todas las operaciones InvokeAsync que se estén ejecutando en ese momento para la actividad actual.The userState parameter must be unique across all currently running InvokeAsync operations for the current activity. Si userState no es único, se produce ArgumentException.If userState is not unique, an ArgumentException is thrown. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.userState is used to identify the workflow in InvokeCompleted, and to cancel the workflow using CancelAsync.

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. 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.If the workflow does not complete within the specified time-out interval the workflow is aborted and a TimeoutException is thrown.

Nota

La excepción TimeoutException solo se produce si se agota el tiempo de espera y el flujo de trabajo queda inactivo durante la ejecución.The TimeoutException is only thrown if the time-out interval elapses and the workflow becomes idle during execution. Un flujo de trabajo que tarda en completarse más tiempo que el especificado por el intervalo de tiempo de espera se completa correctamente si el flujo de trabajo no queda inactivo.A workflow that takes longer than the specified time-out interval to complete completes successfully if the workflow does not become idle.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

InvokeAsync(TimeSpan)

Invoca un flujo de trabajo de forma asincrónica con el intervalo de tiempo de espera especificado.Invokes a workflow asynchronously with the specified time-out interval.

public:
 void InvokeAsync(TimeSpan timeout);
public void InvokeAsync (TimeSpan timeout);
member this.InvokeAsync : TimeSpan -> unit
Public Sub InvokeAsync (timeout As TimeSpan)

Parámetros

timeout
TimeSpan

Intervalo de tiempo en el que se debe completar el flujo de trabajo antes de quedar anulado y de que se produzca una excepción TimeoutException.The interval in which the workflow must complete before it is aborted and a TimeoutException is thrown.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll.The following example invokes a workflow consisting of a LongRunningDiceRoll activity. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados.The LongRunningDiceRoll activity has two output arguments that represent the results of the dice roll operation. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.When the workflow completes these are retrieved in the InvokeCompleted handler.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}
AutoResetEvent syncEvent = new AutoResetEvent(false);

WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

invoker.InvokeCompleted += delegate(object sender, InvokeCompletedEventArgs args)
{
    if (args.Cancelled == true)
    {
        Console.WriteLine("Workflow was cancelled.");
    }
    else if (args.Error != null)
    {
        Console.WriteLine("Exception: {0}\n{1}",
            args.Error.GetType().FullName,
            args.Error.Message);
    }
    else
    {
        Console.WriteLine("The two dice are {0} and {1}.",
            args.Outputs["D1"], args.Outputs["D2"]);
    }

    syncEvent.Set();
};

invoker.InvokeAsync("InvokeAsync Example");

Console.WriteLine("Waiting for the workflow to complete.");

// Wait for the workflow to complete.
syncEvent.WaitOne();

Console.WriteLine("The workflow is complete.");

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento InvokeCompleted.To be notified when the workflow is complete, handle InvokeCompleted. 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.If the workflow does not complete within the specified time-out interval the workflow is aborted and a TimeoutException is thrown.

Nota

La excepción TimeoutException solo se produce si se agota el tiempo de espera y el flujo de trabajo queda inactivo durante la ejecución.The TimeoutException is only thrown if the time-out interval elapses and the workflow becomes idle during execution. Un flujo de trabajo que tarda en completarse más tiempo que el especificado por el intervalo de tiempo de espera se completa correctamente si el flujo de trabajo no queda inactivo.A workflow that takes longer than the specified time-out interval to complete completes successfully if the workflow does not become idle.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.This method invokes a workflow asynchronously using the event-based asynchronous design pattern. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).For more information, see Event-based Asynchronous Pattern Overview.

Se aplica a