Verwenden von Abhängigkeitseigenschaften

Artikel
12/17/2007

Abhängigkeitseigenschaften bieten ein zentralisiertes Repository des Zustands eines Workflows. Beim DependencyObject handelt es sich im Grunde genommen um eine Hashtabelle, in der die aktuellen Werte jeder DependencyProperty gespeichert werden, die darauf angewendet werden.

Ein Instanztyp der Abhängigkeitseigenschaft kann an Instanzdaten gebunden werden, deren tatsächlicher Wert bis zur Laufzeit nicht bestimmt wird. Sie legen diesen Typ eines Werts für die Abhängigkeitseigenschaft auf ActivityBind fest, um den tatsächlichen Wert zu binden, auf den bei Laufzeit zugegriffen wird.

ActivityBind bindet eine Aktivitätseigenschaft an eine der folgenden Möglichkeiten:

Eine andere Aktivitätseigenschaft
Ein Feld
Eine Eigenschaft
Eine Methode

Beim Binden an eine Aktivitätseigenschaft handelt es sich bei der Aktivität, für die die Bindung festgelegt wird (das Ziel), um eine benutzerdefinierte Aktivität. In diesem Fall wird von Windows Workflow Foundation versucht, die Quellaktivität mit der dem Ziel übergeordneten Aktivität beginnend aufzulösen. Wird die Quellaktivität nicht gefunden, wird von Windows Workflow Foundation versucht, den Namen mit der Zielaktivität selbst beginnend aufzulösen. Handelt es sich bei der Zielaktivität um keine benutzerdefinierte Aktivität, wird von Windows Workflow Foundation versucht, die Quellaktivität mit der Zielaktivität selbst beginnend aufzulösen.

Ein Metadatentyp der Abhängigkeitseigenschaft muss zur Entwurfszeit auf einen Literalwert festgelegt werden, weil er bei Laufzeit unveränderlich ist.

Hinweis

Alle in ValidationOptionAttribute festgelegten Werte werden für auf Instanzen basierende Abhängigkeitseigenschaften ignoriert. Sie sind jedoch für die auf Metadaten basierenden Abhängigkeitseigenschaften gültig.

Hinweis

Falls Sie eine Aktivitätseigenschaft erstellen, deren Typ von DependencyObject abgeleitet ist, muss sie als Metadaten-Abhängigkeitseigenschaft deklariert werden, weil sonst während der Laufzeit vom Workflow-Laufzeitmodul eine Ausnahme zurückgegeben wird.

Beim Erstellen von Namen für die Abhängigkeitseigenschaften müssen eindeutige Namen gewählt werden, die nicht für Abhängigkeitseigenschaften oder Ereignisse in Basisklassen verwendet werden, von denen Sie erben. Andernfalls wird während der Laufzeit eine ArgumentException zurückgegeben.

DependencyProperty-Beispiel

Im folgenden Codebeispiel wird die Implementierung einer Bedingung mithilfe von DependencyProperty veranschaulicht. Im Beispiel wird das Hinzufügen einer DependencyProperty und das Eingeben des richtigen Typs in Register veranschaulicht.

Public Shared ExecutionConditionProperty As DependencyProperty = DependencyProperty.Register("ExecuteCondition", GetType(ActivityCondition), GetType(ActivityLibrary2.Activity1))

<DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)> _
    Public Property ExecuteCondition() As ActivityCondition
    Get
        Return CType(MyBase.GetValue(ExecutionConditionProperty), ActivityCondition)
    End Get
    Set(ByVal value As ActivityCondition)
        MyBase.SetValue(ExecutionConditionProperty, value)
    End Set
End Property

public static DependencyProperty ExecutionConditionProperty = DependencyProperty.Register("ExecutionCondition", typeof(System.Workflow.ComponentModel.ActivityCondition), typeof(ActivityLibrary2.Activity1));

[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Visible)]
[BrowsableAttribute(true)]
public System.Workflow.ComponentModel.ActivityCondition ExecutionCondition
{
    get
    {
        return ((System.Workflow.ComponentModel.ActivityCondition)(base.GetValue(ActivityLibrary2.Activity1.ExecutionConditionProperty)));
    }
    set
    {
        base.SetValue(ActivityLibrary2.Activity1.ExecutionConditionProperty, value);
    }
}

Angefügte Eigenschaften

In bestimmten Fällen muss in einer Aktivität eine Eigenschaft registriert sein, die von anderen Aktivitäten in einem Workflow verwendet werden kann. Diese Eigenschaftsart wird als angefügte Eigenschaft bezeichnet, eine spezialisierte Form der Abhängigkeitseigenschaft. Sie registrieren eine angefügte Eigenschaft mit der RegisterAttached-Methode der DependencyProperty-Klasse.

Bei einer angefügten Eigenschaft handelt es sich um einen von anderen Klassen deklarierten Typ der Abhängigkeitseigenschaft, der dann auf eine beliebige Unterklasse der DependencyObject-Klasse angewendet wird. Von der Klasse, die die Abhängigkeitseigenschaft besitzt, müssen statische Accessormethoden bereitgestellt werden, um den Wert von willkürlichen DependencyObject-Instanzen abzurufen und festzulegen.

Im folgenden Code wird die Verwendung einer angefügten Eigenschaft veranschaulicht, um untergeordneten Aktivitäten einer zusammengesetzten Aktivität das Speichern eindeutiger Werte einer Eigenschaft zu ermöglichen, die in der übergeordneten Aktivität definiert ist.

Public NotInheritable Class CustomActivity
    Inherits CompositeActivity
    Implements IActivityEventListener(Of ActivityExecutionStatusChangedEventArgs)

    ' Declare attached property provided to the child actvities.
    Public Shared ReadOnly WhenConditionProperty As DependencyProperty = DependencyProperty.RegisterAttached("ExecuteCondition", GetType(ActivityCondition), GetType(CustomActivity), New PropertyMetadata(DependencyPropertyOptions.Metadata))

    ' Constructors
    Public Sub New()
        InitializeComponent()
    End Sub

    Public Sub New(ByVal name As String)
        MyBase.New(name)
        InitializeComponent()
    End Sub

    '**********************************************************************
    ' Get and Set accessors for the attached property WhenConditionProperty.
    '**********************************************************************
    Public Shared Function GetWhenCondition(ByVal dependencyObject As Object) As Object
        If dependencyObject Is Nothing Then
            Throw New ArgumentNullException("dependencyObject")
        End If

        Return CType(dependencyObject, DependencyObject).GetValue(WhenConditionProperty)
    End Function

    Public Shared Sub SetWhenCondition(ByVal dependencyObject As Object, ByVal value As Object)
        If dependencyObject Is Nothing Then
            Throw New ArgumentNullException("dependencyObject")
        End If
        CType(dependencyObject, DependencyObject).SetValue(WhenConditionProperty, value)
    End Sub

    Protected Overrides Function Execute(ByVal executionContext As ActivityExecutionContext) As ActivityExecutionStatus
        ' Execute implementation omitted for clarity.
    End Function

    Public Sub OnEvent(ByVal sender As Object, ByVal e As System.Workflow.ComponentModel.ActivityExecutionStatusChangedEventArgs) Implements System.Workflow.ComponentModel.IActivityEventListener(Of System.Workflow.ComponentModel.ActivityExecutionStatusChangedEventArgs).OnEvent
        ' OnEvent implementation omitted for clarity.
    End Sub

    Private Sub EvaluateChildConditions(ByVal child As Activity, ByVal context As ActivityExecutionContext)
        Dim whenCondition As ActivityCondition = CType(child.GetValue(CustomActivity.WhenConditionProperty), ActivityCondition)
        ' ...
    End Sub
End Class

public sealed class CustomActivity : CompositeActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs>
{
    // Declare attached property provided to the child actvities.
    public static readonly DependencyProperty WhenConditionProperty = 
        DependencyProperty.RegisterAttached("WhenCondition", typeof(ActivityCondition), typeof(CustomActivity), new PropertyMetadata(DependencyPropertyOptions.Metadata));

    // Constructors
    public CustomActivity()
    {
    }

    public CustomActivity(string name)
        : base(name)
    {
    }

    //**********************************************************************
    // Get and Set accessors for the attached property WhenConditionProperty.
    //**********************************************************************
    public static object GetWhenCondition(object dependencyObject)
    {
        if (dependencyObject == null)
            throw new ArgumentNullException("dependencyObject");
        return (dependencyObject as DependencyObject).GetValue(WhenConditionProperty);
    }

    public static void SetWhenCondition(object dependencyObject, object value)
    {
        if (dependencyObject == null)
            throw new ArgumentNullException("dependencyObject");
        (dependencyObject as DependencyObject).SetValue(WhenConditionProperty, value);
    }

    protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
    {
        // Execute implementation omitted for clarity.
    }

    public void OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
    {
        // OnEvent implementation omitted for clarity.
    }

    private void EvaluateChildConditions(Activity child, ActivityExecutionContext context)
    {
            ActivityCondition whenCondition = (ActivityCondition)child.GetValue(CustomActivity.WhenConditionProperty);
            // ...
    }
}

Weitere Informationen zu Abhängigkeitseigenschaften finden Sie in den DependencyProperty-Klassen und den DependencyObject-Klassen des System.Workflow.ComponentModel-Namespace im Windows Workflow Foundation-Verweis der Klassenbibliothek.

Siehe auch

Referenz

DependencyObject
DependencyProperty

Konzepte

Verwenden von Aktivitätseigenschaften
Erstellen von benutzerdefinierten Aktivitäten

Footer image

Freigeben über