Visão geral sobre propriedades de dependência

Windows Presentation Foundation (WPF) fornece um conjunto de serviços que podem ser usados para estender a funcionalidade de uma propriedade common language runtime (CLR). Coletivamente, esses serviços são tipicamente referenciados como sistema de propriedades WPF. Uma propriedade com o apoio de WPF sistema de propriedades é conhecido sistema autônomo um propriedade de dependência. Esta visão geral descreve o WPF sistema de propriedades e sistema autônomo recursos de um propriedade de dependência. Isso inclui sistema autônomo usar existente Propriedades de dependência in Extensible Application Markup Language (XAML) e no código. Esta visão geral também apresenta aspectos especializados de propriedades de dependência, como metadados de propriedade de dependência e como criar sua própria propriedade de dependência em uma classe personalizada.

Este tópico contém as seguintes seções.

• Pré-requisitos
• Propriedades de dependência e propriedades CLR
• Propriedades de Dependência Com Propriedades CLR
• Configurando Valores de Propriedades
• Funcionalidade de Propriedade Fornecida por uma propriedade de dependência
• Precedência de valores de propriedade de dependência
• Aprender mais sobre propriedades de dependência
• Tópicos relacionados

Pré-requisitos

Este tópico pressupõe que você tem algum conhecimento básico de CLR e programação orientada à objetos. Para que você siga os exemplos deste tópico, você também deve entender XAML e saber como escrever aplicações WPF. Para obter mais informações, consulte Getting Started with Windows Presentation Foundation.

Propriedades de dependência e propriedades CLR

Em WPF,propriedades normalmente são expostas como propriedades de common language runtime (CLR). Em um nível básico, você pode interagir com essas propriedades diretamente e nunca saberá que elas são implementados como uma propriedade de dependência. No entanto, você deve se familiarizar com alguns ou todos os recursos do sistema o Propriedade do WPF, para que você possa aproveitar esses recursos.

O objetivo das propriedades de dependência é fornecer uma maneira para calcular o valor de uma propriedade com base no valor de outras entradas. Essas outras entradas podem incluir propriedades do sistema, como os temas e preferências do usuário, mecanismos determinação just-in-time de propriedades como associação de dados e animações/storyboards, uso múltiplo de modelos, como recursos e estilos ou valores conhecidos por meio de relações pai-filho com outros elementos na árvore do elemento. Além disso, uma propriedade de dependência pode ser implementada para fornecer validação independente, valores padrão, retornos de chamada que monitoram alterações em outras propriedades e um sistema que pode forçar valores de propriedade potencialmente com base nas informações em tempo de execução. As classes derivadas também podem alterar algumas características específicas de uma propriedade existente substituindo metadados de propriedade de dependência, em vez de substituir a implementação real da propriedades existentes ou criar novas propriedades.

Na referência do SDK, você pode identificar qual propriedade é uma propriedade de dependência pela presença da seção Informação sobre Propriedade de Dependência na página da referência gerenciada para essa propriedade. A seção Informações de Propriedade Dependência inclui um link para o campo identificador da DependencyProperty para aquela propriedade de dependência e também inclui uma lista das opções de metadados definidas para essa propriedade, substituição por classe de informações e outros detalhes .

Propriedades de Dependência Com Propriedades CLR

Propriedades de Dependência e o sistema a propriedade WPF estendem funcionalidades de propriedade fornecendo um tipo que suporta uma propriedade, como uma implementação alternativa para o modelo padrão do suporte de propriedade com um campo particular. O nome desse tipo é DependencyProperty. O outro tipo importante que define o sistema de propriedade do WPF é DependencyObject. DependencyObject define a classe base que pode registrar e possuir uma propriedade de dependência.

A seguir, há um sumário da terminologia que é usada nesta documentação software development kit (SDK) ao abordar as Propriedades de Dependência:

• Propriedade de dependência: Uma propriedade que é feita por um DependencyProperty.

• Identificador de propriedade de dependência: A DependencyProperty ocorrência, que é obtida sistema autônomo um valor retornado ao registrar um propriedade de dependência e, em seguida, armazenado sistema autônomo um membro de uma classe. Esse identificador é usado como um parâmetro em vários APIs que interagem com o sistema a propriedade WPF.

• CLR "empacotador": O real get e conjunto implementações da propriedade. Essas implementações incorporam o identificador de propriedade de dependência usando-o nas chamadas de GetValue e SetValue, assim, fornecendo o suporte para a propriedade usando o sistema a propriedade do WPF.

O exemplo a seguir define a propriedade de dependência IsSpinning e mostra o relacionamento do identificador do DependencyProperty para a propriedade que ela suporta.

public static readonly DependencyProperty IsSpinningProperty = 
    DependencyProperty.Register(


...


    );
public bool IsSpinning
{
    get { return (bool)GetValue(IsSpinningProperty); }
    set { SetValue(IsSpinningProperty, value); }
}

O convenção de nomeclatura do seu backup e a propriedade DependencyProperty Campo é importante. O nome do campo é sempre o nome da propriedade, com o sufixo Property acrescentado. Para obter mais informações sobre essa convenção e os motivos para ele, consulte Propriedades de Dependência Personalizada.

Configurando Valores de Propriedades

Você pode definir propriedades em código ou em XAML.

Definindo valores da propriedade em XAML

O exemplo XAML a seguir especifica a cor do plano de fundo de um botão como vermelho. Este exemplo ilustra um caso onde o valor da sequência de caracteres simples para um atributo XAML sofre conversão de tipo pelo carregador do XAML para um tipo de WPF (uma Color, por meio de um SolidColorBrush) no código gerado.

<Button Background="Red" Content="Button!"/>

XAML oferece suporte uma variedade de formas de sintaxe para definir propriedades. Qual sintaxe usar para uma determinada propriedade dependerá do tipo de valor que uma propriedade usa, assim como outros fatores como a presença de um conversor de tipos. Para obter mais informações sobre sintaxe XAML para configuração da propriedade, consulte XAML Overview e Terminologia de sintaxe XAML.

Como um exemplo de sintaxe não atributo, o exemplo a seguir XAML mostra outro botão de plano de fundo. Desta vez em vez definir uma cor sólida simples, o plano de fundo é definido para uma imagem, com um elemento que representa a imagem e a origem da imagem especificada como um atributo do elemento aninhado. Este é um exemplo da sintaxe de propriedade elemento.

<Button Content="Button!">
  <Button.Background>
    <ImageBrush ImageSource="wavy.jpg"/>
  </Button.Background>
</Button>

Definindo propriedades no código

Definir valores de propriedade de dependência no código é normalmente apenas uma chamada para a implementação exposta pelo "wrapper" CLR.

Button myButton = new Button();
myButton.Width = 200.0;

Obter um valor da propriedade também é basicamente uma chamada para a implementação wrapper de "GET":

double whatWidth;
whatWidth = myButton.Width;

Você também pode chamar a APIs do sistema a propriedade GetValue e SetValue diretamente. Isso não é geralmente necessário se você estiver usando propriedades existentes (os conteúdos adicionais são mais conveniente e fornecem melhor exposição de propriedade para ferramentas de desenvolvedor), mas chamar APIs diretamente é apropriado para determinados cenários.

Propriedades podem ser definidas também em XAML e, então, acessadas mais tarde no código, por meio do código subjacente. Para obter detalhes, consulte:Code-Behind e XAML.

Funcionalidade de Propriedade Fornecida por uma propriedade de dependência

Um propriedade de dependência fornece funcionalidade que estende a funcionalidade de uma propriedade em oposição a uma propriedade que é feita por um campo. Geralmente, cada funcionalidade representa ou oferece suporte a um recurso específico do conjunto de recursos de WPF:

• Recursos

• Ligação de Dados

• Estilos

• Animações

• Substituição de metadados

• Herança de Valor de Propriedade

• Integração com WPF Designer

Recursos

Um valor de propriedade de dependência pode ser definida fazendo referência a um recurso. Recursos geralmente são especificados como elementos filho de uma elemento raiz de página, ou do aplicativo (esses locais permitem o acesso mais conveniente para o recurso). O exemplo a seguir mostra como definir um recurso SolidColorBrush.

<DockPanel.Resources>
  <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
</DockPanel.Resources>

Depois que o recurso é definido, você pode fazer referência o recursos e usá-lo para fornecer um valor da propriedade:

<Button Background="{DynamicResource MyBrush}" Content="I am gold" />

Este recurso específico é referenciado como um Extensão de marcação DynamicResource (no XAML, você pode usar qualquer uma referência de recurso estática ou dinâmica). Para usar uma referência de recurso dinâmico, você deve definindo para uma propriedade de dependência, portanto é especificamente a referência de recurso dinâmico que é permitida pelo sistema o propriedade do WPF. Para obter mais informações, consulte Visão geral sobre Recursos.

Observação:
Recursos são tratados sistema autônomo um valor de local, o que significa que se você conjunto outro valor local, você eliminará o referência de recurso . Para obter detalhes, consulte Precedência de valores de propriedade de dependência.

Ligação de Dados

Um propriedade de dependência pode fazer referência a um valor por associação de dados. Ligação de dados funciona através de uma sintaxe específica de marcação de extensão no XAML, ou o objeto Binding no código. Com associação de dados, a determinação do valor final da propriedade é adiada até o tempo de execução, cada vez que o valor é obtido de uma fonte de dados.

O exemplo a seguir define a propriedade Content para um Button, usando uma ligação XAML. A vinculação usa um contexto de dados herdado e uma fonte de dados XmlDataProvider (não mostrado). A vinculação própria especifica da fonte de propriedades desejadas por XPath dentro da fonte de dados.

<Button Content="{Binding XPath=Team/@TeamName}"/>

Observação:
B indings são tratadas sistema autônomo um valor de local , que significa que, se você conjunto outro valor local, você eliminará a ligação. Para obter detalhes, consulte Precedência de valores de propriedade de dependência.

Propriedades de dependência, ou a classe DependencyObject,originalmente não têm suporte INotifyPropertyChanged para fins de produzir notificações de alterações na fonte valor da propriedade do DependencyObject nas operações de associação de dados Para obter mais informações sobre como criar propriedades para uso em associação de dados que possaeportar as alterações para um destino de associação de dados, consulte Revisão de Associação de Dados.

Estilos

Estilos e modelos são duas das principais situações que motivam o uso das propriedades de dependência. Os estilos são particularmente úteis para definir propriedades que definem aplicativo interface do usuário (UI). Estilos geralmente são definidos como recursos de XAML. Estilos interagem com o sistema propriedade porque eles geralmente contêm "setters" para propriedades específica, bem como "disparadores" que alteram um valor da propriedade com base no valor em tempo real para outra propriedade.

O exemplo a seguir cria um estilo muito simples (que seria definido em um dicionário de Resources, não mostrado), em seguida, aplica esse estilo diretamente para a propriedade Style para um Button. O setter dentro de estilo define a propriedade Background de um Button estilizado para verde.

<Style x:Key="GreenButtonStyle">
  <Setter Property="Control.Background" Value="Green"/>
</Style>

<Button Style="{StaticResource GreenButtonStyle}">I am green!</Button>

Para obter mais informações, consulte Styling and Templating.

Animações

As propriedades de dependência podem ser animadas. Quando uma animação é aplicada e estiver sendo executada, o valor animado opera com uma precedência maior do que qualquer valor (como um valor local) que a propriedade tem caso contrário.

O exemplo a seguir anima o Background em uma propriedade Button (Tecnicamente, o Background é animado usando a sintaxe da propriedade elemento para especificar um SolidColorBrush branco como o Background, em seguida, a propriedade Color do que SolidColorBrush é a propriedade que é animada diretamente).

<Button>I am animated
  <Button.Background>
    <SolidColorBrush x:Name="AnimBrush"/>
  </Button.Background>
  <Button.Triggers>
    <EventTrigger RoutedEvent="Button.Loaded">
      <BeginStoryboard>
        <Storyboard>
          <ColorAnimation
            Storyboard.TargetName="AnimBrush" 
            Storyboard.TargetProperty="(SolidColorBrush.Color)"
            From="Red" To="Green" Duration="0:0:5" 
            AutoReverse="True" RepeatBehavior="Forever" />
        </Storyboard>
      </BeginStoryboard>
    </EventTrigger>
  </Button.Triggers>
</Button>

Para obter mais informações sobre animação de propriedades, consulte Revisão de Animação e Visão geral sobre Storyboards.

Substituição de metadados

Você pode alterar determinados comportamentos de uma propriedade de dependência substituindo os metadados para essa propriedade quando você derivar da classe que registra a propriedade de dependência originalmente. Substituir os metadados depende do identificador de DependencyProperty. Substituir os metadados não requer reimplementar a propriedade. A alteração de metadados é tratada nativamente pelo sistema de propriedade; cada classe potencialmente contém metadados individuais para todas as propriedades que são herdadas de classes base, por tipo.

O exemplo a seguir substitui os metadados para uma propriedade de dependência DefaultStyleKey. Substituir essa determinada propriedade de dependência de metadados é parte de um padrão de implementação que cria controles que pode usar estilos de temas padrão.

public class SpinnerControl : ItemsControl
{
    static SpinnerControl()
    {
        DefaultStyleKeyProperty.OverrideMetadata(
            typeof(SpinnerControl), 
            new FrameworkPropertyMetadata(typeof(SpinnerControl))
        );
    }
}

Para obter mais informações sobre a substituição ou obtenção de metadados de propriedade, consulte Metadados de Propriedade de Dependência.

Herança de Valor de Propriedade

Um elemento pode herdar o valor de um propriedade de dependência de seu pai na árvore.

Observação:

P comportamento da herança ropriedade valor não está habilitado globalmente para todas as propriedades de dependência , porque o time de cálculo herança de tem algum impacto no desempenho . P herança de valor ropriedade tipicamente só é ativada para propriedades onde um determinado cenário sugere que herança de valor da propriedade é apropriada . Você pode determinar se um propriedade de dependência herda olhando a seção Informações de propriedade de dependência para aquela propriedade de dependência na referência do SDK.

O exemplo a seguir mostra uma ligação e define a propriedade DataContext que especifica a origem da associação, que não foi mostrada no exemplo anterior de associação. O valor da propriedade DataContext herda, portanto quaisquer ligações subsequentes nos elementos filho não precisam respeitar a fonte que é especificado como DataContext no elemento StackPanel pai.

<StackPanel Canvas.Top="50" DataContext="{Binding Source={StaticResource XmlTeamsSource}}">
  <Button Content="{Binding XPath=Team/@TeamName}"/>
</StackPanel>

Para obter mais informações, consulte Herança de Valor de Propriedade.

Integração com o WPF Designer

Um controle personalizado com propriedades que são implementadas como propriedades de dependência receberá suporte de Windows Presentation Foundation (WPF) Designer for Visual Studio apropriado. Um exemplo é a capacidade para editar as propriedades diretas e de dependência anexadas à janela Properties. Para obter mais informações, consulte Visão geral sobre criação de controles.

Precedência de valores de propriedade de dependência

Quando você receber o valor de uma propriedade de dependência, você provavelmente está obtendo um valor que foi definido na propriedade por meio de qualquer uma das outras propriedade com base nas entradas que participam do sistema a propriedade do WPF. Precedência de valor da propriedade de dependência existe para que uma variedade de cenários para como propriedades obtêm seus valores possam interagir de forma previsível.

Considere o exemplo a seguir: O exemplo inclui um estilo que se aplica a todos os botões e suas propriedades Background, mas, em seguida, especifica um botão com um valor definido Background localmente.

Observação:
A documentação SDK usa os termos "Valor local" ou "definir valor localmente" ocasionalmente ao abordar as propriedades de dependência. A localmente conjunto é um valor da propriedade é conjunto diretamente em uma instância do objeto no código ou sistema autônomo um atributo em um elemento XAML.

Efetivamente, para o primeiro botão, a propriedade está definida duas vezes, mas apenas um valor se aplica: o valor com a prioridade mais alta. Um valor definido localmente tem a precedência mais alta (exceto para uma animação em execução, mas nenhuma animação aplica-se no exemplo) e, portanto, o valor definido localmente é usado em vez do valor de setter de estilo para o plano de fundo no primeiro botão. O segundo botão não tem nenhum valor local (e nenhum outro valor com precedência maior do que um setter de estilo) e, portanto, o plano de fundo do botão vem do setter de estilo.

<StackPanel>
  <StackPanel.Resources>
    <Style x:Key="{x:Type Button}" TargetType="{x:Type Button}">
     <Setter Property="Background" Value="Red"/>
    </Style>
  </StackPanel.Resources>
  <Button Background="Green">I am NOT red!</Button>
  <Button>I am styled red</Button>
</StackPanel>

Por que precedência de propriedade dependência existe?

Normalmente, você não revisaria estilos para sempre aplicar e ocultar mesmo um valor definido localmente de um elemento individual (caso contrário, ele seria muito difícil de usar estilos ou elementos em geral). Portanto, os valores provenientes de estilos operam em uma precedência inferior que a de um valor definido localmente. Para obter uma lista mais completa das propriedades de dependência de onde um valor efetivo de propriedade de dependência pode vir, consulte Precedência de valores de propriedade de dependência.

Observação:
T Eis algumas propriedades definidas na WPF elementos que não são propriedades de dependência. Propriedades foram implementadas sistema autônomo propriedades de dependência somente quando havia precisa oferecer suporte a pelo menos um dos cenários habilitados por sistema de propriedade: ligação de dados, estilos, animação, suporte de valor padrão, herança, propriedades anexadas ou invalidação.

Aprender mais sobre propriedades de dependência

• Uma propriedade anexa é um tipo de propriedade que suporta uma sintaxe especializada no XAML. Uma propriedade anexada geralmente não tem uma correspondência 1: 1 com a propriedade common language runtime (CLR) e não é necessariamente um propriedade de dependência. A finalidade típica de uma propriedade anexa é permitir elementos filhos reportar valores de propriedade para um elemento pai, mesmo se o elemento pai e o elemento filho não possuem essa propriedade como parte de listagens de membros de classe. Um cenário principal é habilitar elementos filhos para informar o pai como devem ser apresentados no UI; para obter um exemplo, consulte Dock ou Left. Para obter detalhes, consulte:Attached Properties Overview.

• Fesenvolvedores de componente ou desenvolvedores de aplicativos podem desejar criar suas próprias propriedade de dependência para habilitar recursos como associação de dados ou suporte a estilos, ou para invalidação e suporte de coerção de valor. Para obter detalhes, consulte:Propriedades de Dependência Personalizada.

• As propriedades de dependência geralmente devem ser consideradas como propriedades públicas, acessíveis ou menos pelo menos encontráveis por qualquer chamador que tem acesso a uma instância. Para obter detalhes, consulte:Segurança de Propriedades de Dependência.

Consulte também

Conceitos

Propriedades de Dependência Personalizada

Read-Only Dependency Properties

XAML Overview

Arquitetura WPF