Utilisation des propriétés de dépendance

Article
04/22/2008

Les propriétés de dépendance fournissent une base de données de référentiel centralisée concernant l'état d'un workflow. Le DependencyObject est en fait un tableau de hachage qui stocke les valeurs actuelles de toute DependencyProperty qui lui est appliquée.

Un type d'instance d'une propriété de dépendance peut être lié aux données d'instance, auquel cas la valeur réelle n'est déterminée qu'au moment de l'exécution. Vous définissez ce type de valeur de propriété de dépendance afin qu'il soit un ActivityBind à lier à la valeur réelle à laquelle il est fait accès au moment de l'exécution.

ActivityBind lie une propriété d'activité à chacun des éléments suivants :

Une autre propriété d'activité
Un champ
Une propriété
Une méthode

Lorsque vous créez une liaison avec une propriété d'activité, si l'activité avec laquelle la liaison est définie (la cible) est une activité personnalisée, Windows Workflow Foundation essaie de résoudre l'activité source à partir de l'activité parent cible. Si l'activité source est introuvable, Windows Workflow Foundation essaie de résoudre le nom à partir de l'activité cible elle-même. Si l'activité cible n'est pas une activité personnalisée, Windows Workflow Foundation essaie de résoudre l'activité source à partir de l'activité cible elle-même.

Une propriété de dépendance de type métadonnées doit se voir affecter une valeur littérale au moment de la conception parce qu'elle est immuable au moment de l'exécution.

Remarque :
Toutes valeurs affectées dans ValidationOptionAttribute sont ignorées pour les propriétés de dépendance basées sur des instances ; toutefois, elles sont valides pour les propriétés de dépendance basées sur des métadonnées.

Remarque :
Si vous créez une propriété d'activité dont le type est dérivé de DependencyObject, elle doit être déclarée comme une propriété de dépendance de métadonnées ou une exception est levée par le moteur d'exécution de workflow pendant l'exécution.

Lorsque vous créez des noms pour vos propriétés de dépendance, vous devez choisir des noms uniques qui ne sont utilisés pour les propriétés de dépendance ou les événements dans aucune classe de base dont vous héritez ; sinon, un ArgumentException est levé au moment de l'exécution.

Exemple de DependencyProperty

L'exemple de code suivant montre comment implémenter une condition à l'aide de DependencyProperty. L'exemple présente comment ajouter une DependencyProperty, avec le type correspondant passé dans Register.

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

Propriétés attachées

Dans certains cas, vous avez besoin d'une activité pour enregistrer une propriété qui peut être utilisée par d'autres activités dans un workflow. Ce type de propriété est appelé une propriété attachée et consiste en un formulaire spécialisé de propriété de dépendance. Vous enregistrez une propriété attachée à l'aide de la méthode RegisterAttached de la classe DependencyProperty.

Une propriété attachée est un type de propriété de dépendance que d'autres classes déclarent et qui peut ensuite s'appliquer à toute sous-classe de la classe DependencyObject. La classe qui possède la propriété de dépendance doit fournir des méthodes d'accesseur statiques pour obtenir et définir la valeur sur les instances DependencyObject arbitraires.

Le code suivant affiche comment vous pouvez utiliser une propriété attachée pour permettre aux activités enfants d'une activité composite de stocker les valeurs uniques d'une propriété définie dans l'activité parente.

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

Pour plus d'informations sur les propriétés de dépendance, consultez les classes DependencyProperty et DependencyObject de l'espace de noms System.Workflow.ComponentModel dans la référence de bibliothèque de classes Windows Workflow Foundation.

Voir aussi

Référence

DependencyObject
DependencyProperty

Concepts

Utilisation des propriétés d'activité
Création d'activités personnalisées

Footer image

Partager via