Visão geral das propriedades anexadas

Visão geral das propriedades anexadas

[ Este artigo destina-se aos desenvolvedores do Windows 8.x e do Windows Phone 8.x que escrevem aplicativos do Windows Runtime. Se você estiver desenvolvendo para o Windows 10, consulte documentação mais recente ]

Uma propriedade anexada é um conceito de XAML. Seu conceito é similar a uma propriedade global que pode ser definida para qualquer elemento de objeto em XAML. Tipicamente, as propriedades anexadas são definidas como uma forma especializada de propriedade de dependência que não tem um wrapper de propriedade convencional no modelo de objeto do tipo de proprietário.

Pré-requisitos

Consideramos que você entende o conceito básico das propriedades de dependência e já leu a Visão geral das propriedades de dependência.

Propriedades anexadas em XAML

As propriedades anexadas existem principalmente porque habilitaram uma sintaxe XAML. Em XAML, você define propriedades anexadas usando a sintaxe AttachedPropertyProvider.PropertyName. Aqui está um exemplo sobre como definir o Canvas.Left em XAML.



<Canvas>
  <Button Canvas.Left="50">Hello</Button>
</Canvas>

Observe que o uso é um tanto similar a uma propriedade estática; sempre há uma referência ao tipo Canvas que possui e registra a propriedade anexada, e nenhuma referência a qualquer instância pelo nome.

Observação  Estamos apenas usando Canvas.Left como um exemplo de propriedade anexada sem explicar totalmente por que devemos usá-lo. Se você quiser saber mais sobre para que serve o Canvas.Left e como Canvas manipula seus filhos de layout, veja o tópico de referência de Canvas ou Guia de início rápido: definindo layouts.
 

Por que usar propriedades anexadas?

As propriedades anexadas são uma maneira de evitar as convenções de codificação que podem impedir que objetos diferentes em um relacionamento transmitam informações entre si em tempo de execução. É certamente possível colocar as propriedades em uma classe base comum para que cada objeto possa simplesmente obter e definir essa propriedade. Mas por fim o grande número de cenários em que você pode querer fazer isso inchará suas classes base com propriedades compartilháveis. Isso pode inclusive introduzir casos em que talvez haja duas centenas de descendentes tentando usar uma propriedade. Isso não é um ótimo design de classe. Para abordar essa questão, o conceito da propriedade anexada permite que um objeto atribua um valor para uma propriedade que sua própria estrutura de classe não define. A classe de definição pode ler o valor de objetos filho em tempo de execução depois que vários objetos são criados nos relacionamentos em uma árvore de objetos.

Por exemplo, elementos filho podem usar propriedades anexadas para informar o elemento pai sobre o modo como são apresentados na interface do usuário. Este é o caso da propriedade anexada Canvas.Left. Canvas.Left foi criada como uma propriedade anexada porque foi definida em elementos contidos em um elemento Canvas, em vez de no próprio Canvas. Assim, qualquer elemento filho possível usa as propriedades Canvas.Left e Canvas.Top para especificar o deslocamento do layout desejado dentro do pai do contêiner de layout do Canvas. As propriedades anexadas fazem com que esse isso funcione sem sobrecarregar o modelo de objeto do elemento base com muitas propriedades aplicáveis a apenas um dos vários contêineres de layout possíveis. Em vez disso, muitos dos contêineres de layout implementam seu próprio conjunto de propriedades anexadas.

Para implementar a propriedade anexada, a classe Canvas define um campo estático DependencyProperty chamado Canvas.LeftProperty. Depois, o Canvas fornece os métodos SetLeft e GetLeft como acessadores públicos da propriedade anexada, para habilitar a configuração XAML e o acesso ao valor de tempo de execução. Para XAML e para o sistema de propriedades de dependência, esse conjunto de APIs satisfaz um padrão que habilita uma sintaxe XAML específica para propriedades anexadas e armazena o valor no repositório de propriedades de dependência.

Como o tipo proprietário usa as propriedades anexadas

Embora seja possível definir as propriedades anexadas em qualquer elemento XAML (ou DependencyObject subjacente), isso não significa necessariamente que a definição da propriedade produzirá um resultado tangível ou que o valor será acessado. O tipo que define a propriedade anexada normalmente é semelhante a um destes cenários:

  • O tipo que define a propriedade anexada é o pai em um relacionamento de outros objetos. Os objetos filho definirão valores para a propriedade anexada. O tipo de proprietário de propriedade anexada tem algum comportamento inato que itera através de seus elementos filho, obtém os valores e atua nesses valores em algum momento na vida útil do objeto (uma ação de layout, SizeChanged etc.)
  • O tipo que define a propriedade anexada é usado como o elemento filho para vários elementos pai e modelos de conteúdo possíveis, mas as informações não são necessariamente de layout.
  • A propriedade anexada relata informações para um serviço, e não para outro elemento de interface do usuário.

Para saber mais sobre esses cenários e tipos de propriedade, veja a seção "Mais sobre Canvas.Left" de Propriedades anexadas personalizadas.

Propriedades anexadas no código

Propriedades anexadas não têm os wrappers de propriedade típicos para fácil acesso de obtenção e definição, se comparadas às propriedades de dependência. Isso acontece porque a propriedade anexada não necessariamente faz parte do modelo de objeto focado no código para instâncias onde a propriedade foi definida. (É possível, mas incomum, definir uma propriedade que seja uma propriedade anexada que outros tipos possam definir por si só e que, ao mesmo tempo, tenha um uso de propriedade convencional no tipo proprietário.)

Há duas formas de definir uma propriedade anexada em código: usar as APIs do sistema de propriedades ou usar os acessadores de padrão XAML. As duas técnicas são bastante equivalentes em termos de resultado final. Assim, a escolha é basicamente uma questão de estilo de codificação.

Usando o sistema de propriedades

As propriedades anexadas do Tempo de Execução do Windows são implementadas como propriedades de dependência, portanto, o sistema de propriedades pode armazenar os valores no repositório de propriedades de dependência, tal como muitas propriedades de instâncias convencionais são armazenadas. Consequentemente, as propriedades anexadas expõem um identificador de propriedade de dependência na classe proprietária.

Para definir uma propriedade anexada no código, chame o método SetValue e transmita o campo DependencyProperty, que funciona como identificador dessa propriedade anexada. (Você também passa o valor a ser definido.)

Para obter o valor de uma propriedade anexada no código, chame o método GetValue, transmitindo novamente o campo DependencyProperty que funciona como o identificador.

Usando o padrão de acessador XAML

Um processador XAML deve ser capaz de definir esses valores de propriedade anexada quando o XAML é analisado em uma árvore de objetos. O tipo proprietário da propriedade anexada deve implementar os métodos de acessador dedicado, nomeados na forma de GetPropertyName e SetPropertyName. Esses métodos de acessador dedicado também são um meio de obter ou definir a propriedade anexada em código. Sob a perspectiva de código, uma propriedade anexada é similar a um campo existente que contém acessadores de método em vez de acessadores de propriedade. Esse campo existente pode existir em qualquer objeto, não sendo necessário defini-lo especificamente.

O exemplo a seguir mostra como você pode definir uma propriedade anexada em código via API do acessador XAML. Nesse exemplo, myCheckBox é uma instância da classe CheckBox. A última linha é o código que efetivamente define o valor. As linhas anteriores apenas estabelecem as instâncias e suas relações de pai-filho. A última linha não comentada será a sintaxe se você usar o sistema de propriedades. A última linha comentada será a sintaxe se você usar o padrão do acessador XAML.


    Canvas myC = new Canvas();
    CheckBox myCheckBox = new CheckBox();
    myCheckBox.Content = "Hello";
    myC.Children.Add(myCheckBox);
    myCheckBox.SetValue(Canvas.TopProperty,75);
    //Canvas.SetTop(myCheckBox, 75);

Propriedades anexadas personalizadas

Para obter exemplos de código sobre como definir propriedades anexadas personalizadas e saber mais sobre os cenários que as utilizam, veja Propriedades anexadas personalizadas.

Sintaxe especial para referências de propriedades anexadas

O ponto no nome de uma propriedade anexada é uma parte essencial do padrão de identificação. Às vezes, ocorrem ambiguidades quando uma sintaxe ou situação considera que o ponto tem outro significado. Por exemplo, o ponto é considerado como a passagem de um modelo-objeto para um caminho de associação. Na maioria dos casos de ambiguidade, a propriedade anexada tem uma sintaxe especial que ainda permite a análise do ponto interno como o separador owner.property de uma propriedade anexada.

  • Para especificar uma propriedade anexada como parte de um caminho de destino de uma animação, inclua o nome da propriedade anexada entre parênteses ("()")—por exemplo, "(Canvas.Left)". Para saber mais, veja Sintaxe de caminhos de propriedades.
    Cuidado  Uma limitação existente da implementação XAML do Tempo de Execução do Windows é que você não pode animar uma propriedade anexada personalizada.
     
  • Para especificar uma propriedade anexada como a propriedade de destino relacionada a uma referência de recurso de um arquivo de recurso para x:Uid, use uma sintaxe especial que insira uma declaração using: totalmente qualificada de estilo de código dentro de colchetes ("[]") para criar uma quebra proposital no escopo. Por exemplo, pressupondo que haja um elemento <TextBlock x:Uid="Title" />, a chave do recurso no arquivo de recurso que direciona o valor Canvas.Top nessa instância é "Title.[using:Windows.UI.Xaml.Controls]Canvas.Top". Para saber mais sobre arquivos de recurso e XAML, veja Guia de início rápido: traduzindo recursos de interface do usuário.

Tópicos relacionados

Propriedades anexadas personalizadas
Visão geral das propriedades de dependência
Guia de início rápido: definindo layouts
Guia de início rápido: traduzindo recursos da interface do usuário
SetValue
GetValue

 

 

Mostrar:
© 2017 Microsoft