Partilhar via

XAML Overview

  • Artigo

Este tópico descreve os recursos da linguagem Extensible Application Markup Language (XAML) e demonstra como você pode usar XAML para escrever aplicativos Windows Presentation Foundation (WPF). Este tópico descreve especificamente XAML conforme implementado pelo Windows Presentation Foundation (WPF). XAML propriamente dito é um conceito de linguagem maior que Windows Presentation Foundation (WPF).

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

  • Uma linguagem declarativa com suporte para controle de fluxo
  • Elementos-objetos XAML
  • Definindo propriedades
  • Valores de referência e extensões de marcação
  • Valores de atributo compatíveis com o conversor de tipos
  • Tipos de coleção e propriedades de coleção em XAML
  • Propriedades de conteúdo XAML
  • Maiúsculas, minúsculas, e espaço em branco em XAML
  • Mais sobre sintaxe XAML
  • Namespaces XML e elementos da raiz XAML
  • Eventos e code-behind XAML
  • x:Name
  • Propriedades anexadas e eventos anexados
  • Classes base e XAML
  • Segurança em XAML
  • Carregando XAML a partir do código
  • O Que Mais Há
  • Tópicos relacionados

Uma linguagem declarativa com suporte para controle de fluxo

XAML simplifica a criação de uma UI para o modelo de programação .NET Framework. Você pode criar elementos de UI visíveis na marcação declarativa de XAML e, em seguida, separar a definição da UI da lógica de tempo de execução usando arquivos code-behind, associados à marcação por definições de classes parciais. A capacidade de misturar código com marcação em XAML é importante porque XML em si é declarativa e não sugere um modelo de controle de fluxo. Uma linguagem declarativa baseada em XML é muito intuitiva para criar interfaces desde o protótipo à produção, especialmente para pessoas com experiência no design e tecnologias da Web. Ao contrário da maioria das outras linguagens de marcação, XAML diretamente representa a instanciação de objetos gerenciados. Esse princípio de design geral permite código simplificado e acesso de depuração aos objetos criados em XAML.

Os arquivos XAML são arquivos XML que geralmente têm a extensão .xaml.

O exemplo a seguir de XAML mostra como pouca marcação é necessária para criar um botão como parte de uma UI. O botão criado tem apresentação visual padrão através de estilos de tema e comportamentos padrão através de seu design de classe.

<StackPanel>
  <Button Content="Click Me"/>
</StackPanel>

Elementos-objetos XAML

XAML tem um conjunto de regras que mapeiam elementos-objetos para classes ou estruturas, os atributos para propriedades ou eventos, e namespaces XML para namespaces CLR. Elementos XAML mapeiam para tipos Microsoft .NET conforme definido nos conjuntos de módulos (assemblies) referenciados, e os atributos mapeiam para membros desses tipos.

O exemplo anterior especificado dois elementos do objeto: <StackPanel> (com uma marca de fechamento), e <Button/> (que também tivesse vários atributos; atributos são discutidos em uma próxima seção). Cada uma das strings StackPanel e Button mapeia para o nome de uma classe que é definida pelo WPF e é parte dos assemblies do WPF. Quando você especifica uma marca de elemento-objeto, você cria uma instrução de processamento de XAML para criar um nova instância da classe nomeada quando sua página XAML for carregada. Cada instância é criada ao chamar o construtor padrão da classe ou estrutura subjacente e armazenar o resultado. Para ser usado como um objeto-elemento em XAML, a classe ou estrutura deve expor um construtor público padrão (sem-parâmetros).

Definindo propriedades

As propriedades em XAML são definidas através de propriedades em um elemento-objeto, usando uma variedade de possíveis sintaxes. Haverá variações nas sintaxes que podem ser usadas para uma determinada propriedade, com base nas características da propriedade que você estiver configurando.

Ao definir os valores das propriedades, você adicionará recursos ou características aos elementos-objetos. O estado inicial da instância do objeto subjacente para um elemento-objeto baseia-se no comportamento do construtor padrão. Normalmente, seu aplicativo irá usar algo diferente de uma instância completamente padronizada de um determinado objeto.

Sintaxe de atributo

Em XAML, propriedades geralmente podem ser expressadas como atributos. A sintaxe de atributo é a mais agilizada das sintaxes de configuração de propriedades e será a sintaxe mais intuitiva para os desenvolvedores que tenham usados linguagens de marcação no passado. Por exemplo, a marcação a seguir cria um botão que possui texto vermelho e um plano de fundo azul, bem como exibe texto especificado como Content.

<Button Background="Blue" Foreground="Red" Content="This is a button"/>

Sintaxe de Elemento Propriedade

Para algumas propriedades de um elemento-objeto, a sintaxe de atributo não é possível, porque o objeto ou as informações necessárias para fornecer o valor da propriedade não pode ser adequadamente expressado como uma simples string. Nesses casos pode-se usar uma sintaxe diferente, conhecida como sintaxe de propriedade de elemento. A sintaxe de propriedade de elemento define o conteúdo da tag como a propriedade referenciada do elemento que a contém. Geralmente, o conteúdo é um objeto do tipo que a propriedade utiliza como seu valor (com a instância de valor da configuração normalmente especificada como outro elemento-objeto). A sintaxe para o elemento propriedade é <NomeDoTipo.Propriedade>. Depois de especificar o conteúdo, você deve fechar o elemento de propriedade com um tag de fechamento assim como qualquer outro elemento (com a sintaxe </NomeDoTipo.Propriedade>). Para propriedades onde tanto a sintaxe de atributo quanto a sintaxe de elemento de propriedade forem suportadas, as duas sintaxes geralmente têm o mesmo resultado, embora sutilezas (p.ex., tratamento de espaço em branco) podem variar ligeiramente entre sintaxes. Se for possível uma sintaxe de atributo, esta é normalmente mais conveniente e permite uma marcação mais compacta, mas que é apenas uma questão de estilo, não uma limitação técnica. O exemplo a seguir mostra as mesmas propriedades que foram definidas no exemplo anterior de atributo de sintaxe, mas dessa vez usando a sintaxe de elemento de propriedade para todas as propriedades do Button.

<Button>
  <Button.Background>
    <SolidColorBrush Color="Blue"/>
  </Button.Background>
  <Button.Foreground>
    <SolidColorBrush Color="Red"/>
  </Button.Foreground>
  <Button.Content>
    This is a button
  </Button.Content>
</Button>

A sintaxe de elemento de propriedade para XAML representa um desvio significativo da interpretação XML básica da marcação. Em XML, <NomeDoTipo.Propriedade> representa outro elemento, sem nenhuma relação implícita a um pai TypeName além de seu status como um elemento-filho. Em XAML, <NomeDoTipo.Property> diretamente implica que Property é uma propriedade de NomeDoTipo, sendo definida pelo conteúdo do elemento de propriedade, e nunca será um elemento discreto que por acaso tem um ponto no seu nome.

Propriedades e a herança de classe

As propriedades, da forma que são exibidas como atributos XAML em um elemento WPF, geralmente são herdadas de classes base. Por exemplo, no exemplo anterior, a propriedade Background não é uma propriedade imediatamente declarada na classe Button, se você examinasse a definição de classe, resultados de reflexo, ou a documentação. Em vez disso, Background é herdada da classe base Control.

O comportamento do elementos XAML WPF, com relação a herança de classe, é outro desvio significativo da interpretação XML básica da marcação. Herança de classe (particularmente quando classes base intermediários são abstratas) é um motivo que o conjunto de XAML é difícil representar completamente e com precisão usando sistema autônomo tipos de esquema que são usados normalmente para elementos e seus atributos permitidos XML programação, sistema autônomo formato XSD ou DTD. Além disso, o "X" emXAMLsignifica "extensível" e extensibilidade impede a integridade de qualquer representação determinada de "o que é XAML para WPF"(Embora manter separadas definições do namespace de XML podem ajudar com esse problema; esse conceito é discutido em uma seção posterior).

Valores de referência e extensões de marcação

Extensões de marcação são um conceito XAML. Na sintaxe de atributo, chaves ({ e }) indicam um uso de extensão de marcação. Esse uso direciona o processamento de XAML para sair do tratamento geral dos valores de atributo como uma string literal ou um valor diretamente conversível para string.

Quando as propriedades levarem um valor de tipo de referência, essas propriedades geralmente necessitarão de sintaxe de elemento de propriedade (que sempre cria uma nova instância), ou uma referência a um objeto através de uma extensão de marcação. Um uso de extensão de marcação potencialmente pode retornar uma instância existente e, portanto, pode ser mais versátil ou talvez leve a um custo menor de execução.

Quando um extensão de marcação é usada para fornecer um valor de atributo, o valor do atributo em vez disso deve ser fornecido pela lógica dentro da classe que dá respaldo à extensão de marcação relevante. As extensões de marcação mais comuns usadas na programação de aplicativos WPF são vinculação, usada para expressões de associação de dados, e as referências de recursos StaticResource e DynamicResource. Usando extensões de marcação, você pode usar a sintaxe de atributo para fornecer valores de referência para propriedades mesmo se essa propriedade não suportar uma sintaxe de atributo para instanciação direta de objetos, ou ativar comportamento específico que adia o comportamento geral do requisito que as propriedades XAML devem ser preenchidas por valores do tipo da propriedade.

Por exemplo, o exemplo a seguir define o valor da propriedade Style usando a sintaxe de atributo. A propriedade Style recebe uma instância da classe Style, um tipo de referência que por padrão não poderia ser especificado em uma string na sintaxe de atributo. Mas nesse caso, o atributo referencia uma extensão de marcação particular, StaticResource. Quando essa extensão de marcação for processada, ele retorna uma referência a um estilo que foi anteriormente instanciado como um recurso com chave em um dicionário de recursos.

<Page.Resources>
  <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
  <Style TargetType="Border" x:Key="PageBackground">
    <Setter Property="Background" Value="Blue"/>
  </Style>


...


</Page.Resources>
<StackPanel>
  <Border Style="{StaticResource PageBackground}">


...


  </Border>
</StackPanel>

Os recursos são apenas um uso de extensão de marcação ativado por WPF ou XAML. Para obter uma listagem de referência das extensões de marcação, consulte Extensões XAML do Namespace WPF ou Namespace XAML (x:) Recursos da linguagem. Para obter mais informações sobre extenções de marcação, consulte Extensão de Marcação e XAML.

Valores de atributo compatíveis com o conversor de tipos

Na seção Sintaxe de atributo, foi mencionado que o valor do atributo deve poder ser definido por uma string. O tratamento básico, nativo de como sequências de caracteres são convertidas para outros tipos de objeto ou valores primitivos tem base no próprio tipo String. Mas muitas WPF tipos ou membros de tipos estendem o atributo de seqüência básica processamento comportamento, de modo que instâncias de tipos de objeto mais complexos podem ser especificadas sistema autônomo valores de atributos por meio de uma seqüência de caracteres. No nível do código, esse processamento é feito por meio da especificação de um CLR Conversor de tipo que processa o valor do atributo de seqüência de caracteres. O tipo de estrutura Thickness, normalmente usado para indicar as medidas de uma área retangular, como um Margin, é um exemplo de um tipo que tem uma sintaxe de atributo especial compatível com o conversor de tipos exposta para todas as propriedades que usam esse tipo, para oferecer facilidade de uso em marcação XAML. O exemplo a seguir utiliza uma sintaxe de atributo compatível com o conversor de tipos para fornecer um valor para um Margin:

<Button Margin="10,20,10,30" Content="Click me"/>

O exemplo anterior de atributo de sintaxe é equivalente ao seguinte exemplo de sintaxe mais detalhado, onde o Margin é definido através da sintaxe de elemento de propriedade contendo um elemento-objeto Thickness, e quatro propriedades-chave de Thickness são definidas como atributos na nova instância:

<Button Content="Click me">
  <Button.Margin>
    <Thickness Left="10" Top="20" Right="10" Bottom="30"/>
  </Button.Margin>
</Button>

A escolha entre a sintaxe compatível com o conversor de tipos e uma sintaxe equivalente mais detalhada geralmente é uma opção de estilo de codificação, mas a sintaxe compatível com o conversor de tipos promove una marcação mais agilizada. (No entanto, há um número limitado de objetos onde o conversor de tipos é a única maneira para definir uma propriedade para esse tipo, porque o próprio objeto tipo não tem um construtor padrão. Um exemplo é Cursor.)

Para obter mais informações sobre como a sintaxe compatível com o conversor de tipos é suportada, consulte TypeConverters and XAML.

Tipos de coleção e propriedades de coleção em XAML

XAML especifica um recurso de linguagem pela qual o elemento-objeto que representa um tipo de coleção pode ser omitido deliberadamente da marcação. Quando um processador XAML trata de uma propriedade que utiliza um tipo de coleção, uma instância do tipo de coleção apropriada é criada implicitamente, mesmo se o elemento-objeto da coleção não estiver presente na marcação. Nas páginas de referência do SDK para tipos de coleção, essa sintaxe com a omissão deliberada do elemento-objeto para uma coleção é ocasionalmente mencionada nas seções sobre a sintaxe XAML como Sintaxe de Coleção Implícita.

Sintaxe de Coleção Implícita está disponível para tipos que implementam IList ou IDictionary, ou para arrays.

Você já viu um exemplo de uma Sintaxe de Coleção Implícita (mesmo que ele não tenha sido explicitamente apresentada), no exemplo sobre recursos XAML:

<Page.Resources>
  <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
  <Style TargetType="Border" x:Key="PageBackground">
    <Setter Property="Background" Value="Blue"/>
  </Style>


...


</Page.Resources>
<StackPanel>
  <Border Style="{StaticResource PageBackground}">


...


  </Border>
</StackPanel>

Com exceção do elemento raiz, cada elemento de objeto em uma página que está aninhado sistema autônomo um elemento filho de outro elemento é realmente um elemento que é um ou ambos sistema autônomo casos a seguintes: um membro de uma propriedade de coleção implícito de seu elemento pai ou um elemento que especifica o valor do XAML propriedade Content para o elemento pai)XAML Propriedades de conteúdo serão discutidas em uma próxima seção). Em outras palavras, a relação de elementos-pai e elementos-filho em uma página de marcação é na verdade um único objeto na raiz, e cada elemento-objeto abaixo da raiz é uma instância única que fornece uma valor da propriedade do pai, ou um dos itens dentro de uma coleção que é também um valor da propriedade de tipo de coleção do pai. No caso do exemplo de recursos, a propriedade Resources recebe um objeto do tipo ResourceDictionary. O exemplo a seguir é sintaxe equivalente com o elemento-objeto para o ResourceDictionary especificado explicitamente.

<Page.Resources>
  <ResourceDictionary>
      <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
      <Style TargetType="Border" x:Key="PageBackground">
        <Setter Property="Background" Value="Blue"/>
      </Style>


...


  </ResourceDictionary>
</Page.Resources>
<StackPanel>
  <Border Style="{StaticResource PageBackground}">


...


    </Border>
  </StackPanel>
</Page>

A coleção Resources é um exemplo de uma propriedade de coleção que está presente em vários elementos comuns no nível de framework da WPF. A definição dessa propriedade no XAML requer a sintaxe de elemento de propriedade. Cada elemento de objeto fechada dentro do elemento de propriedade se torna um item da coleção (um IDictionary implementação). Embora o tipo de coleção normalmente tenham uma propriedade ou indexador que contém os itens, essa propriedade não é possível especificar na marcação; ele está totalmente implícito. Para o ResourceDictionary, essa propriedade é o indexador Item.

Para ver um exemplo mais completo sobre o uso do dicionário de recursos, consulte Como: Definir e referenciar um recurso.

Propriedades de conteúdo XAML

XAML especifica um recurso de linguagem pelo qual qualquer classe que pode ser usada como um elemento-objeto XAML pode designar exatamente uma de suas propriedades para ser a propriedade de conteúdo XAML para as instâncias da classe. Quando um processador XAML trata um elemento-objeto que tem uma propriedade de conteúdo XAML, quaisquer elementos-filho XML do elemento-objeto são processados como se eles estivessem contidos dentro de uma tag the elemento de propriedade implícito representando aquela propriedade de conteúdo. Em seu marcação, a sintaxe de elemento de propriedade para a propriedade de conteúdo XAML pode ser omitida. Quaisquer elementos-filho que você especificar na marcação tornar-se-ão o valor da propriedade de conteúdo XAML.

Você já viu um exemplo de um XAML propriedade Conteúdo sem ele sendo chamado: o primeiro exemplo neste tópico.

<StackPanel>
  <Button Content="Click Me"/>
</StackPanel>

Aqui, Button é um elemento-filho de StackPanel. Essa é uma marcação otimizada e intuitiva que omite duas tags por dois motivos diferentes.

  • Elemento de propriedade StackPanel.Children omitido: StackPanel deriva da Panel. Panel Define Panel.Children sistema autônomo seu XAML propriedade Conteúdo. Todas as classes derivadas de Panel têm, portanto, essa propriedade de conteúdo XAML, e o elemento de propriedade Panel.Children pode ser omitido.

  • Elemento de objeto UIElementCollection omitido: The Panel.Children propriedade tem o tipo UIElementCollection, que implementa IList. Portanto, a tag do elemento-objeto UIElementCollection pode ser omitida, com base nas regras para coleções definidas por XAML. Nesse caso, UIElementCollection não pode ser instanciado como um elemento-objeto. Você nem mesmo tem a opção de declarar explicitamente esse objeto de coleção. Isso ocorre porque UIElementCollection não expõe um construtor padrão. Vários outros tipos de coleção WPF também não expõem os construtores para uso elemento de objeto, porque o tratamento de sintaxe para coleções XAML ainda permite-lhes trabalhar em XAML implicitamente. Esse é o motivo pelo qual o elemento-objeto UIElementCollection é mostrado comentado no exemplo; se o descomentássemos, o exemplo não compilaria.

<StackPanel>
  <StackPanel.Children>
    <!--<UIElementCollection>-->
    <Button>
      <Button.Content>
        Click Me
      </Button.Content>
    </Button>
    <!--</UIElementCollection>-->
  </StackPanel.Children>
</StackPanel>

Texto interno o propriedades de conteúdo XAML

O exemplo de StackPanel / Button possui ainda outra variação.

<StackPanel>
  <Button>Click Me</Button>
</StackPanel>

Observe a alteração que ocorre na especificação do texto do Button. Antes, a propriedade Content foi especificada em sintaxe de atributo; dessa vez, a string de exibição é o texto interno de um elemento-objeto Button. Essa sintaxe funciona porque Content é a propriedade de conteúdo XAML da classe base ContentControl de Button. A seqüência de caracteres dentro do elemento é avaliada com base no tipo de propriedade do Content propriedade, que é Object. Object não tenta executar qualquer conversão de tipo de seqüência de caracteres, portanto, o valor da Content propriedade se torna o valor de string literal. Como alternativa, o conteúdo dentro de Button poderia ter sido qualquer Object. Controles como Button geralmente definem a propriedade de conteúdo XAML para a classe de modo que a propriedade de conteúdo XAML possa ser usada como texto de exibição (texto de interface com o usuário), para composição de controles, ou ambos.

A capacidade de colocar as strings dentro do elemento como conteúdo para produzir a marcação que se assemelhe outras linguagens de marcação comum é particularmente importante para o modelo do documento de fluxo (para obter detalhes, consulte Documentos em Windows Presentation Foundation) e para a localização (consulte Globalização para o Windows Presentation Foundation) .

Valores de propriedades de conteúdo XAML devem ser contíguos

O valor de uma propriedade de conteúdo XAML deve ser fornecido totalmente antes ou depois de quaisquer outros elementos de propriedade no elemento-objeto. Isso vale seja no caso em que o valor de uma propriedade de conteúdo XAML é especificado como uma string, ou no caso em que ele é especificado como um ou mais objetos. Por exemplo, a seguinte marcação não compila:

<Button>I am a 
  <Button.Background>Blue</Button.Background>
  blue button</Button>

Isso é ilegal essencialmente porque se essa sintaxe fosse explícita usando a sintaxe de elemento de propriedade para a propriedade de conteúdo, então a propriedade de conteúdo seria definida duas vezes:

<Button>
  <Button.Content>I am a </Button.Content>
  <Button.Background>Blue</Button.Background>
  <Button.Content> blue button</Button.Content>
</Button>

Outro exemplo ilegal é se a propriedade de conteúdo é uma coleção, e elementos-filho são intercalados com os elementos de propriedade:

<StackPanel>
  <Button>This example</Button>
  <StackPanel.Resources>
    <SolidColorBrush x:Key="BlueBrush" Color="Blue"/>
  </StackPanel.Resources>
  <Button>... is illegal XAML</Button>
</StackPanel>

Modelos de conteúdo

Uma classe pode suportar um uso como um elemento XAML em termos de sintaxe, mas esse elemento só funcionará corretamente em um aplicativo ou página quando ele for colocado em uma posição esperada de uma árvore de elementos ou modelo de conteúdo geral. Por exemplo, um MenuItem deve normalmente ser colocado apenas como um filho de uma classe derivada de MenuBase (p.ex., Menu). Modelos de conteúdo para elementos específicos são documentados como parte de comentários nas páginas de classe para controles e outras classes WPF que podem ser usadas como elementos XAML. Para alguns controles que têm modelos de conteúdo mais complexos, o modelo de conteúdo está documentado como um tópico conceitual separado. Consulte Modelos de conteúdo.

Maiúsculas, minúsculas, e espaço em branco em XAML

XAML diferencia maiúsculas de minúsculas. Elementos-objeto, elementos de propriedade, e nomes de atributo devem todos ser especificados usando a caixa adequada quando comparados pelo nome com o tipo subjacente no conjunto de módulos (assembly), ou para um membro de um tipo. Os valores de atributos nem sempre fazem diferenciação entre maiúsculas e minúsculas. A diferenciação em valores dependerá do comportamento do conversor de tipos associado com a propriedade que recebe o valor, ou o tipo do valor de propriedade. Por exemplo, as propriedades que recebem o tipo Boolean podem receber tanto true quanto True como valores equivalentes, mas apenas porque a conversão de tipos de string padrão para Boolean já permite essas variações como equivalentes.

Serializadores e processadores XAML ignorarão ou cancelarão todos os espaços em branco não significativos, e normalizarão qualquer espaço em branco significativo. Esse comportamento geralmente só é importante quando você especificar as strings dentro de propriedades de conteúdo XAML. Em termos mais simples, XAML converte caracteres de espaço, quebra-de-linha, e tabulação em espaços, e em seguida mantém um espaço se encontrado em qualquer uma das extremidades de uma string contígua. A explicação completa do tratamento de espaços em branco em XAML não é abordada neste tópico. Para obter detalhes, consulte:Processamento de Espaço em branco em XAML.

Mais sobre sintaxe XAML

Sintaxe de coleção implícita e propriedades de conteúdo XAML são ambos os recursos da linguagem XAML que permitem a omissão de determinadas tags inferidas. O objetivo desses recursos é tornar as relações pai-filho dos elementos em uma página mais evidente durante a criação ou exame da marcação.

Para obter mais informações sobre sintaxe de atributo e a sintaxe de propriedade de elemento, bem como outros termos que são usados ao descrever a sintaxe XAML ao longo da documentação SDK, consulte Terminologia de sintaxe XAML. O tópico Terminologia de sintaxe XAML também é um bom local para iniciar se você estiver considerando os usos de XAML a habilitar se você estiver criando uma classe personalizada.

Namespaces XML e elementos da raiz XAML

Um arquivo XAML deve ter apenas um elemento-raiz, para ser um arquivo XML bem-formado e um arquivo XAML válido. Normalmente você deve escolher um elemento que é parte do modelo de aplicativo (por exemplo, Window ou Page para uma página, ResourceDictionary para um dicionário externo, ou Application para a raiz de definição de aplicativo). O exemplo a seguir mostra o elemento-raiz de um arquivo XAML típico para uma página WPF, com o elemento-raiz Page.

<Page
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"


...


</Page>

O elemento raiz também contém os atributos xmlns e xmlns:x. Esses atributos indicam a um XAML processador quais espaços para nome XML contêm as definições de elemento de elementos que fará referência a marcação. The xmlns atributo indica especificamente o namespace XML padrão. No namespace de XML padrão, elementos do objeto na marcação podem ser especificados sem um prefixo. A maioria dos WPF cenários de aplicativos e para praticamente todos os exemplos fornecidos na WPF seções de SDK, o namespace XML padrão é mapeado para o WPF espaço para nome https://schemas.microsoft.com/winfx/2006/xaml/presentation. The xmlns:x atributo indica um namespace XML adicional, que mapeia o XAML espaço para nome de linguagem https://schemas.microsoft.com/winfx/2006/xaml. Os componentes necessários da linguagem definidos pela especificação XAML são precedidos por x: quando referenciados na marcação de um arquivo com esse mapeamento. Esse uso de xmlns para definir um escopo para uso e o mapeamento é consistente com a especificação XML 1.0. Observe que o xmlns atributos são estritamente necessários no elemento raiz de cada página e na definição de aplicativo apenas se ele é fornecido na marcação. xmlns as definições serão aplicadas a todos os elementos filho da raiz (esse comportamento é novamente consistente com a especificação XML 1.0 para xmlns.) xmlns os atributos também são permitidos em outros elementos sob a raiz e aplicam a qualquer elemento filho do elemento definição. No entanto, esse uso não é normal, pois definição freqüente ou redefinição de espaços para nome XML pode resultar em um XAML estilo de marcação que é difícil de ler.

The WPF assemblies são conhecidos por conter tipos que oferecem suporte a WPF mapeamentos para o namespace de XML padrão devido a uma configuração que faz parte do seu projeto Compilar arquivo. Assemblies também são mapeados nos arquivos de destino. Portanto, o mapeamento de xmlns é suficiente para fazer referência a elementos XAML que vêm de assemblies WPF. Para seus próprios assemblies personalizados ou para assemblies fora de WPF, você pode especificar o conjunto sistema autônomo parte do xmlns MAP ping. Normalmente, você escolhe um prefixo diferente, mas também é possível escolher um namespace de XML diferente sistema autônomo padrão e, em seguida MAP WPF para um prefixo. Para obter mais informações sobre como namespaces XML e os espaços para nome do código fazendo assemblies estão relacionados, consulte Espaços de nomes XAML e mapeamentos de espaços de nomes.

X: Prefixo

O exemplo de elemento raiz anterior, o prefixo x: foi usado para MAP o XAML Namepace XML https://schemas.microsoft.com/winfx/2006/xaml. Este x: prefixo será usado para mapear o XAML XML namepace no modelos para projetos, exemplos e na documentação em todo este SDK. The x: prefixo /XAML Namepace XML contêm várias construções de programação que você usará com bastante freqüência no seu XAML. A seguir é uma listagem do mais comunsx: prefixo /XAML Você irá usar construções de programação de namespace:

  • x: chave: Define uma chave exclusiva para cada recurso em um ResourceDictionary. x:Key provavelmente conta para 90 % das x: usos você verá na marcação do seu aplicativo.

  • x: classe: Especifica o CLR nome de namespace e classe para a classe que fornece o code-behind para uma XAML página. Você deve ter uma classe dessas para oferecer suporte a code-behind, e é por isso que você quase sempre vê x: mapeado, mesmo se não houver nenhum recurso.

  • x: nome: Especifica um em time de execução nome de objeto para a instância existente no em time de execução após o processamento de um elemento de objeto de código. Usa-se x:Name para casos de elementos nomeados onde não houver suporte para a propriedade equivalente no nível de framework WPF, Name. Isso acontece em algumas situações de animação.

  • x: estático: Permite que uma referência de valor que obtém um valor estático que não é contrário um XAML-propriedade compatível. 

  • x: tipo: Constrói um Type com base em um nome de tipo de referência. Isso é usado para especificar atributos que recebem Type (p.ex., Style.TargetType), embora em muitos casos a propriedade tenha conversão string-para-Type nativa de forma que o uso de x:Type é opcional.

Há adicionais programação construções no x: prefixo /XAML namespace, que não são tão comuns. Para obter detalhes, consulte:Namespace XAML (x:) Recursos da linguagem.

Eventos e code-behind XAML

A maioria dos aplicativos WPF consistem de marcação e code-behind. Dentro de um projeto, o XAML é gravado sistema autônomo um .xaml arquivo e um CLR linguagem sistema autônomo Microsoft Visual Basic .NET ou C# é usado para gravar um arquivo code-behind. Quando um arquivo XAML é compilado, o local do arquivo de code-behind XAML para cada página XAML é identificado ao especificar um namespace e classe como o atributo x:Class do elemento-raiz da página XAML.

Nos exemplos apresentados até agora, você viu vários botões, mas nenhum desses botões tinha qualquer comportamento lógico associado a eles. A nível de aplicativo, o mecanismo principal para adicionar um comportamento a um elemento-objeto é usar um evento existente da classe de elemento, e escrever um tratador específico para o evento que é invocado quando esse evento é gerado em tempo de execução. O nome do evento e o nome do tratador a usar são especificados na marcação, enquanto o código que implementa o tratador é definido no code-behind.

<Page 
  xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="MyNamespace.MyPageCode">
  <Button Click="ClickHandler" >Click Me!</Button>
</Page>

namespace MyNamespace
{
  public partial class MyPageCode
  {
    void ClickHandler(object sender, RoutedEventArgs e)
    {
      Button b = e.Source as Button;
      b.Background = Brushes.Red;
    }
  }
}

Observe que o arquivo code-behind usa o namespace CLR MyNamespace e declara MyPageCode sistema autônomo uma classe parcial dentro desse namespace. Isso acompanha o valor do atributo x:Class de MyNamespace.MyPageCode fornecido na raiz de marcação. O compilador criará automaticamente uma classe parcial para qualquer página XAML compilada por derivação de uma classe a partir do tipo do elemento-raiz. Quando você fornece code-behind que também define a mesma classe parcial, o código resultante é combinado dentro do mesmo namespace e classe do aplicativo compilado.

Para obter mais informações sobre os requisitos para programação de code-behind, consulte a seção "code-behind, manipulador de eventos e requisitos de classe parcial"Code-Behind e XAML.

Se você não deseja criar um code-behind file separado, você pode também inserir seu código in-line dentro de um arquivo XAML. No entanto, código in-line é uma técnica menos versátil que tem limitações significativas. Para obter detalhes, consulte:Code-Behind e XAML.

Sintaxe de atributo de eventos

Quando você especifica o comportamento através de eventos na marcação, você normalmente use sintaxe de atributo para anexar tratadores. O elemento-objeto onde o atributo de evento é especificado torna-se a instância que escuta o evento e chama o tratador. O nome do evento específico que você deseja manipular é o nome do atributo. O valor do atributo é o nome do método do tratador que você irá definir. Em seguida, você deve fornecer a implementação do tratador no code-behind, com o tratador sendo baseado no representante para o evento. Você escrever o tratador no code-behind em um linguagem de programação como Microsoft Visual Basic .NET ou C#.

Cada evento de WPF irá relatar dados do evento quando o evento for gerado. Tratadores de eventos podem acessar esses dados de evento. No exemplo anterior, o tratador obtém a fonte do evento relatada pelos dados de evento e, em seguida, define propriedades sobre essa fonte.

Eventos roteados

Evento roteados são um recurso exclusivo e fundamental para o WPF. Eventos roteados perimtem que um elemento trate um evento que foi gerado por um elemento diferente, desde que os elementos estejam conectados por uma relação de árvore de elementos. Ao especificar o tratamento de eventos com um atributo XAML, pode-se escutar o evento roteado e tratá-lo em qualquer elemento, incluindo elementos que não listam desse evento específico na tabela de membros de classe. Para isso, qualifica-se o atributo de nome do evento com o nome da classe proprietária. Por exemplo, o StackPanel-pai no exemplo de StackPanel/Button poderia registrar um tratador para o evento Click do elemento-filho botão especificando o atributo Button.Click no elemento-objeto StackPanel, com seu nome do tratador como o valor de atributo. Para obter mais informações, consulte Visão geral sobre eventos roteados.

x:Name

Por padrão, a instância do objeto criada pelo processamento de um elemento-objeto não possui um identificador único ou uma referência de objeto inerente que você pode usar em seu código. Se você chamar um construtor no código, você quase sempre usará o resultado do construtor para armazenar a instância construída em uma variável, de modo que você possa fazer referência à instância mais tarde no seu código. Para oferecer acesso padronizado a objetos que foram criados por meio de uma definição de marcação, XAML define o atributo x:Name. Você pode definir o valor do atributo x:Name em qualquer elemento-objeto. Em seu code-behind, o identificador escolhido é equivalente a uma variável de instância que se refere a instância criada. Em todos sistema autônomo aspectos, denominado elementos de função sistema autônomo se fossem instâncias de objeto (o nome referencia apenas essa instância) e o code-behind pode referenciar sistema autônomo elementos nomeados para lidar com interações de time de execução dentro do aplicativo.

Elementos XAML no nível do framework WPF herdam uma propriedade Name, que é equivalente ao atributo x:Name definido por XAML. Existem outras classes que também fornecem equivalentes a nível de propriedade para x:Name, que também geralmente é definido como uma propriedade Name. Em termos gerais, se você não puder encontrar uma propriedade Name na tabela de membros do elemento selecionado, use x:Name em seu lugar.

O exemplo a seguir define Name em um elemento StackPanel. Em seguida, um tratador em um Button dentro desse StackPanel faz referência a StackPanel por sua referência de instância buttonContainer conforme definido por Name.

<StackPanel Name="buttonContainer">


...


  <Button Click="RemoveThis">Click to remove this button</Button>
</StackPanel>

void RemoveThis(object sender, RoutedEventArgs e)
{
    FrameworkElement fe = e.Source as FrameworkElement;
    if (buttonContainer.Children.Contains(fe))
    {
        buttonContainer.Children.Remove(fe);
    }
}

Assim como uma variável, o nome de uma instância é regido por um conceito do escopo, de modo que os nomes possam ser únicos em um determinado escopo previsível. A marcação primária que define uma página denota um namescope (escopo de nomes) único, com o limite do namescope sendo o elemento-raiz da página. No entanto, outras fontes de marcação podem interagir com uma página em tempo de execução (p.ex., estilos ou modelos dentro de estilos), e essas fontes de marcação geralmente têm seus próprios namescopes que não necessariamente conectam-se com o namescope da página. Para mais informações sobre x:Name e namescopes, consulte Name, x:Name Attribute, ou Namescopes WPF.

Propriedades anexadas e eventos anexados

XAML especifica um recurso de linguagem que permite que determinadas propriedades ou eventos sejam especificados em qualquer elemento, independentemente da existência da propriedade ou elemento na tabela de membros do elemento em que eles estão sendo definidos. Quando este recurso é aplicado a propriedades ele é denominado propriedade anexada, e quando ele é aplicado a eventos ele é denominado evento anexado. Conceitualmente, você pode pensar em propriedades anexadas e eventos anexados como membros globais que podem ser definidos em qualquer elemento/classe, independentemente de sua hierarquia de classes.

Propriedades anexadas em XAML são normalmente usadas pela sintaxe de atributos. Na sintaxe de atributo, você especifica uma propriedade anexada no formulário OwnerType.PropertyName. Superficialmente, isso é parecido com o uso de elementos de propriedade, mas neste caso o OwnerType que você especifica é sempre um tipo diferente do elemento-objeto onde a propriedade anexada está sendo definida. OwnerType é o tipo que fornece os métodos acessadores que são exigidos por um processador XAML para obter ou definir o valor da propriedade anexada. A situação mais comum para propriedades anexadas é permitir que elementos-filho relatem um valor da propriedade para seus elemento-pai.

O exemplo a seguir ilustra a propriedade anexada DockPanel.Dock. A classe DockPanel define os acessadores para DockPanel.Dock e, portanto, é o proprietário da propriedade anexada. A classe DockPanel também inclui a lógica que itera seus elementos-filho e especificamente verifica cada elemento para ver se valor de DockPanel.Dock está definido. Se for encontrado um valor, esse valor será usado durante o layout para posicionar os elementos-filho. O uso da propriedade anexada DockPanel.Dock e essa capacidade de posicionamento é, na verdade, a situação motivadora para a classe DockPanel.

<DockPanel>
  <Button DockPanel.Dock="Left" Width="100" Height="20">I am on the left</Button>
  <Button DockPanel.Dock="Right" Width="100" Height="20">I am on the right</Button>
</DockPanel>

Em Windows Presentation Foundation (WPF), todas as propriedades anexadas também são implementadas como propriedades de dependência. Para obter detalhes, consulte:Attached Properties Overview.

Eventos anexados usam uma forma OwnerType.EventName semelhante de sintaxe de atributo. Assim como os eventos não anexados, o valor de atributo para um evento anexado em XAML especifica o nome do método tratador que é chamado quando o evento é tratado no elemento.

Uma situação onde eventos anexados são usados é para eventos de dispositivos de entrada que podem ser tratados em qualquer elemento, como botões do mouse. Um exemplo desse tipo de evento anexado é Mouse.MouseDown. No entanto, a maioria dos elementos no nível de framework WPF podem utilizar esse evento sem o uso de eventos anexados. Isso ocorre porque a classe base elemento UIElement cria um alias para o evento anexado Mouse.MouseDown e expõe esse alias na tabela de membros de UIElement (p.ex., MouseDown). Consequentemente, você normalmente não precisará usar a sintaxe de evento anexado em uma página XAML ou durante a programação de um aplicativo Windows Presentation Foundation (WPF). As exceções são se você estiver usando elementos personalizados, ou elementos-objeto que não derivam de UIElement mas ainda assim têm uma representação visual (esses casos são raros). In WPF, todos sistema autônomo eventos anexados também são implementados sistema autônomo eventos roteados. ContentElement também expõe aliases para os eventos de entrada, para uso pelo modelo de fluxo de documento. Para obter detalhes, consulte Visão geral sobre eventos roteados e Input Overview.

Anatomia de um elemento-raiz de uma página XAML

A tabela a seguir mostra a divisão de um elemento-raiz de uma página XAML típica, mostrando os atributos específicos de um elemento-raiz identificados neste tópico:

<Page

Elemento-objeto de abertura do elemento-raiz

xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"

O namespace (WPF) padrão

xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"

O namespace XAML

x:Class="MyNamespace.MyPageCode"

A declaração de classe parcial que conecta a marcação a qualquer code-behind definido nessa mesma classe parcial

>

Fim do elemento-objeto para a raiz, não fechado ainda porque a página contém elementos-filho

Classes base e XAML

Subjacente a XAML e seus esquemas, existe um conjunto de classes que correspondem aos objetos CLR bem como elementos de marcação a ser usados em XAML. No entanto, nem todas as classes podem ser mapeadas para elementos. Classes abstratas, como ButtonBase, e certas classes base não abstratas são usadas para herança no modelo de objetos CLR e não suportam as marcas de XAML correspondentes. Classes base, incluindo aquelas abstratas, são importantes para o desenvolvimento em XAML porque cada um dos elementos XAML concretos herda os membros de alguma classe base na sua hierarquia. Freqüentemente esses membros incluem propriedades que podem ser conjunto sistema autônomo atributos no elemento ou eventos que podem ser tratados. FrameworkElement é a base de concreta UI classe de WPF com o Nível de estrutura do WPF. Quando estiver criando a UI, você usará várias classes de formas, painéis, decoradores, ou controles, sendo que todos derivam de FrameworkElement. Um classe base relacionada, FrameworkContentElement, oferece suporte a elementos orientados a documento que funcionam bem para uma apresentação de layout de fluxo, usando APIs que deliberadamente espelham as APIs no FrameworkElement. A combinação de atributos no nível do elemento e um modelo de objetos CLR fornece um conjunto de propriedades comuns que são configuráveis na maioria dos elementos XAML concretos, independentemente do tipo exato de elemento e sua classe subjacente.

Segurança em XAML

XAML é uma linguagem de marcação que representa diretamente a instanciação e execução de objetos. Portanto, os elementos criados em XAML têm a mesma capacidade de interagir com os recursos do sistema (acesso a rede, E/S com o sistema de arquivos, por exemplo) que o código gerado equivalente.

WPF oferece suporte ao framework de segurança Segurança de Acesso a Código (CAS) do .NET. Isso significa que conteúdo de WPF sendo executado na zona da Internet tem permissões de execução reduzidas. " Perder XAML"(páginas de noncompiledXAML interpretados no time de carregamento por um XAML Visualizador) e aplicativo de navegador XAML (XBAP) geralmente são executados nessa zona de internet e usar o mesmo conjunto de permissão. No entanto, XAML carregado para dentro de um aplicativo totalmente confiável terá o mesmo acesso aos recursos do sistema que o aplicativo hospedeiro. Para obter mais informações, consulte Windows Presentation Foundation Partial Trust Security.

Carregando XAML a partir do código

XAML pode ser usado para definir um interface do usuário inteira, mas às vezes é também apropriado definir apenas uma parte da interface do usuário em XAML. Esse recurso pode ser usado para habilitar personalização parcial, armazenamento local de informações, uso de XAML para fornecer um objeto comercial, ou uma variedade de situações possíveis. A chave para essas situações é a classe XamlReader e o método Load. A entrada é um arquivo XAML, e a saída é um objeto que representa toda a árvore de objetos em tempo de execução que foi criada a partir dessa marcação. Em seguida, você pode inserir o objeto a ser uma propriedade de outro objeto que já existe no aplicativo. Desde que a propriedade seja uma propriedade adequada no modelo de conteúdo que possui recursos para sua eventual exibição e que irá notificar o mecanismo de execução que novo conteúdo foi adicionado ao aplicativo, você pode facilmente modificar o conteúdo de um aplicatiuvo em execução ao carregar XAML. Observe que esse recurso geralmente só está disponível em aplicativos de confiança total, por causa das implicações de segurança óbvias decorrentes do carregamento de arquivos em aplicativos à medida que eles são executados.

O Que Mais Há

Este tópico fornece uma introdução básica para os coneitos e terminologia da sintaxe XAML. Para mais informações sobre os termos usados aqui, consulte Terminologia de sintaxe XAML.

Se você ainda tiver não feito isso, tente o tutorial Getting Started with Windows Presentation Foundation. Quando você realmente criar o aplicativo de marcação descrito pelo tutorial, o exercício ajudará a reforçar muitos dos conceitos descritos neste tópico.

WPF usa um modelo de alicativo que tem base na classe Application. Para obter detalhes, consulte:Visão Geral do Gerenciamento de Aplicativo.

Building a WPF Application (WPF) fornece mais detalhes sobre como criar aplicativos incluindo XAML a partir de linha de comando e com Microsoft Visual Studio.

Visão geral sobre propriedades de dependência fornece mais informações sobre a versatilidade das propriedades no Windows Presentation Foundation (WPF) e apresenta o conceito de propriedades de dependência.

Finalmente, uma ferramenta de edição XAML chamada XAMLPad está incluída no SDK. Você pode usar essa ferramenta para fazer experiências com XAML em tempo real.

Consulte também

Conceitos

XAMLPad

XAML e classes personalizadas

Visão geral sobre elementos base

Árvores em WPF

Outros recursos

Namespace XAML (x:) Recursos da linguagem

Extensões XAML do Namespace WPF

Modelos de conteúdo