WPF - Propriedades de Dependência

Em aplicativos WPF, a propriedade de dependência é um tipo específico de propriedade que estende a propriedade CLR. Aproveita as funcionalidades específicas disponíveis no sistema de propriedades WPF.

Uma classe que define uma propriedade de dependência deve ser herdada do DependencyObjectclasse. Muitas das classes de controles de IU que são usadas em XAML são derivadas doDependencyObject classe e eles suportam propriedades de dependência, por exemplo, a classe Button suporta IsMouseOver propriedade de dependência.

O código XAML a seguir cria um botão com algumas propriedades.

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

A extensão de marcação x: Type em XAML tem uma funcionalidade semelhante, como typeof () em C #. É usado quando são especificados atributos que assumem o tipo do objeto, como <Style TargetType = "{x: Type Button}">

Quando o código acima for compilado e executado, você obterá o seguinte MainWindow. Quando o mouse estiver sobre o botão, ele mudará a cor do primeiro plano de um botão. Quando o mouse sai do botão, ele volta à cor original.

Por que precisamos de propriedades de dependência

A propriedade de dependência oferece todos os tipos de benefícios quando você a usa em seu aplicativo. A propriedade de dependência pode ser usada em uma propriedade CLR nos seguintes cenários -

Se você deseja definir o estilo
Se você quiser vinculação de dados
Se você deseja definir com um recurso (um recurso estático ou dinâmico)
Se você quiser apoiar animação

Basicamente, as Propriedades de dependência oferecem muitas funcionalidades que você não obterá usando uma propriedade CLR.

A principal diferença entre dependency properties e outro CLR properties estão listados abaixo -

As propriedades CLR podem ler / gravar diretamente do membro privado de uma classe usando getter e setter. Em contraste, as propriedades de dependência não são armazenadas no objeto local.
As propriedades de dependência são armazenadas em um dicionário de pares de chave / valor que é fornecido pela classe DependencyObject. Ele também economiza muita memória porque armazena a propriedade quando alterada. Ele também pode ser vinculado a XAML.

Propriedades de dependência personalizadas

No .NET framework, as propriedades de dependência personalizadas também podem ser definidas. Siga as etapas fornecidas a seguir para definir a propriedade de dependência personalizada em C #.

Declare e registre seu dependency property com registro de chamadas do sistema.
Proporciona a setter e getter para a propriedade.
Defina um static handler que irá lidar com quaisquer mudanças que ocorram globalmente
Defina um instance handler que tratará de quaisquer alterações que ocorram nessa instância específica.

O código C # a seguir define uma propriedade de dependência para definir o SetText propriedade do controle do usuário.

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

Aqui está o arquivo XAML no qual o TextBlock é definido como um controle de usuário e a propriedade Text será atribuída a ele pela propriedade de dependência SetText.

O código XAML a seguir cria um controle de usuário e inicializa seu SetText propriedade de dependência.

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

Vamos rodar este aplicativo. Você pode observar imediatamente que em nossa MainWindow, a propriedade de dependência para controle de usuário foi usada com sucesso como um Texto.