Exponer datos con CacheMetadata

Antes de ejecutar una actividad, el runtime de flujo de trabajo obtiene toda la información sobre la actividad que necesita para mantener su ejecución. El runtime de flujo de trabajo obtiene esta información durante la ejecución del método CacheMetadata. La implementación predeterminada de este método proporciona al runtime todas las actividades secundarias, variables y argumentos públicos expuestos por la actividad en el momento de su ejecución; si la actividad necesita proporcionar más información al runtime que la especificada (como miembros privados o actividades que va a programar la actividad), este método se puede reemplazar para proporcionarla.

Comportamiento de CacheMetadata predeterminado

La implementación predeterminada de CacheMetadata para las actividades que derivan de NativeActivity procesa los tipos de métodos siguientes de las maneras siguientes:

• InArgument<T>, OutArgument<T> o InOutArgument<T> (argumentos genéricos): estos argumentos se exponen al runtime como argumentos con un nombre y un tipo iguales al nombre y el tipo de la propiedad expuesta, la dirección de argumento apropiada y algunos datos de validación.

• Variable o cualquier subclase de ella: estos miembros se exponen al runtime como variables públicas.

• Activity o cualquier subclase de ella: estos miembros se exponen al runtime como actividades secundarias públicas. El comportamiento predeterminado se puede implementar explícitamente llamando al método AddImportedChild y pasando la actividad secundaria.

• ActivityDelegate o cualquier subclase de ella: estos miembros se exponen al runtime como delegados públicos.

• ICollection de tipo Variable: todos los elementos de la colección se exponen al runtime como variables públicas.

• ICollection de tipo Activity: todos los elementos de la colección se exponen al runtime como elementos secundarios públicos.

• ICollection de tipo ActivityDelegate: todos los elementos de la colección se exponen al runtime como delegados públicos.

El método CacheMetadata para las actividades que derivan de Activity, CodeActivity y AsyncCodeActivity también funciona como en los casos anteriores, exceptuando las diferencias siguientes:

• Las clases que derivan de Activity no pueden programar actividades secundarias ni delegados, por lo que dichos miembros se exponen como elementos secundarios y delegados importados.

• Las clases que derivan de CodeActivity y AsyncCodeActivity no admiten variables, elementos secundarios o delegados, por lo que solo se expondrán argumentos.

Reemplazar CacheMetadata para proporcionar información al runtime

El siguiente fragmento de código muestra cómo agregar información sobre miembros a los metadatos de una actividad durante la ejecución del método CacheMetadata. Observe que se llama a la base del método para almacenar en memoria caché todos los datos públicos sobre la actividad.

protected override void CacheMetadata(NativeActivityMetadata metadata)
{
    base.CacheMetadata(metadata);
    metadata.AddImplementationChild(this._writeLine);
    metadata.AddVariable(this._myVariable);
    metadata.AddImplementationVariable(this._myImplementationVariable);

    RuntimeArgument argument = new RuntimeArgument("MyArgument", ArgumentDirection.In, typeof(SomeType));
    metadata.Bind(argument, this.SomeName);
    metadata.AddArgument(argument);
}

Utilizar CacheMetadata para exponer los elementos secundarios de implementación

Para pasar datos a actividades secundarias que van a ser programadas por una actividad utilizando variables, es necesario agregar las variables como variables de implementación; las variables públicas no pueden tener establecidos sus valores de esta manera. La razón de ello es que las actividades están previstas para ser ejecutadas como implementaciones de funciones (que tienen parámetros), en lugar de clases encapsuladas (que tienen propiedades). Sin embargo, hay situaciones en que los argumentos se deben establecer explícitamente, como cuando se utiliza ScheduleActivity, ya que la actividad programada no tiene acceso a los argumentos de la actividad principal de la manera que una actividad secundaria lo tendría.

En el fragmento de código siguiente, se muestra cómo pasar un argumento de una actividad nativa a una actividad programada mediante CacheMetadata.

public sealed class ChildActivity : NativeActivity
{
    public WriteLine _writeLine;
    public InArgument<string> Message { get; set; }
    private Variable<string> MessageVariable { get; set; }
    public ChildActivity()
    {
        MessageVariable = new Variable<string>();
        _writeLine = new WriteLine
        {
            Text = new InArgument<string>(MessageVariable),
        };
    }
    protected override void CacheMetadata(NativeActivityMetadata metadata)
    {
        base.CacheMetadata(metadata);
        metadata.AddImplementationVariable(this.MessageVariable);
        metadata.AddImplementationChild(this._writeLine);
    }
    protected override void Execute(NativeActivityContext context)
    {
        string configuredMessage = context.GetValue(Message);
        context.SetValue(MessageVariable, configuredMessage);
        context.ScheduleActivity(this._writeLine);
    }
}