Verwenden von Abhängigkeitseigenschaften
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
Copyright © 2007 by Microsoft Corporation. Alle Rechte vorbehalten.