WPF: propiedades de dependencia

En las aplicaciones WPF, la propiedad de dependencia es un tipo específico de propiedad que amplía la propiedad CLR. Aprovecha las funcionalidades específicas disponibles en el sistema de propiedades de WPF.

Una clase que define una propiedad de dependencia debe heredarse de la DependencyObjectclase. Muchas de las clases de controles de IU que se usan en XAML se derivan de laDependencyObject clase y admiten propiedades de dependencia, por ejemplo, la clase Button admite la IsMouseOver propiedad de dependencia.

El siguiente código XAML crea un botón con algunas propiedades.

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

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

Cuando se compila y ejecuta el código anterior, obtendría lo siguiente MainWindow. Cuando el mouse está sobre el botón, cambiará el color de primer plano de un botón. Cuando el ratón deja el botón, vuelve a su color original.

Por qué necesitamos propiedades de dependencia

La propiedad de dependencia le brinda todo tipo de beneficios cuando la usa en su aplicación. La propiedad de dependencia se puede utilizar sobre una propiedad CLR en los siguientes escenarios:

Si quieres establecer el estilo
Si desea vinculación de datos
Si desea establecer con un recurso (un recurso estático o dinámico)
Si quieres apoyar la animación

Básicamente, las propiedades de dependencia ofrecen muchas funcionalidades que no obtendrá al usar una propiedad CLR.

La principal diferencia entre dependency properties y otra CLR properties se enumeran a continuación:

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

Propiedades de dependencia personalizadas

En .NET Framework, también se pueden definir propiedades de dependencia personalizadas. Siga los pasos que se indican a continuación para definir la propiedad de dependencia personalizada en C #.

Declare y registre su dependency property con registro de llamadas del sistema.
Proporcionar la setter y getter para la propiedad.
Definir un static handler que manejará cualquier cambio que ocurra globalmente
Definir un instance handler que manejará cualquier cambio que ocurra en esa instancia en particular.

El siguiente código C # define una propiedad de dependencia para establecer el SetText propiedad del control del 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 Text le será asignada por la propiedad de dependencia SetText.

El siguiente código XAML crea un control de usuario e inicializa su SetText propiedad de dependencia.

<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. Puede observar inmediatamente que en nuestra ventana principal, la propiedad de dependencia para el control del usuario se ha utilizado con éxito como texto.

↰ Previous page Next page ↱