WorkflowInvoker.InvokeAsync Método

Referencia

Definición

Espacio de nombres:: System.Activities

Ensamblado:: System.Activities.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos.

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.
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.
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.
InvokeAsync()	Invoca un flujo de trabajo de forma asincrónica.
InvokeAsync(Object)	Invoca un flujo de trabajo de forma asincrónica usando el identificador único especificado.
InvokeAsync(IDictionary<String,Object>)	Invoca un flujo de trabajo de forma asincrónica utilizando la IDictionary<TKey,TValue> de parámetros de entrada especificada.
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.
InvokeAsync(TimeSpan)	Invoca un flujo de trabajo de forma asincrónica con el intervalo de tiempo de espera especificado.

Comentarios

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento 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.

Este método invoca de forma asincrónica un flujo de trabajo usando el modelo de diseño asincrónico basado en eventos. Para más información, consulte Event-based Asynchronous Pattern Overview (Introducción al patrón asincrónico basado en eventos).

InvokeAsync(TimeSpan, Object)

Invoca de forma asincrónica un flujo de trabajo con el intervalo de tiempo de espera especificado y un identificador único.

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.

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.

Ejemplos

En el siguiente ejemplo se invoca un flujo de trabajo formado por una actividad LongRunningDiceRoll. La actividad LongRunningDiceRoll tiene dos argumentos de salida que representan los resultados de la operación de tirar los dados. Cuando se completa el flujo de trabajo, se recuperan en el controlador del evento InvokeCompleted.

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. Si userState no es único, se produce ArgumentException. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.

Para recibir una notificación cuando se complete el flujo de trabajo, controle el evento 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.

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. 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.

Se aplica a

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.

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.

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.

Ejemplos

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

Nota

Este método almacena en la tarea que devuelve todas las excepciones que no son de uso que puede producir el homólogo sincrónico del método. Si se almacena una excepción en la tarea devuelta, esa excepción se producirá cuando se espere a la tarea. Las excepciones de uso, como ArgumentException, se siguen produciendo de forma sincrónica. Para ver las excepciones almacenadas, vea las excepciones producidas por Invoke(IDictionary<String,Object>, TimeSpan).

Se aplica a

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.

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.

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.

Ejemplos

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

Se aplica a

InvokeAsync()

Invoca un flujo de trabajo de forma asincrónica.

public:
 void InvokeAsync();

public void InvokeAsync ();

member this.InvokeAsync : unit -> unit

Public Sub InvokeAsync ()

Ejemplos

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

Se aplica a

InvokeAsync(Object)

Invoca un flujo de trabajo de forma asincrónica usando el identificador único especificado.

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.

Ejemplos

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. Si el parámetro userState no es único, se produce ArgumentException. El parámetro userState se usa para identificar el flujo de trabajo del evento InvokeCompleted y para cancelarlo mediante el método CancelAsync.

Se aplica a

InvokeAsync(IDictionary<String,Object>)

Invoca un flujo de trabajo de forma asincrónica utilizando la IDictionary<TKey,TValue> de parámetros de entrada especificada.

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.

Ejemplos

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

Este método almacena en la tarea que devuelve todas las excepciones que no son de uso que puede producir el homólogo sincrónico del método. Si se almacena una excepción en la tarea devuelta, esa excepción se producirá cuando se espere a la tarea. Las excepciones de uso, como ArgumentException, se siguen produciendo de forma sincrónica. Para ver las excepciones almacenadas, consulte las excepciones producidas por Invoke(IDictionary<String,Object>).

Se aplica a

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.

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.

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.

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.

Ejemplos

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

Nota

Se aplica a

InvokeAsync(TimeSpan)

Invoca un flujo de trabajo de forma asincrónica con el intervalo de tiempo de espera especificado.

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.

Ejemplos

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

Nota

Este método almacena en la tarea que devuelve todas las excepciones que no son de uso que puede producir el homólogo sincrónico del método. Si se almacena una excepción en la tarea devuelta, se producirá esa excepción cuando se espere la tarea. Las excepciones de uso, como ArgumentException, se siguen iniciando de forma sincrónica. Para ver las excepciones almacenadas, consulte las excepciones producidas por Invoke(TimeSpan).

Se aplica a

Compartir a través de

WorkflowInvoker.InvokeAsync Método

Definición

Sobrecargas

Comentarios

InvokeAsync(TimeSpan, Object)

Parámetros

Ejemplos

Comentarios

Se aplica a

InvokeAsync(IDictionary<String,Object>, TimeSpan)

Parámetros

Ejemplos

Comentarios

Se aplica a

InvokeAsync(IDictionary<String,Object>, Object)

Parámetros

Ejemplos

Comentarios

Se aplica a

InvokeAsync()

Ejemplos

Comentarios

Se aplica a

InvokeAsync(Object)

Parámetros

Ejemplos

Comentarios

Se aplica a

InvokeAsync(IDictionary<String,Object>)

Parámetros

Ejemplos

Comentarios

Se aplica a

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

Parámetros

Ejemplos

Comentarios

Se aplica a

InvokeAsync(TimeSpan)

Parámetros

Ejemplos

Comentarios

Se aplica a

Recursos adicionales