Exposition de données avec CacheMetadata

Avant d'exécuter une activité, le runtime du workflow obtient toutes les informations nécessaires sur l'activité afin de gérer son exécution. Le runtime de workflow obtient ces informations pendant l'exécution de la méthode CacheMetadata. 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 par défaut de CacheMetadata

L'implémentation par défaut de CacheMetadata pour les activités qui dérivent de NativeActivity traite les types de méthode suivants comme suit :

• InArgument<T>, OutArgument<T> ou InOutArgument<T> (arguments génériques) : ces arguments sont exposés au runtime comme des arguments dont le nom et le type correspondent au nom et au type de la propriété exposée, à la direction de l'argument approprié, et à certaines données de validation.

• Variable ou une sous-classe : 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.

Le 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

• classes qui dérivent de CodeActivity et AsyncCodeActivity ne prennent pas en charge les variables, les enfants ou les délégués, c'est pourquoi 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 méthode CacheMetadata. Notez que la base de la méthode est appelée pour mettre en cache toutes les données publiques sur 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 passer les 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 valeurs des variables publiques ne peuvent pas être définies de cette façon. En effet, les activités sont conçues pour être exécutées plus comme des implémentations de fonctions (qui ont des paramètres), que comme des classes encapsulées (qui ont des propriétés). Toutefois, il existe des situations dans lesquelles les arguments doivent être définis explicitement, comme lors de l’utilisation de ScheduleActivity, puisque l’activité planifiée n’a pas accès aux arguments de l’activité parent comme une activité enfant.

L’extrait de code suivant montre comment passer un argument d’une activité native à une activité planifiée en utilisant 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);
    }
}