XAML - Abhängigkeitseigenschaften

Eine Abhängigkeitseigenschaft ist ein bestimmter Eigenschaftstyp, bei dem auf den Wert ein scharfes Eigenschaftssystem folgt, das auch Teil der Windows-Laufzeit-App ist. Eine Klasse, die eine Abhängigkeitseigenschaft definiert, muss von der DependencyObject-Klasse geerbt werden.

Viele der in XAML verwendeten UI-Steuerungsklassen sind von der DependencyObject-Klasse abgeleitet und unterstützen Abhängigkeitseigenschaften. Der folgende XAML-Code erstellt eine Schaltfläche mit einigen Eigenschaften.

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

Die Markup-Erweiterung x: Type in XAML verfügt über eine ähnliche Funktionalität wie typeof () in C #. Es wird verwendet, wenn Attribute angegeben werden, die den Typ des Objekts annehmen, z. B. <Style TargetType = "{x: Type Button}">

Wenn Sie den obigen Code kompilieren und ausführen, wird das folgende MainWindow erstellt. Wenn sich die Maus über der Schaltfläche befindet, wird die Vordergrundfarbe der Schaltfläche geändert. Wenn die Maus die Taste verlässt, nimmt sie wieder ihre ursprüngliche Farbe an.

Der Hauptunterschied zwischen Abhängigkeitseigenschaften und anderen CLR-Eigenschaften ist -

• CLR-Eigenschaften können mithilfe von direkt vom privaten Mitglied einer Klasse lesen / schreiben getter und setter. Bei Abhängigkeitseigenschaften wird es nicht in einem lokalen Objekt gespeichert.

• Abhängigkeitseigenschaften werden in einem Wörterbuch von Schlüssel / Wert-Paaren gespeichert, das von der DependencyObject-Klasse bereitgestellt wird.

• Es spart auch viel Speicher, da es die Eigenschaft speichert, wenn es geändert wird.

• Es kann auch in XAML gebunden werden.

In .NET Framework können auch benutzerdefinierte Abhängigkeitseigenschaften definiert werden. Hier sind die Schritte zum Definieren einer benutzerdefinierten Abhängigkeitseigenschaft in C #.

• Deklarieren und registrieren Sie Ihre Abhängigkeitseigenschaft im Systemaufrufregister.

• Stellen Sie den Setter und Getter für die Eigenschaft bereit.

• Definieren Sie einen statischen Handler, um alle global auftretenden Änderungen zu verarbeiten.

• Definieren Sie einen Instanzhandler, um alle Änderungen zu behandeln, die an dieser bestimmten Instanz auftreten.

Im Folgenden wird der Code in C # für die Abhängigkeitseigenschaft angegeben, der zum Festlegen der SetText-Eigenschaft des Benutzersteuerelements definiert wurde.

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

Hier ist die XAML-Datei, in der der TextBlock als Benutzersteuerelement definiert ist und ihm die Text-Eigenschaft von der SetText-Abhängigkeitseigenschaft zugewiesen wird.

Der folgende XAML-Code erstellt ein Benutzersteuerelement mit der Initialisierung seiner SetText-Abhängigkeitseigenschaft und einiger anderer Eigenschaften.

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

Lassen Sie uns diese Anwendung ausführen und Sie können sofort in unserem MainWindow sehen, dass die Abhängigkeitseigenschaft für die Benutzersteuerung erfolgreich als Text verwendet wurde.