Verfügbarmachen von Daten mit CacheMetadata

Vor dem Ausführen einer Aktivität ruft die Workflowlaufzeit alle Informationen zu der Aktivität ab, die sie benötigt, um die Ausführung aufrechtzuerhalten. 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.

Standardverhalten von CacheMetadata

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

• InArgument<T>, oder OutArgument<T>InOutArgument<T> (generische Argumente): Diese Argumente werden für die Laufzeit als Argumente mit einem Namen und Typ verfügbar gemacht, der dem verfügbar gemachten Eigenschaftennamen und -typ, der entsprechenden Argumentrichtung und einigen Überprüfungsdaten entspricht.

• Variable oder eine beliebige Unterklasse davon: Diese Mitglieder werden der Runtime als öffentliche Variablen zur Verfügung gestellt.

• Activity oder eine beliebige Unterklasse davon: Diese Mitglieder werden der Runtime als öffentliche untergeordnete Aktivitäten zur Verfügung gestellt. Das Standardverhalten kann explizit implementiert werden, indem AddImportedChild aufgerufen und die untergeordnete Aktivität übergeben wird.

• ActivityDelegate oder eine beliebige Unterklasse davon: Diese Mitglieder werden der Laufzeit als öffentliche Delegierte zur Verfügung gestellt.

• 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 der Collection werden der Laufzeit als öffentliche untergeordnete Elemente zur Verfügung gestellt.

• ICollection vom Typ ActivityDelegate: Alle Elemente in der Collection werden der Laufzeit als öffentliche Delegierte zur Verfügung gestellt.

Die CacheMetadata für Aktivitäten, die von Activity, CodeActivity und AsyncCodeActivity abgeleitet sind, funktionieren ebenfalls wie oben, 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 von CodeActivity und AsyncCodeActivity abgeleitet werden, unterstützen keine Variablen, untergeordnete Elemente oder Delegaten, sodass nur Argumente verfügbar sind.

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

Der folgende Codeausschnitt veranschaulicht, wie Sie während der Ausführung der CacheMetadata Methode Informationen zu Membern zu den Metadaten einer Aktivität hinzufügen. Beachten Sie, dass die Basis der Methode aufgerufen wird, um alle öffentlichen Daten über die 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 dafür ist, dass Aktivitäten mehr als Implementierungen von Funktionen (die Parameter aufweisen) und nicht gekapselte Klassen (die Eigenschaften aufweisen) ausgeführt werden sollen. 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 von einer native Aktivität in eine geplante Aktivität mithilfe von CacheMetadata ü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);
    }
}