Quando utilizzare le proprietà di dipendenza

A volte penso di utilizzare forse le proprietà di dipendenza inutilmente. Quando devo usarlo? Quando ho una proprietà che dipende da altre proprietà? Diciamo che ho una proprietà Color che voglio che dipenda dalle proprietà Tonalità, Saturazione, Luminosità, utilizzo una proprietà di dipendenza? O cosa uso? Controllo ciò che è legato a Color per aggiornare quando le proprietà Hue, Saturation, Luminosity sono cambiate.

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 penso che questo non sia il modo giusto di fare le cose? Se ho più proprietà che influenzano il colore, avrò 1 riga in più in tutte queste proprietà?

Dovresti utilizzare DependencyProperty quando vuoi essere in grado di associare il suo valore a qualcosa tramite XAML, ad es.

  

Aggiornamento: come menzionato da Ian qui sotto, sono necessarie anche le proprietà di dipendenza se vuoi essere in grado di animare la tua proprietà o impostarla attraverso uno stile

Se non hai bisogno di lavorare in questo modo, non è necessario. Ad esempio, se si desidera essere in grado di impostare il valore su una costante tramite XAML (come di seguito), questo funzionerà senza utilizzare DependencyProperty

  

Allo stesso modo, se vuoi associare il valore di una proprietà su (ad esempio) il tuo modello di vista:

  

quindi non è necessario utilizzare DependencyProperty . A condizione che si implementa INotifyPropertyChanged il Text verrà comunque aggiornato quando la proprietà cambia.

Modifica: rileggendo la tua domanda, non sono sicuro se la tua situazione sarà influenzata dal fatto che tu usi o meno una DependencyProperty – se la sto leggendo correttamente, tutto ciò che vuoi fare è far sì che un certo numero di proprietà essere aggiornato 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è aumentando un sacco di eventi PropertyChanged in ogni setter), ma se non ti appassioni allora potresti provare ad avere una singola proprietà che espone le proprietà figlio rilevanti da associare a quelle sono tutte calcolate:

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

Quindi disponi di una proprietà Color sul tuo ViewModel che solleva l’evento PropertyChanged e associalo a quello attraverso la vista:

  

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

Le regole generali sono:

  • Per i controlli XAML, utilizzare le proprietà di dipendenza;

  • Per i dati (che si INotifyPropertyChanged all’interfaccia), utilizzare INotifyPropertyChanged .

Ci sono delle eccezioni, ma sono rare.

Un altro uso delle proprietà di dipendenza è con il diario di navigazione. Le proprietà di dipendenza personalizzate su una pagina con indicatore Juornal nei metadati sono incluse nello stato che WPF salva per la pagina.

Ricorda che le proprietà delle dipendenze, sebbene consentano il binding sia come origine che come target, sono anche sensibili al thread e, in caso di serializzazione, dovrai utilizzare un surrogato, la serializzazione come DependencyObject non è serializzabile.

Oh, e Equals e GetHashCode sono sigillati 🙁