Verfügbarmachen von Daten mit CacheMetadata

Vor dem Ausführen einer Aktivität ruft die Workflowlaufzeit alle Aktivitätsinformationen ab, die für die Ausführung erforderlich sind. Die Workflowlaufzeit ruft diese Informationen während der Ausführung der CacheMetadata-Methode ab. Die Standardimplementierung dieser Methode stellt der Laufzeit alle öffentlichen Argumente, Variablen und untergeordneten Aktivitäten bereit, die von der Aktivität zur Ausführungszeit verfügbar gemacht werden. Wenn die Aktivität mehr Informationen als diese an die Laufzeit übergeben muss (z. B. private Member oder Aktivitäten, die von der Aktivität geplant werden sollen), kann diese Methode überschrieben werden, um diese Informationen zur Verfügung zu stellen.

CacheMetadata-Standardverhalten

Die Standardimplementierung von CacheMetadata für Aktivitäten, die aus NativeActivity abgeleitet werden, verarbeitet die folgenden Methodentypen auf folgende Weise:

• InArgument<T>, OutArgument<T> oder InOutArgument<T> (generische Argumente): Diese Argumente werden für die Laufzeit als Argumente verfügbar gemacht, deren Name und Typ mit dem verfügbar gemachten Eigenschaftsnamen und -typ identisch ist. Zudem werden die entsprechende Argumentrichtung und einige Validierungsdaten bereitgestellt.

• Variable oder eine beliebige Unterklasse davon: Diese Member werden für die Laufzeit als öffentliche Variablen verfügbar gemacht.

• Activity oder eine beliebige Unterklasse davon: Diese Member werden für die Laufzeit als öffentliche untergeordnete Aktivitäten verfügbar gemacht. Das Standardverhalten kann explizit implementiert werden, indem AddImportedChild aufgerufen und die untergeordnete Aktivität übergeben wird.

• ActivityDelegate oder eine beliebige Unterklasse davon: Diese Member werden für die Laufzeit als öffentliche Delegaten verfügbar gemacht.

• ICollection vom Typ Variable: Alle Elemente in der Auflistung werden für die Laufzeit als öffentliche Variablen verfügbar gemacht.

• ICollection vom Typ Activity: Alle Elemente in der Auflistung werden für die Laufzeit als öffentliche untergeordnete Elemente verfügbar gemacht.

• ICollection vom Typ ActivityDelegate: Alle Elemente in der Auflistung werden für die Laufzeit als öffentliche Delegaten verfügbar gemacht.

CacheMetadata für Aktivitäten, die aus Activity, CodeActivity abgeleitet werden, und AsyncCodeActivity funktionieren auch wie oben beschrieben, mit Ausnahme der folgenden Unterschiede:

• Klassen, die aus Activity abgeleitet werden, können keine untergeordneten Aktivitäten oder Delegaten planen. Daher werden solche Member als importierte untergeordnete Elemente und Delegaten verfügbar gemacht.

• Klassen, die aus CodeActivity und AsyncCodeActivity abgeleitet werden, unterstützen keine Variablen, untergeordneten Elemente oder Delegaten, sodass nur Argumente verfügbar gemacht werden.

Überschreiben von CacheMetadata zum Bereitstellen von Informationen für die Laufzeit

Der folgende Codeausschnitt veranschaulicht, wie den Metadaten einer Aktivität während der Ausführung der CacheMetadata-Methode Informationen zu Membern hinzugefügt werden. Beachten Sie, dass die Basis der Methode aufgerufen wird, um alle öffentlichen Daten zur Aktivität zwischenzuspeichern.

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

Verwenden von CacheMetadata zum Verfügbarmachen von untergeordneten Elementen der Implementierung

Zur Übergabe von Daten an untergeordnete Aktivitäten, die mithilfe von Variablen von einer Aktivität geplant werden sollen, müssen die Variablen als Implementierungsvariablen hinzugefügt werden. Die Werte von öffentlichen Variablen können nicht auf diese Weise festgelegt werden. Der Grund ist, dass Aktivitäten nach Möglichkeit eher als Implementierungen von Funktionen (die über Parameter verfügen) ausgeführt werden sollen und nicht als gekapselte Klassen (die über Eigenschaften verfügen). Es gibt jedoch Situationen, in denen die Argumente explizit festgelegt werden müssen, beispielsweise beim Verwenden von ScheduleActivity, da die geplante Aktivität nicht so auf die Argumente der übergeordneten Aktivität zugreifen kann wie eine untergeordnete Aktivität.

Der folgende Codeausschnitt veranschaulicht, wie ein Argument aus einer nativen Aktivität mit CacheMetadata an eine geplante Aktivität übergeben wird.

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