Exponera data med CacheMetadata

Innan du kör en aktivitet hämtar arbetsflödesmotorn all information om den aktivitet som behövs för att upprätthålla dess körning. Arbetsflödets runtime hämtar den här informationen under utförandet av CacheMetadata-metoden. Standardimplementeringen av den här metoden tillhandahåller exekveringsmiljön med alla publika argument, variabler och underordnade aktiviteter som exponeras av aktiviteten vid körning. Om aktiviteten behöver ge mer information till exekveringsmiljön än detta (till exempel privata medlemmar eller aktiviteter som ska schemaläggas av aktiviteten), kan den här metoden åsidosättas för att möjliggöra detta.

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örningsmiljön som publika variabler.

• Activity eller någon underklass därav: Dessa medlemmar exponeras för exekvering som offentliga barnaktiviteter. Standardbeteendet kan implementeras explicit genom att anropa AddImportedChild och överföra den underliggande aktiviteten.

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

• ICollection av typen Variable: Alla element i samlingen exponeras för runtime som publika variabler.

• ICollection av typen Activity: Alla element i kollektionen blir synliga för runtime som offentliga barn.

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

För aktiviteterna som härleds från CacheMetadata, Activity och CodeActivity fungerar de också som ovan, förutom följande skillnader:

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

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

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

Följande kodfragment visar hur du lägger till information om medlemmar i en aktivitets metadata under körningen CacheMetadata av metoden. Observera att basmetoden anropas för att cacha alla offentliga uppgifter 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 tillfällen då det är nödvändigt att ange argumenten uttryckligen, till exempel när du använder ScheduleActivity, eftersom den schemalagda aktiviteten inte har åtkomst till den överordnade aktivitetens argument på samma sätt som en underordnad aktivitet skulle ha.

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