WPF - Proprietà di dipendenza

Nelle applicazioni WPF, la proprietà di dipendenza è un tipo specifico di proprietà che estende la proprietà CLR. Sfrutta le funzionalità specifiche disponibili nel sistema di proprietà WPF.

Una classe che definisce una proprietà di dipendenza deve essere ereditata da DependencyObjectclasse. Molte delle classi di controlli dell'interfaccia utente utilizzate in XAML derivano daDependencyObject e supportano le proprietà di dipendenza, ad esempio la classe Button supporta la IsMouseOver proprietà di dipendenza.

Il codice XAML seguente crea un pulsante con alcune proprietà.

<Window x:Class = "WPFDependencyProperty.MainWindow" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:local = "clr-namespace:WPFDependencyProperty"
   Title = "MainWindow" Height = "350" Width = "604"> 
	
   <Grid> 
      <Button  Height = "40" Width = "175" Margin = "10" Content = "Dependency Property"> 
         <Button.Style> 
            <Style TargetType = "{x:Type Button}"> 
               <Style.Triggers> 
					
                  <Trigger Property = "IsMouseOver" Value = "True"> 
                     <Setter Property = "Foreground" Value = "Red" /> 
                  </Trigger>
						
               </Style.Triggers>
            </Style> 
         </Button.Style> 
      </Button> 
   </Grid> 
	
</Window>

L'estensione di markup x: Type in XAML ha una funzionalità simile come typeof () in C #. Viene utilizzato quando vengono specificati attributi che accettano il tipo di oggetto come <Style TargetType = "{x: Type Button}">

Quando il codice precedente viene compilato ed eseguito, si otterrà quanto segue MainWindow. Quando il mouse è sopra il pulsante, cambierà il colore di primo piano di un pulsante. Quando il mouse lascia il pulsante, torna al suo colore originale.

Perché abbiamo bisogno di proprietà di dipendenza

La proprietà di dipendenza offre tutti i tipi di vantaggi quando la si utilizza nella propria applicazione. La proprietà di dipendenza può essere utilizzata su una proprietà CLR negli scenari seguenti:

Se vuoi impostare lo stile
Se vuoi il data binding
Se vuoi impostare una risorsa (una risorsa statica o dinamica)
Se vuoi supportare l'animazione

Fondamentalmente, le proprietà di dipendenza offrono molte funzionalità che non otterrai utilizzando una proprietà CLR.

La principale differenza tra dependency properties e altro CLR properties sono elencati di seguito -

Le proprietà CLR possono leggere / scrivere direttamente dal membro privato di una classe utilizzando getter e setter. Al contrario, le proprietà di dipendenza non vengono archiviate nell'oggetto locale.
Le proprietà di dipendenza sono archiviate in un dizionario di coppie chiave / valore fornito dalla classe DependencyObject. Inoltre consente di risparmiare molta memoria perché memorizza la proprietà quando viene modificata. Può essere associato anche in XAML.

Proprietà di dipendenza personalizzate

In .NET framework, è possibile definire anche proprietà di dipendenza personalizzate. Seguire i passaggi indicati di seguito per definire la proprietà di dipendenza personalizzata in C #.

Dichiara e registra il tuo dependency property con registro chiamate di sistema.
Fornisci il file setter e getter per la proprietà.
Definisci un file static handler che gestirà eventuali modifiche che si verificano a livello globale
Definisci un file instance handler che gestirà tutte le modifiche che si verificano in quella particolare istanza.

Il codice C # seguente definisce una proprietà di dipendenza per impostare il SetText proprietà del controllo utente.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Data; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Imaging; 
using System.Windows.Navigation; 
using System.Windows.Shapes;  

namespace WpfApplication3 { 
   /// <summary> 
      /// Interaction logic for UserControl1.xaml 
   /// </summary> 
	
   public partial class UserControl1 : UserControl { 
	
      public UserControl1() { 
         InitializeComponent(); 
      }
		
      public static readonly DependencyProperty SetTextProperty = 
         DependencyProperty.Register("SetText", typeof(string), typeof(UserControl1), new 
            PropertyMetadata("", new PropertyChangedCallback(OnSetTextChanged))); 
				
      public string SetText { 
         get { return (string)GetValue(SetTextProperty); } 
         set { SetValue(SetTextProperty, value); } 
      } 
		
      private static void OnSetTextChanged(DependencyObject d,
         DependencyPropertyChangedEventArgs e) { 
         UserControl1 UserControl1Control = d as UserControl1; 
         UserControl1Control.OnSetTextChanged(e); 
      } 
		
      private void OnSetTextChanged(DependencyPropertyChangedEventArgs e) { 
         tbTest.Text = e.NewValue.ToString(); 
      }  
   } 
}

Di seguito è riportato il file XAML in cui TextBlock è definito come controllo utente e la proprietà Text gli verrà assegnata dalla proprietà di dipendenza SetText.

Il codice XAML seguente crea un controllo utente e lo inizializza SetText proprietà di dipendenza.

<Window x:Class = "WpfApplication3.MainWindow" 
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml" 
   xmlns:views = "clr-namespace:WpfApplication3"
   Title = "MainWindow" Height = "350" Width = "604"> 
	
   <Grid> 
      <views:UserControl1 SetText = "Hellow World"/> 
   </Grid> 
	
</Window>

Eseguiamo questa applicazione. Puoi immediatamente osservare che nella nostra MainWindow, la proprietà di dipendenza per il controllo utente è stata utilizzata con successo come testo.