Expondo dados com CacheMetadata

Antes de executar uma atividade, o runtime do fluxo de trabalho obtém todas as informações sobre a atividade necessária para manter sua execução. O runtime do fluxo de trabalho obtém essas informações durante a execução do CacheMetadata método. A implementação padrão desse método oferece o runtime com todos os argumentos públicos, variáveis, e atividades filhos exposto pela atividade é então executada; se a atividade precisará fornecer mais informações em runtime desta (como membros particulares, ou atividades a ser agendadas pela atividade), esse método pode ser substituído para oferece.

Comportamento padrão do CacheMetadata

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

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

• Variable ou qualquer subclasse dela: esses membros são expostos ao runtime como variáveis públicas.

• Activity ou alguma subclasse disso: Esses membros são expostos ao runtime como atividades filhos públicas. O comportamento padrão pode ser implementado explicitamente chamando AddImportedChild, passando na atividade filho.

• ActivityDelegate ou alguma subclasse disso: Esses membros são expostos no runtime como delegados públicos.

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

• ICollection de tipo Activity: Todos os elementos na coleção expostos no runtime como filhos públicos.

• ICollection de tipo ActivityDelegate: Todos os elementos na coleção são expostos ao runtime como delegados públicos.

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

• As classes que derivam de Activity não pode agendar atividades filho ou representantes, para que esses membros são expostos como filhos e delegados importados;

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

Sobrescrevendo CacheMetadata para fornecer informações ao ambiente de execução

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

Usando CacheMetadata para expor filhos de implementação

Para passar dados para atividades filhos que devem ser agendadas por uma atividade usando variáveis, é necessário adicionar variáveis como variáveis de implementação; variáveis públicas não podem ter seus valores definidos essa maneira. O motivo disso é 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, há situações em que os argumentos devem ser explicitamente definidos, como ao usar ScheduleActivity, desde que a atividade agendada não tem acesso aos argumentos pai de atividade da maneira que uma atividade filho.

O snippet de código a seguir demonstra como passar um argumento de uma atividade nativa para uma atividade 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);
    }
}