XAML: propiedades de dependencia

Una propiedad de dependencia es un tipo específico de propiedad donde el valor es seguido por un sistema de propiedades agudo que también es parte de la aplicación Windows Runtime. Una clase que define una propiedad de dependencia debe heredarse de la clase DependencyObject.

Muchas de las clases de control de la IU que se usan en XAML se derivan de la clase DependencyObject y admiten propiedades de dependencia. El siguiente código XAML crea un botón con algunas propiedades.

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

La extensión de marcado x: Type en XAML tiene una funcionalidad similar como typeof () en C #. Se utiliza cuando se especifican atributos que toman el tipo de objeto, como <Style TargetType = "{x: Type Button}">

Cuando compile y ejecute el código anterior, producirá la siguiente ventana principal. Cuando el mouse está sobre el botón, cambiará el color de primer plano del botón. Cuando el ratón deja el botón, volverá a cambiar a su color original.

La principal diferencia entre las propiedades de dependencia y otras propiedades CLR son:

Las propiedades de CLR pueden leer / escribir directamente desde el miembro privado de una clase usando getter y setter. En el caso de propiedades de dependencia, no se almacena en un objeto local.
Las propiedades de dependencia se almacenan en un diccionario de pares clave / valor proporcionado por la clase DependencyObject.
También ahorra mucha memoria porque almacena la propiedad cuando se cambia.
También se puede enlazar en XAML.

En .NET Framework, también se pueden definir propiedades de dependencia personalizadas. Estos son los pasos para definir la propiedad de dependencia personalizada en C #.

Declare y registre su propiedad de dependencia con el registro de llamadas del sistema.
Proporcione el setter y getter de la propiedad.
Defina un controlador estático para manejar cualquier cambio que ocurra globalmente.
Defina un controlador de instancia para manejar cualquier cambio que ocurra en esa instancia en particular.

A continuación se muestra el código en C # para la propiedad de dependencia que se definió para establecer la propiedad SetText del control de usuario.

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

Aquí está el archivo XAML en el que TextBlock se define como un control de usuario y la propiedad de dependencia SetText le asignará la propiedad Text.

El siguiente código XAML crea un control de usuario con la inicialización de su propiedad de dependencia SetText y algunas otras propiedades.

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

Ejecutemos esta aplicación y podrá ver inmediatamente en nuestra ventana principal que la propiedad de dependencia para el control del usuario se ha utilizado con éxito como texto.

↰ Previous page Next page ↱