Utilizzo delle proprietà di dipendenza

Articolo
09/01/2008

Le proprietà di dipendenza forniscono un repository centralizzato dello stato di un flusso di lavoro. La classeDependencyObject è fondamentalmente una tabella hash in cui vengono memorizzati i valori correnti di qualsiasi DependencyProperty applicata ad essa.

È possibile associare un tipo di istanza di proprietà di dipendenza a dati di istanza; in tal caso il valore effettivo viene determinato solo in fase di esecuzione. Questo tipo di valore della proprietà di dipendenza viene impostato come classe ActivityBind per l'associazione al valore effettivo a cui si accede in fase di esecuzione.

La classe ActivityBind associa la proprietà di un'attività a uno degli elementi seguenti:

Un'altra proprietà dell'attività
Un campo
Una proprietà
Un metodo

Quando si esegue l'associazione a una proprietà dell'attività, se l'attività nella quale viene impostata l'associazione (destinazione) è un'attività personalizzata, in Windows Workflow Foundation viene tentata la risoluzione dell'attività di origine partendo dall'attività padre della destinazione. Se l'attività di origine non viene trovata, viene tentata la risoluzione del nome partendo dall'attività di destinazione stessa. Se l'attività di destinazione non è un'attività personalizzata, viene tentata la risoluzione dell'attività di origine partendo dall'attività di destinazione stessa.

Un tipo metadati di proprietà di dipendenza deve essere impostato su un valore letterale in fase di progettazione poiché non è modificabile in fase di esecuzione.

Nota

I valori impostati in ValidationOptionAttribute vengono ignorati per le proprietà di dipendenza basate su istanze, ma sono validi per le proprietà di dipendenza basate su metadati.

Nota

Se si crea una proprietà di attività il cui tipo viene derivato da DependencyObject, è necessario dichiararla come proprietà di dipendenza di metadati; in caso contrario, verrà generata un'eccezione dal motore di runtime del flusso di lavoro in fase di esecuzione.

Quando si creano nomi per le proprietà di dipendenza, è necessario scegliere nomi univoci che non siano utilizzati per proprietà di dipendenza o eventi in classi di base da cui si eredita; in caso contrario, verrà generata un'eccezione ArgumentException in fase di esecuzione.

Esempio di DependencyProperty

Nell'esempio di codice seguente viene illustrato come implementare una condizione mediante una DependencyProperty. Nell'esempio viene illustrato come aggiungere una DependencyProperty con il tipo corretto passato nel metodo 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);
    }
}

Proprietà associate

In alcuni casi è necessario che un'attività registri una proprietà che può essere utilizzata da altre attività in un flusso di lavoro. Questo tipo di proprietà viene denominato proprietà associata, ovvero un tipo specifico di proprietà di dipendenza. Per registrare una proprietà associata, utilizzare il metodo RegisterAttached della classe DependencyProperty.

Una proprietà associata è un tipo di proprietà di dipendenza che altre classi dichiarano applicabile a una sottoclasse della classe DependencyObject. La classe che possiede la proprietà di dipendenza deve fornire metodi statici della funzione di accesso per ottenere e impostare il valore nelle istanze arbitrarie DependencyObject.

Nel codice seguente viene illustrato come utilizzare una proprietà associata per consentire alle attività figlio di una CompositeActivity di archiviare i valori univoci di una proprietà definita nell'attività padre.

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

Per ulteriori informazioni sulle proprietà di dipendenza, vedere le classi DependencyProperty e DependencyObject nello spazio dei nomi System.Workflow.ComponentModel nel riferimento alla libreria di classi di Windows Workflow Foundation.

Vedere anche

Riferimenti

DependencyObject
DependencyProperty

Concetti

Utilizzo delle proprietà dell'attività
Creazione di attività personalizzate

Footer image

Condividi tramite