Expondo dados com CacheMetadata

Antes de executar uma atividade, o tempo de execução do fluxo de trabalho obtém todas as informações sobre a atividade de que precisa para manter sua execução. A execução do fluxo de trabalho obtém essas informações durante o ambiente de execução do método CacheMetadata. A implementação padrão desse método fornece ao ambiente de execução todos os argumentos públicos, variáveis e atividades filho expostos pela atividade no momento em que ela é executada; Se a atividade precisar fornecer mais informações ao ambiente de execução do que isso (como membros privados ou atividades a serem agendadas pela atividade), esse método pode ser substituído para fornecê-lo.

Comportamento padrão de CacheMetadata

A implementação padrão de CacheMetadata para atividades que derivam de NativeActivity processa os seguintes tipos de métodos das seguintes maneiras:

• InArgument<T>, OutArgument<T>, ou InOutArgument<T> (argumentos genéricos): esses argumentos são expostos ao tempo de execução como argumentos com um nome e tipo iguais ao nome e tipo da propriedade exposta, a direção apropriada do argumento e alguns dados de validação.

• Variable ou qualquer subclasse do mesmo: esses membros são expostos ao tempo de execução como variáveis públicas.

• Activity ou qualquer subclasse do mesmo: Esses membros são expostos ao tempo de execução como atividades infantis públicas. O comportamento padrão pode ser implementado explicitamente chamando AddImportedChild, passando a atividade filha.

• ActivityDelegate ou qualquer subclasse do mesmo: esses membros são expostos ao tempo de execução como delegados públicos.

• ICollection do tipo Variable: Todos os elementos da coleção são expostos ao tempo de execução como variáveis públicas.

• ICollection do tipo Activity: Todos os elementos da coleção são expostos ao tempo de execução como filhos públicos.

• ICollection do tipo ActivityDelegate: Todos os elementos da coleção são expostos ao tempo de execução como delegados públicos.

O CacheMetadata para atividades que derivam de Activity, CodeActivitye AsyncCodeActivity também funcionam como acima, exceto para as seguintes diferenças:

• As classes que derivam de Activity não podem agendar atividades infantis ou delegados, de modo que tais membros são expostos como crianças e delegados importados;

• Classes que derivam de CodeActivity e AsyncCodeActivity não suportam variáveis, subelementos ou delegados, portanto, apenas argumentos serão expostos.

Reescrevendo CacheMetadata para fornecer informações ao tempo de execução

O trecho de código a seguir demonstra como adicionar informações sobre membros aos metadados de uma atividade durante a execução do CacheMetadata método. Observe que a base do método é chamada para armazenar em cache todos os dados públicos sobre a atividade.

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

Utilizando CacheMetadata para expor componentes de implementação

Para passar dados para atividades infantis que devem ser programadas por uma atividade usando variáveis, é necessário adicionar as variáveis como variáveis de implementação; As variáveis públicas não podem ter os seus valores definidos desta forma. A razão para isso é que as atividades devem ser executadas mais como implementações de funções (que têm parâmetros), em vez de classes encapsuladas (que têm propriedades). No entanto, existem situações em que é necessário definir explicitamente os argumentos, como ao utilizar ScheduleActivity, dado que a atividade programada não tem acesso aos argumentos da atividade mãe, como faria uma atividade filha.

Este trecho de código demonstra como passar um argumento de uma ação nativa para uma ação agendada usando 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);
    }
}