Exposition de données avec CacheMetadata

Avant d’exécuter une activité, le runtime de flux de travail obtient toutes les informations relatives à l’activité dont elle a besoin pour maintenir son exécution. Le runtime de flux de travail obtient ces informations pendant l’exécution de la CacheMetadata méthode. L'implémentation par défaut de cette méthode fournit au runtime tous les arguments publics, variables et activités enfants exposés par l'activité lors de son exécution ; si l'activité a besoin de fournir plus d'informations au runtime (telles que les membres privés ou les activités à planifier par l'activité), cette méthode peut être substituée pour les fournir.

Comportement des métadonnées de cache par défaut

L'implémentation par défaut de CacheMetadata pour les activités qui dérivent de NativeActivity traite les types de méthodes suivants de la manière suivante :

• InArgument<T>, OutArgument<T>ou InOutArgument<T> (arguments génériques) : ces arguments sont exposés au runtime en tant qu’arguments portant un nom et un type égal au nom et au type de propriété exposés, à la direction de l’argument approprié et à certaines données de validation.

• Variable ou toute sous-classe de celle-ci : ces membres sont exposés au runtime en tant que variables publiques.

• Activity ou une sous-classe : ces membres sont exposés au runtime en tant qu’activités enfants publiques. Le comportement par défaut peut être implémenté explicitement en appelant AddImportedChild et en passant l’activité enfant.

• ActivityDelegate ou une sous-classe : ces membres sont exposés au runtime en tant que délégués publics.

• ICollection de type Variable: tous les éléments de la collection sont exposés au runtime en tant que variables publiques.

• ICollection de type Activity : tous les éléments de la collection sont exposés au runtime en tant qu’enfants publics.

• ICollection de type ActivityDelegate : tous les éléments de la collection sont exposés au runtime en tant que délégués publics.

Les CacheMetadata pour les activités qui dérivent de Activity, CodeActivity, et AsyncCodeActivity fonctionnent également comme ci-dessus, à l’exception des différences suivantes :

• Les classes qui dérivent de Activity ne peuvent pas planifier des activités enfants ou des délégués, ces pourquoi ces membres sont exposés comme des enfants importés et des délégués ; les

• Les classes qui dérivent de CodeActivity et AsyncCodeActivity ne prennent pas en charge les variables, les éléments enfants ou les délégués, de sorte que seuls les arguments seront exposés.

Substitution de CacheMetadata pour fournir des informations au runtime

L’extrait de code suivant montre comment ajouter des informations sur les membres aux métadonnées d’une activité pendant l’exécution de la CacheMetadata méthode. Notez que la base de la méthode est appelée pour mettre en cache toutes les données publiques relatives à l’activité.

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

Utilisation de CacheMetadata pour exposer les enfants de l'implémentation

Pour transmettre des données aux activités enfants qui doivent être planifiées par une activité à l’aide de variables, il est nécessaire d’ajouter les variables en tant que variables d’implémentation ; les variables publiques ne peuvent pas avoir leurs valeurs définies de cette façon. La raison en est que les activités sont destinées à être exécutées plus en tant qu’implémentations de fonctions (qui ont des paramètres), plutôt que des classes encapsulées (qui ont des propriétés). Toutefois, il existe des situations dans lesquelles les arguments doivent être définis explicitement, par exemple lors de l’utilisation de ScheduleActivity, car l’activité planifiée n’a pas accès aux arguments de l’activité parent de la même manière qu'une activité enfant le ferait.

L’extrait de code suivant montre comment passer un argument d’une activité native dans une activité planifiée à l’aide CacheMetadatade .

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