Expõem dados com CacheMetadata

Antes de executar uma atividade, o runtime de fluxo de trabalho obtém qualquer informação sobre a atividade que precisa para manter sua execução. O runtime de fluxo de trabalho obtém essas informações durante a execução do método de CacheMetadata . 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 de CacheMetadata

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

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

• Variable ou alguma subclasse disso: Esses membros são expostos no 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 representantes públicos.

• ICollection de tipo Variable: Todos os elementos na coleção é retornado para o 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 representantes públicos.

CacheMetadata para as atividades que derivam de Activity, CodeActivity, e AsyncCodeActivity também funcionam como anterior, exceto as 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;

• As classes que derivam de CodeActivity e AsyncCodeActivity não suporta variáveis, filhos, ou representantes, portanto somente argumentos serão expostas.

Substituindo CacheMetadata para fornecer informações em runtime

O snippet de código a seguir demonstra como adicionar informações sobre membros para metadados de uma atividade durante a execução do método de CacheMetadata . Observe que a base do método é chamada para armazenar em cachê 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. A razão para isso é que as atividades são feitos para ser executadas mais como implementações das funções (que têm parâmetros), em vez das classes encapsuladas (que tem 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);
    }
}