Exponera data med CacheMetadata

Innan du kör en aktivitet hämtar arbetsflödeskörningen all information om den aktivitet som behövs för att upprätthålla körningen. Arbetsflödeskörningen hämtar den här informationen under körningen CacheMetadata av metoden. Standardimplementeringen av den här metoden ger körningen med alla offentliga argument, variabler och underordnade aktiviteter som exponeras av aktiviteten när den körs. Om aktiviteten behöver ge mer information till körningen än detta (till exempel privata medlemmar eller aktiviteter som ska schemaläggas av aktiviteten), kan den här metoden åsidosättas för att tillhandahålla den.

Standardbeteende för CacheMetadata

Standardimplementeringen av CacheMetadata för aktiviteter som härleds från NativeActivity processer följande metodtyper på följande sätt:

• InArgument<T>, OutArgument<T>, eller InOutArgument<T> (allmänna argument): Dessa argument exponeras för körningen som argument med ett namn och en typ som är lika med det exponerade egenskapsnamnet och typen, lämplig argumentriktning och vissa valideringsdata.

• Variable eller någon underklass därav: Dessa medlemmar exponeras för körningen som offentliga variabler.

• Activity eller någon underklass därav: Dessa medlemmar exponeras för körningen som offentliga underordnade aktiviteter. Standardbeteendet kan implementeras explicit genom att anropa AddImportedChildoch skicka in den underordnade aktiviteten.

• ActivityDelegate eller någon underklass därav: Dessa medlemmar exponeras för körningen som offentliga ombud.

• ICollection av typen Variable: Alla element i samlingen exponeras för körningen som offentliga variabler.

• ICollection av typen Activity: Alla element i samlingen exponeras för körningen som offentliga underordnade.

• ICollection av typen ActivityDelegate: Alla element i samlingen exponeras för körningen som offentliga ombud.

För CacheMetadata aktiviteter som härleds från Activity, CodeActivityoch AsyncCodeActivity fungerar även som ovan, förutom följande skillnader:

• Klasser som härleds från Activity kan inte schemalägga underordnade aktiviteter eller ombud, så sådana medlemmar exponeras som importerade underordnade och ombud.

• Klasser som härleds från CodeActivity och AsyncCodeActivity inte stöder variabler, underordnade eller ombud, så endast argument kommer att exponeras.

Åsidosätta CacheMetadata för att ge information till körningen

Följande kodfragment visar hur du lägger till information om medlemmar i en aktivitets metadata under körningen CacheMetadata av metoden. Observera att metodens bas anropas för att cachelagrat alla offentliga data om aktiviteten.

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

Använda CacheMetadata för att exponera implementeringsbarn

För att kunna skicka data till underordnade aktiviteter som ska schemaläggas av en aktivitet med hjälp av variabler är det nödvändigt att lägga till variablerna som implementeringsvariabler. offentliga variabler kan inte ange sina värden på det här sättet. Anledningen till detta är att aktiviteter är avsedda att köras mer som implementeringar av funktioner (som har parametrar), snarare än inkapslade klasser (som har egenskaper). Det finns dock situationer där argumenten måste anges uttryckligen, till exempel när du använder ScheduleActivity, eftersom den schemalagda aktiviteten inte har åtkomst till den överordnade aktivitetens argument på det sätt som en underordnad aktivitet skulle göra.

Följande kodfragment visar hur du skickar ett argument från en intern aktivitet till en schemalagd aktivitet med hjälp av 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);
    }
}