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. O tempo de execução 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 fornece ao tempo 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 tempo 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 processos os seguintes tipos de NativeActivity método 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 na atividade filho.

• 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 e CodeActivityAsyncCodeActivity não suportam variáveis, filhos ou delegados, portanto, apenas argumentos serão expostos.

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

Usando CacheMetadata para expor filhos 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, há situações em que os argumentos devem ser explicitamente definidos, como ao usar ScheduleActivity, uma vez que a atividade agendada não tem acesso aos argumentos da atividade pai da mesma forma que uma atividade filha.

O trecho de código a seguir demonstra como passar um argumento de uma atividade nativa para uma atividade agendada usando CacheMetadatao .

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