Exposición de datos con CacheMetadata

Antes de ejecutar una actividad, el tiempo de ejecución del 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 todos los argumentos públicos, variables y actividades secundarias expuestas por la actividad en el momento en que se ejecuta; Si la actividad necesita proporcionar más información al tiempo de ejecución que este (como miembros privados o actividades que la actividad va a programar), este método se puede invalidar para proporcionarla.

Comportamiento predeterminado de CacheMetadata

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

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

• Variable o cualquier subclase de ahí: estos miembros se exponen al tiempo de ejecución como variables públicas.

• Activity o cualquier subclase de ella: estos miembros se exponen al entorno de ejecución 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 entorno de ejecución como delegados públicos.

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

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

• ICollection de tipo ActivityDelegate: todos los elementos de la colección se exponen al entorno de ejecución 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 expongan los argumentos.

Sobrescribir CacheMetadata para proporcionar información durante la ejecución

En el fragmento de código siguiente se muestra cómo agregar información sobre los miembros a los metadatos de una actividad durante la ejecución del CacheMetadata método . Tenga en cuenta que se llama a la base del método para almacenar en 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 esto es que las actividades están pensadas para ejecutarse más 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.

El siguiente fragmento de código 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);
    }
}