Quando utilizzare le proprietà delle dipendenze

Question

A volte penso che forse si utilizzino le proprietà di dipendenza inutilmente. Quando devo usarlo? Quando ho una proprietà che dipende da altre proprietà? Dire che ho una proprietà Color che voglio che dipenda dalle proprietà Tonalità, Saturazione, Luminosità, utilizzo una proprietà di dipendenza? O cosa uso? Controllo questo limite associato a Color da aggiornare quando le proprietà Tonalità, Saturazione, Luminosità vengono modificate.

per ora quello che ho fatto è stato

public byte Hue { 
    get { return _hue; } 
    set 
    { 
     if (_hue == value) 
      return; 
     _hue = value; 
     NotifyPropertyChanged("Hue"); 
     NotifyPropertyChanged("Color"); // to update controls bound to color 
    } 
} 

ma credo che questo non è il modo giusto di fare le cose? Se ho più proprietà che influenzano il colore, avrò 1 riga in più in tutte queste proprietà?

Answer 1

Utilizzare solo un DependencyProperty quando si desidera poter associare il valore al valore a qualcosa tramite XAML, ad es.

<local:MyObject MyDependencyProperty="{Binding ...}" /> 

Aggiornamento: come detto da Ian di seguito, le proprietà di dipendenza sono necessari anche se si vuole essere in grado di animare la vostra proprietà o impostarlo attraverso uno stile

Se non c'è bisogno di lavorare in questo modo quindi non è necessario. per esempio. Se si desidera solo essere in grado di impostare il valore a una costante attraverso XAML (come sotto) questo lavoro senza utilizzare una DependencyProperty

<local:MyObject MyRegularProperty="Some Value" /> 

Allo stesso modo, se si desidera associare - il valore di una proprietà su (per esempio) il vostro vista del modello:

<TextBlock Text="{Binding MyViewModelProperty}" /> 

allora non c'è bisogno di usare un DependencyProperty. Se si implementa INotifyPropertyChanged, lo Text verrà comunque aggiornato quando la proprietà cambia.

Edit: rileggendo la tua domanda, non sono sicuro se la vostra situazione sarà influenzato da se o non si utilizza un DependencyProperty - se sto leggendo correttamente, tutto quello che vuoi fare è causare un numero di proprietà da aggiornare sull'interfaccia utente quando cambia una di queste proprietà, giusto?

Non penso che ci sia qualcosa di sbagliato nel modo in cui stai implementando le cose al momento (cioè sollevando un sacco di eventi PropertyChanged in ogni setter), ma se non ti appassioni allora potresti provare ad avere un singola proprietà che espone importanti proprietà secondarie di legarsi a che sono tutti calcolati:

class ColorWrapper 
{ 
    public Color Color { get; set; } 
    public byte Hue 
    { 
     get { return this.Color.Hue; } //or however this is calculated 
} 

Poi hanno una proprietà Color sul tuo ViewModel che genera l'evento PropertyChanged e legarsi a che attraverso la vista:

<TextBlock Text="{Binding Color.Hue}" /> 

Come ho detto, non direi che questo è un miglioramento in particolare di quello che hai già.

Answer 2

Le regole generali sono:

• Per controlli XAML, proprietà di dipendenza uso;

• Per i dati (che vengono associati all'interfaccia), utilizzare INotifyPropertyChanged.

Ci sono delle eccezioni, ma sono rare.

Answer 3

Ricordare che Proprietà dipendenza, anche se consentono Binding come origine o destinazione, sono anche sensibili al thread e quando si serializza si dovrà utilizzare un surrogato, serializzazione come DependencyObject non serializzabile.

Oh, e Equals e GetHashCode sono sigillati :(

Answer 4

Un altro uso della proprietà di dipendenza è con il giornale di navigazione. Proprietà di dipendenza personalizzate su una pagina con la bandiera Ÿ rivista nella meta-dati sono inclusi nello stato che WPF salva per la pagina