XAML - Propriétés de dépendance

Une propriété de dépendance est un type spécifique de propriété où la valeur est suivie d'un système de propriétés précis qui fait également partie de l'application Windows Runtime. Une classe qui définit une propriété de dépendance doit être héritée de la classe DependencyObject.

De nombreuses classes de contrôle d'interface utilisateur utilisées dans XAML sont dérivées de la classe DependencyObject et prennent en charge les propriétés de dépendance. Le code XAML suivant crée un bouton avec certaines propriétés.

<Window x:Class = "XAMLDependencyProperty.MainWindow"
   xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x = "http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:local = "clr-namespace:XAMLDependencyProperty"
   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'extension de balisage x: Type en XAML a une fonctionnalité similaire à celle de typeof () en C #. Il est utilisé lorsque des attributs sont spécifiés qui prennent le type de l'objet tel que <Style TargetType = "{x: Type Button}">

Lorsque vous compilez et exécutez le code ci-dessus, il produira le MainWindow suivant. Lorsque la souris est sur le bouton, cela changera la couleur de premier plan du bouton. Lorsque la souris quitte le bouton, elle reprend sa couleur d'origine.

La principale différence entre les propriétés de dépendance et les autres propriétés CLR est:

Les propriétés CLR peuvent directement lire / écrire à partir du membre privé d'une classe en utilisant getter et setter. En cas de propriétés de dépendance, il n'est pas stocké dans un objet local.
Les propriétés de dépendance sont stockées dans un dictionnaire de paires clé / valeur fourni par la classe DependencyObject.
Il économise également beaucoup de mémoire car il stocke la propriété lorsqu'elle est modifiée.
Il peut également être lié en XAML.

Dans le framework .NET, les propriétés de dépendance personnalisées peuvent également être définies. Voici les étapes pour définir la propriété de dépendance personnalisée en C #.

Déclarez et enregistrez votre propriété de dépendance avec le registre des appels système.
Fournissez le setter et le getter pour la propriété.
Définissez un gestionnaire statique pour gérer toutes les modifications qui se produisent globalement.
Définissez un gestionnaire d'instances pour gérer toutes les modifications apportées à cette instance particulière.

Vous trouverez ci-dessous le code en C # pour la propriété de dépendance qui a défini pour définir la propriété SetText du contrôle utilisateur.

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

Voici le fichier XAML dans lequel le TextBlock est défini en tant que contrôle utilisateur et la propriété Text lui sera affectée par la propriété de dépendance SetText.

Le code XAML suivant crée un contrôle utilisateur avec l'initialisation de sa propriété de dépendance SetText et d'autres propriétés.

<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>

Exécutons cette application et vous pouvez voir immédiatement dans notre MainWindow que la propriété de dépendance pour le contrôle utilisateur a été utilisée avec succès en tant que texte.