WPF - właściwości zależności

W aplikacjach WPF właściwość zależności jest określonym typem właściwości, który rozszerza właściwość CLR. Wykorzystuje określone funkcje dostępne w systemie właściwości WPF.

Klasa, która definiuje właściwość zależności, musi być dziedziczona z klasy DependencyObjectklasa. Wiele klas kontrolek interfejsu użytkownika, które są używane w języku XAML, pochodzi zDependencyObject klasy i obsługują właściwości zależności, np. klasa Button obsługuje IsMouseOver właściwość zależności.

Poniższy kod XAML tworzy przycisk z niektórymi właściwościami.

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

Rozszerzenie znacznika x: Type w języku XAML ma podobną funkcjonalność, jak typeof () w C #. Jest używany, gdy określono atrybuty przyjmujące typ obiektu, na przykład <Style TargetType = "{x: Type Button}">

Gdy powyższy kod zostanie skompilowany i wykonany, otrzymasz następujący kod MainWindow. Kiedy mysz znajduje się nad przyciskiem, zmienia kolor pierwszego planu przycisku. Kiedy mysz opuszcza przycisk, przywraca on swój pierwotny kolor.

Dlaczego potrzebujemy właściwości zależności

Właściwość zależności daje wszelkiego rodzaju korzyści, gdy używasz jej w swojej aplikacji. Właściwość zależności może być używana przez właściwość CLR w następujących scenariuszach -

Jeśli chcesz ustawić styl
Jeśli chcesz powiązać dane
Jeśli chcesz ustawić za pomocą zasobu (statycznego lub dynamicznego)
Jeśli chcesz wspierać animację

Zasadniczo właściwości zależności oferują wiele funkcji, których nie uzyskasz przy użyciu właściwości CLR.

Główna różnica między dependency properties i inne CLR properties są wymienione poniżej -

Właściwości CLR mogą bezpośrednio odczytywać / zapisywać z prywatnego elementu członkowskiego klasy przy użyciu getter i setter. Natomiast właściwości zależności nie są przechowywane w obiekcie lokalnym.
Właściwości zależności są przechowywane w słowniku par klucz / wartość, który jest udostępniany przez klasę DependencyObject. Oszczędza również dużo pamięci, ponieważ przechowuje właściwość po zmianie. Może być również powiązany w XAML.

Niestandardowe właściwości zależności

W środowisku .NET można również zdefiniować niestandardowe właściwości zależności. Wykonaj kroki podane poniżej, aby zdefiniować niestandardową właściwość zależności w C #.

Zadeklaruj i zarejestruj swój dependency property z rejestrem wywołań systemowych.
Zapewnić setter i getter dla nieruchomości.
Zdefiniuj static handler który obsłuży wszelkie zmiany zachodzące na całym świecie
Zdefiniuj plik instance handler który obsłuży wszelkie zmiany, które nastąpią w tej konkretnej instancji.

Poniższy kod C # definiuje właściwość zależności, aby ustawić SetText właściwość kontrolki użytkownika.

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

Oto plik XAML, w którym TextBlock jest zdefiniowany jako kontrolka użytkownika, a właściwość Text zostanie do niego przypisana przez właściwość zależności SetText.

Poniższy kod XAML tworzy kontrolkę użytkownika i inicjuje jej SetText właściwość zależności.

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

Uruchommy tę aplikację. Możesz od razu zauważyć, że w naszym MainWindow właściwość zależności dla kontrolki użytkownika została pomyślnie użyta jako Text.