Compartilhar via

Visão geral do XAML

  • Artigo

Este artigo apresenta a linguagem XAML e os conceitos de XAML para o público de desenvolvedores de aplicativos do Tempo de Execução do Windows e descreve as diferentes maneiras de declarar objetos e definir atributos em XAML conforme ele é usado para criar um aplicativo do Tempo de Execução do Windows.

O que é XAML?

Extensible Application Markup Language (XAML) é uma linguagem declarativa. Especificamente, o XAML pode inicializar objetos e definir propriedades de objetos usando uma estrutura de linguagem que mostra relações hierárquicas entre vários objetos e uma convenção de tipo de suporte que dá suporte à extensão de tipos. Você pode criar elementos de interface do usuário visíveis na marcação XAML declarativa. Em seguida, você pode associar um arquivo code-behind separado para cada arquivo XAML que pode responder a eventos e manipular os objetos que você declara originalmente em XAML.

A linguagem XAML oferece suporte ao intercâmbio de fontes entre diferentes ferramentas e funções no processo de desenvolvimento, como a troca de fontes XAML entre ferramentas de design e um IDE (ambiente de desenvolvimento interativo) ou entre desenvolvedores primários e desenvolvedores de localização. Usando XAML como o formato de intercâmbio, as funções de designer e de desenvolvedor podem ser mantidas separadas ou reunidas, e designers e desenvolvedores podem iterar durante a produção de um aplicativo.

Quando você os vê como parte de seus projetos de aplicativo do Tempo de Execução do Windows, os arquivos XAML são arquivos XML com a extensão de nome de arquivo .xaml.

Sintaxe XAML básica

O XAML tem uma sintaxe básica que se baseia em XML. Por definição, o XAML válido também deve ser XML válido. Mas o XAML também tem conceitos de sintaxe que recebem um significado diferente e mais completo, embora ainda sejam válidos em XML de acordo com a especificação XML 1.0. Por exemplo, o XAML dá suporte à sintaxe de elemento de propriedade, em que os valores de propriedade podem ser definidos dentro de elementos em vez de como valores de cadeia de caracteres em atributos ou como conteúdo. Para XML normal, um elemento de propriedade XAML é um elemento com um ponto em seu nome, portanto, é válido para XML simples, mas não tem o mesmo significado.

XAML e Visual Studio

O Microsoft Visual Studio ajuda você a produzir sintaxe XAML válida, tanto no editor de texto XAML quanto na superfície de design XAML mais orientada graficamente. Ao escrever XAML para seu aplicativo usando o Visual Studio, não se preocupe muito com a sintaxe a cada pressionamento de tecla. O IDE incentiva a sintaxe XAML válida fornecendo dicas de preenchimento automático, mostrando sugestões em listas e menus suspensos do Microsoft IntelliSense, mostrando bibliotecas de elementos de interface do usuário na janela Caixa de Ferramentas ou outras técnicas. Se esta for sua primeira experiência com XAML, ainda pode ser útil conhecer as regras de sintaxe e, particularmente, a terminologia que às vezes é usada para descrever as restrições ou opções ao descrever a sintaxe XAML em referência ou outros tópicos. Os detalhes da sintaxe XAML são abordados em um tópico separado, Guia de sintaxe XAML.

Namespaces XAML

Na programação geral, um namespace é um conceito de organização que determina como os identificadores para entidades de programação são interpretados. Usando namespaces, uma estrutura de programação pode separar identificadores declarados pelo usuário de identificadores declarados pela estrutura, eliminar a ambiguidade de identificadores por meio de qualificações de namespace, impor regras para definir o escopo de nomes e assim por diante. O XAML tem seu próprio conceito de namespace XAML que atende a essa finalidade para a linguagem XAML. Veja como o XAML aplica e estende os conceitos de namespace da linguagem XML:

  • O XAML usa o atributo XML reservado xmlns para declarações de namespace. O valor do atributo normalmente é um URI (Uniform Resource Identifier), que é uma convenção herdada do XML.
  • O XAML usa prefixos em declarações para declarar namespaces não padrão, e os usos de prefixo em elementos e atributos fazem referência a esse namespace.
  • O XAML tem um conceito de namespace padrão, que é o namespace usado quando não existe nenhum prefixo em um uso ou declaração. O namespace padrão pode ser definido de forma diferente para cada estrutura de programação XAML.
  • As definições de namespace herdam em um arquivo ou constructo XAML, do elemento pai para o elemento filho. Por exemplo, se você definir um namespace no elemento raiz de um arquivo XAML, todos os elementos dentro desse arquivo herdarão essa definição de namespace. Se um elemento mais adiante na página redefinir o namespace, os descendentes desse elemento herdarão a nova definição.
  • Os atributos de um elemento herdam os namespaces do elemento. É bastante incomum ver prefixos em atributos XAML.

Um arquivo XAML quase sempre declara um namespace XAML padrão em seu elemento raiz. O namespace XAML padrão define quais elementos você pode declarar sem qualificá-los por um prefixo. Para projetos típicos de aplicativos do Tempo de Execução do Windows, esse namespace padrão contém todo o vocabulário XAML interno para o Tempo de Execução do Windows usado para definições de interface do usuário: os controles padrão, elementos de texto, gráficos e animações XAML, tipos de suporte a vinculação de dados e estilo e assim por diante. A maior parte do XAML que você escreverá para aplicativos do Tempo de Execução do Windows poderá, portanto, evitar o uso de namespaces e prefixos XAML ao se referir a elementos comuns da interface do usuário.

Aqui está um snippet que mostra uma raiz criada Page por modelo da página inicial de um aplicativo (mostrando apenas a tag de abertura e simplificada). Ele declara o namespace padrão e também o namespace x (que explicaremos a seguir).

<Page
    x:Class="Application1.BlankPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>

O namespace XAML da linguagem XAML

Um namespace XAML específico declarado em quase todos os arquivos XAML do Tempo de Execução do Windows é o namespace da linguagem XAML. Esse namespace inclui elementos e conceitos definidos pela especificação da linguagem XAML. Por convenção, o namespace XAML da linguagem XAML é mapeado para o prefixo "x". Os modelos de projeto e arquivo padrão para projetos de aplicativo do Tempo de Execução do Windows sempre definem o namespace XAML padrão (sem prefixo, apenas xmlns=) e o namespace XAML da linguagem XAML (prefixo "x") como parte do elemento raiz.

O prefixo "x"/namespace XAML da linguagem XAML contém vários constructos de programação que você usa com freqüência em seu XAML. Veja a seguir os mais comuns:

Termo Descrição
x:Chave Define uma chave exclusiva definida pelo usuário para cada recurso em um arquivo XAML ResourceDictionary. A cadeia de caracteres de token da chave é o argumento para a extensão de marcação StaticResource , e você usa essa chave posteriormente para recuperar o recurso XAML de outro uso de XAML em outro lugar no XAML do aplicativo.
x:Classe Especifica o namespace de código e o nome da classe de código para a classe que fornece code-behind para uma página XAML. Isso nomeia a classe que é criada ou unida pelas ações de compilação quando você cria seu aplicativo. Essas ações de build dão suporte ao compilador de marcação XAML e combinam sua marcação e code-behind quando o aplicativo é compilado. Você deve ter essa classe para dar suporte ao code-behind para uma página XAML. Window.Content no modelo de ativação padrão do Tempo de Execução do Windows.
x:Nome Especifica um nome de objeto de tempo de execução para a instância que existe no código de tempo de execução depois que um elemento de objeto definido em XAML é processado. Você pode pensar em definir x:Name em XAML como sendo como declarar uma variável nomeada no código. Como você aprenderá mais tarde, é exatamente isso que acontece quando o XAML é carregado como um componente de um aplicativo do Tempo de Execução do Windows.
Note Name é uma propriedade semelhante na estrutura, mas nem todos os elementos dão suporte a ela. Use x:Name para identificação de elemento sempre que FrameworkElement.Name não tiver suporte nesse tipo de elemento.
x:Uid Identifica elementos que devem usar recursos localizados para alguns de seus valores de propriedade. Para obter mais informações sobre como usar x:Uid, consulte Guia de início rápido: traduzindo recursos da interface do usuário.
Tipos de dados XAML intrínsecos Esses tipos podem especificar valores para tipos de valor simples quando isso é necessário para um atributo ou recurso. Esses tipos intrínsecos correspondem aos tipos de valor simples que normalmente são definidos como parte das definições intrínsecas de cada linguagem de programação. Por exemplo, talvez você precise de um objeto que represente um valor booliano verdadeiro para usar em um ObjectAnimationUsingKeyFrames estado visual com storyboard. Para esse valor em XAML, você usaria o tipo intrínseco x:Boolean como o elemento de objeto, desta forma: <x:Boolean>True</x:Boolean>

Existem outras construções de programação no namespace XAML da linguagem XAML, mas não são tão comuns.

Mapeando tipos personalizados para namespaces XAML

Um dos aspectos mais poderosos do XAML como linguagem é que é fácil estender o vocabulário XAML para seus aplicativos do Tempo de Execução do Windows. Você pode definir seus próprios tipos personalizados na linguagem de programação do aplicativo e, em seguida, fazer referência a seus tipos personalizados na marcação XAML. O suporte para extensão por meio de tipos personalizados é fundamentalmente integrado ao funcionamento da linguagem XAML. Estruturas ou desenvolvedores de aplicativos são responsáveis por criar os objetos de suporte aos quais o XAML faz referência. Nem as estruturas nem o desenvolvedor do aplicativo estão vinculados às especificações do que os objetos em seus vocabulários representam ou fazem além das regras básicas de sintaxe XAML. (Há algumas expectativas sobre o que os tipos de namespace XAML da linguagem XAML devem fazer, mas o Tempo de Execução do Windows fornece todo o suporte necessário.)

Se você usar XAML para tipos provenientes de bibliotecas diferentes das bibliotecas principais e metadados do Tempo de Execução do Windows, deverá declarar e mapear um namespace XAML com um prefixo. Use esse prefixo em usos de elemento para fazer referência aos tipos que foram definidos em sua biblioteca. Você declara mapeamentos de prefixo como atributos xmlns , normalmente em um elemento raiz junto com as outras definições de namespace XAML.

Para criar sua própria definição de namespace que faz referência a tipos personalizados, primeiro especifique a palavra-chave xmlns:, em seguida, o prefixo desejado. O valor desse atributo deve conter a palavra-chave usando: como a primeira parte do valor. O restante do valor é um token de cadeia de caracteres que faz referência ao namespace de suporte de código específico que contém seus tipos personalizados, por nome.

O prefixo define o token de marcação usado para se referir a esse namespace XAML no restante da marcação nesse arquivo XAML. Um caractere de dois-pontos (:) fica entre o prefixo e a entidade a ser referenciada no namespace XAML.

Por exemplo, a sintaxe de atributo para mapear um prefixo myTypes para o namespace myCompany.myTypes é: xmlns:myTypes="using:myCompany.myTypes", e um uso de elemento representativo é: <myTypes:CustomButton/>

Para obter mais informações sobre como mapear namespaces XAML para tipos personalizados, incluindo considerações especiais para extensões de componente do Visual C++ (C++/CX), consulte Namespaces XAML e mapeamento de namespace.

Outros namespaces XAML

Você geralmente vê arquivos XAML que definem os prefixos "d" (para namespace de designer) e "mc" (para compatibilidade de marcação). Geralmente, eles são para suporte de infraestrutura ou para habilitar cenários em uma ferramenta de tempo de design. Para obter mais informações, consulte a seção "Outros namespaces XAML" do tópico Namespaces XAML.

Extensões de marcação

As extensões de marcação são um conceito de linguagem XAML que geralmente é usado na implementação XAML do Tempo de Execução do Windows. As extensões de marcação geralmente representam algum tipo de "atalho" que permite que um arquivo XAML acesse um valor ou comportamento que não esteja simplesmente declarando elementos com base em tipos de suporte. Algumas extensões de marcação podem definir propriedades com cadeias de caracteres simples ou com elementos aninhados adicionais, com o objetivo de simplificar a sintaxe ou a fatoração entre diferentes arquivos XAML.

Na sintaxe de atributo XAML, as chaves "{" e "}" indicam um uso de extensão de marcação XAML. Esse uso direciona o processamento XAML para escapar do tratamento geral de tratar valores de atributo como uma cadeia de caracteres literal ou um valor conversível diretamente em cadeia de caracteres. Em vez disso, um analisador XAML chama o código que fornece comportamento para essa extensão de marcação específica, e esse código fornece um objeto alternativo ou resultado de comportamento que o analisador XAML precisa. As extensões de marcação podem ter argumentos, que seguem o nome da extensão de marcação e também estão contidos nas chaves. Normalmente, uma extensão de marcação avaliada fornece um valor retornado de objeto. Durante a análise, esse valor retornado é inserido na posição na árvore de objetos em que o uso da extensão de marcação estava no XAML de origem.

O XAML do Tempo de Execução do Windows dá suporte a essas extensões de marcação definidas no namespace XAML padrão e são compreendidas pelo analisador XAML do Tempo de Execução do Windows:

  • {x:Bind}: dá suporte à associação de dados, que adia a avaliação da propriedade até o tempo de execução, executando o código de finalidade especial, que ele gera em tempo de compilação. Essa extensão de marcação dá suporte a uma ampla variedade de argumentos.
  • {Binding}: dá suporte à associação de dados, que adia a avaliação da propriedade até o tempo de execução executando a inspeção de objeto de tempo de execução de uso geral. Essa extensão de marcação dá suporte a uma ampla variedade de argumentos.
  • {StaticResource}: dá suporte à referência a valores de recursos definidos em um ResourceDictionaryarquivo . Esses recursos podem estar em um arquivo XAML diferente, mas devem ser encontrados pelo analisador XAML no momento do carregamento. O argumento de um {StaticResource} uso identifica a chave (o nome) de um recurso com chave em um ResourceDictionary.
  • {ThemeResource}: semelhante a {StaticResource} , mas pode responder a alterações de tema em tempo de execução. {ThemeResource} aparece com bastante frequência nos modelos XAML padrão do Tempo de Execução do Windows, pois a maioria desses modelos foi projetada para compatibilidade com o usuário alternando o tema enquanto o aplicativo está em execução.
  • {TemplateBinding}: um caso especial de {Binding} que dá suporte a modelos de controle em XAML e seu uso eventual em tempo de execução.
  • {RelativeSource}: habilita uma forma específica de associação de modelo em que os valores vêm do pai do modelo.
  • {CustomResource}: para cenários avançados de pesquisa de recursos.

O Tempo de Execução do Windows também dá suporte à extensão de marcação {x:Null}. Use isso para definir valores anuláveis como nulos em XAML. Por exemplo, você pode usar isso em um modelo de controle para um CheckBox, que interpreta null como um estado de verificação indeterminado (acionando o estado visual "Indeterminado").

Uma extensão de marcação geralmente retorna uma instância existente de alguma outra parte do grafo de objeto para o aplicativo ou adia um valor para o tempo de execução. Como você pode usar uma extensão de marcação como um valor de atributo, e esse é o uso típico, muitas vezes você vê extensões de marcação fornecendo valores para propriedades de tipo de referência que, de outra forma, poderiam exigir uma sintaxe de elemento de propriedade.

Por exemplo, aqui está a sintaxe para referenciar um reutilizável Style de um ResourceDictionary: <Button Style="{StaticResource SearchButtonStyle}"/>. A Style é um tipo de referência, não um valor simples, portanto, sem o {StaticResource} uso, você precisaria de um <Button.Style> elemento de propriedade e uma <Style> definição dentro dele para definir a FrameworkElement.Style propriedade.

Usando extensões de marcação, todas as propriedades configuráveis em XAML são potencialmente configuráveis na sintaxe de atributo. Você pode usar a sintaxe de atributo para fornecer valores de referência para uma propriedade, mesmo que ela não dê suporte a uma sintaxe de atributo para instanciação direta de objetos. Ou você pode habilitar um comportamento específico que adia o requisito geral de que as propriedades XAML sejam preenchidas por tipos de valor ou por tipos de referência recém-criados.

Para ilustrar, o próximo exemplo XAML define o FrameworkElement.Style valor da propriedade de a Border usando a sintaxe de atributo. A FrameworkElement.Style propriedade usa uma instância da Windows.UI.Xaml.Style classe, um tipo de referência que, por padrão, não pôde ser criado usando uma cadeia de caracteres de sintaxe de atributo. Mas nesse caso, o atributo referencia uma extensão de marcação específica, StaticResource. Quando essa extensão de marcação é processada, ela retorna uma referência a um elemento Style que foi definido anteriormente como um recurso com chave em um dicionário de recursos.

<Canvas.Resources>
  <Style TargetType="Border" x:Key="PageBackground">
    <Setter Property="BorderBrush" Value="Blue"/>
    <Setter Property="BorderThickness" Value="5"/>
  </Style>
</Canvas.Resources>
...
<Border Style="{StaticResource PageBackground}">
  ...
</Border>

Você pode aninhar extensões de marcação. A extensão de marcação mais interna é avaliada primeiro.

Devido às extensões de marcação, você precisa de sintaxe especial para um valor literal "{" em um atributo. Para obter mais informações, consulte Guia de sintaxe XAML.

Eventos

XAML é uma linguagem declarativa para objetos e suas propriedades, mas também inclui uma sintaxe para anexar manipuladores de eventos a objetos na marcação. A sintaxe do evento XAML pode integrar os eventos declarados por XAML por meio do modelo de programação do Tempo de Execução do Windows. Você especifica o nome do evento como um nome de atributo no objeto em que o evento é manipulado. Para o valor do atributo, você especifica o nome de uma função de manipulador de eventos que você define no código. O processador XAML usa esse nome para criar uma representação delegada na árvore de objetos carregada e adiciona o manipulador especificado a uma lista de manipuladores internos. Quase todos os aplicativos do Tempo de Execução do Windows são definidos por fontes de marcação e code-behind.

A seguir está um exemplo simples. A Button classe oferece suporte a um evento chamado Click. Você pode escrever um manipulador para Click que executa o código que deve ser invocado depois que o usuário clica no Button. Em XAML, você especifica Click como um atributo no Button. Para o valor do atributo, forneça uma cadeia de caracteres que seja o nome do método do manipulador.

<Button Click="showUpdatesButton_Click">Show updates</Button>

Quando você compila, o compilador agora espera que haja um método chamado showUpdatesButton_Click definido no arquivo code-behind, no namespace declarado no valor x:Class da página XAML. Além disso, esse método deve satisfazer o contrato de delegado para o Click evento. Por exemplo:

namespace App1
{
    public sealed partial class MainPage: Page {
        ...
        private void showUpdatesButton_Click (object sender, RoutedEventArgs e) {
            //your code
        }
    }
}

' Namespace included at project level
Public NotInheritable Class MainPage
    Inherits Page
        ...
        Private Sub showUpdatesButton_Click (sender As Object, e As RoutedEventArgs e)
            ' your code
        End Sub
    ...
End Class

namespace winrt::App1::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
        ...
        void showUpdatesButton_Click(Windows::Foundation::IInspectable const&, Windows::UI::Xaml::RoutedEventArgs const&);
    };
}

// .h
namespace App1
{
    public ref class MainPage sealed {
        ...
    private:
        void showUpdatesButton_Click(Object^ sender, RoutedEventArgs^ e);
    };
}

Em um projeto, o XAML é escrito como um arquivo .xaml e você usa a linguagem de sua preferência (C#, Visual Basic, C++/CX) para escrever um arquivo code-behind. Quando um arquivo XAML é compilado por marcação como parte de uma ação de build para o projeto, o local do arquivo code-behind XAML para cada página XAML é identificado especificando um namespace e uma classe como o atributo x:Class do elemento raiz da página XAML. Para obter mais informações sobre como esses mecanismos funcionam em XAML e como eles se relacionam com os modelos de programação e aplicativo, consulte Visão geral de eventos e eventos roteados.

Observação

Para C++/CX, há dois arquivos code-behind: um é um cabeçalho (.xaml.h) e o outro é a implementação (.xaml.cpp). A implementação faz referência ao cabeçalho e, tecnicamente, é o cabeçalho que representa o ponto de entrada para a conexão code-behind.

Dicionários de recurso

Criar um ResourceDictionary é uma tarefa comum que geralmente é realizada com a criação de um dicionário de recursos como uma área de uma página XAML ou um arquivo XAML separado. Dicionários de recursos e como usá-los é uma área conceitual mais ampla que está fora do escopo deste tópico. Para obter mais informações, consulte ResourceDictionary e referências de recursos XAML.

XAML e XML

A linguagem XAML é fundamentalmente baseada na linguagem XML. Mas o XAML estende o XML significativamente. Em particular, ele trata o conceito de esquema de maneira bem diferente devido à sua relação com o conceito de tipo de suporte e adiciona elementos de linguagem, como membros anexados e extensões de marcação. xml:lang é válido em XAML, mas influencia o tempo de execução em vez de analisar o comportamento e normalmente é alias para uma propriedade no nível da estrutura. Para saber mais, confira FrameworkElement.Language. xml:base é válido na marcação, mas os analisadores o ignoram. xml:space é válido, mas só é relevante para cenários descritos no tópico XAML e espaço em branco. O atributo de codificação é válido em XAML. Somente as codificações UTF-8 e UTF-16 são suportadas. A codificação UTF-32 não é suportada.

Diferenciação de maiúsculas e minúsculas em XAML

O XAML diferencia maiúsculas de minúsculas. Essa é outra consequência do XAML ser baseado em XML, que diferencia maiúsculas de minúsculas. Os nomes de elementos e atributos XAML diferenciam maiúsculas de minúsculas. O valor de um atributo é potencialmente sensível a maiúsculas e minúsculas; Isso depende de como o valor do atributo é tratado para propriedades específicas. Por exemplo, se o valor do atributo declarar um nome de membro de uma enumeração, o comportamento interno que converte uma cadeia de caracteres de nome de membro para retornar o valor do membro da enumeração não diferencia maiúsculas de minúsculas. Por outro lado, o valor da propriedade Name e os métodos utilitários para trabalhar com objetos com base no nome declarado pela propriedade Name tratam a cadeia de caracteres name como sensível a maiúsculas e minúsculas.

Namescopes XAML

A linguagem XAML define um conceito de namescope XAML. O conceito de namescope XAML influencia como os processadores XAML devem tratar o valor de x:Name ou Name aplicado a elementos XAML, particularmente os escopos nos quais os nomes devem ser considerados identificadores exclusivos. Os namescopes XAML são abordados com mais detalhes em um tópico separado; consulte Namescopes XAML.

A função do XAML no processo de desenvolvimento

O XAML desempenha várias funções importantes no processo de desenvolvimento de aplicativos.

  • XAML é o formato principal para declarar a interface do usuário e os elementos de um aplicativo nessa interface do usuário, se você estiver programando usando C#, Visual Basic ou C++/CX. Normalmente, pelo menos um arquivo XAML em seu projeto representa uma metáfora de página em seu aplicativo para a interface do usuário exibida inicialmente. Arquivos XAML adicionais podem declarar páginas adicionais para a interface do usuário de navegação. Outros arquivos XAML podem declarar recursos, como modelos ou estilos.
  • Você usa o formato XAML para declarar estilos e modelos aplicados a controles e interface do usuário para um aplicativo.
  • Você pode usar estilos e modelos para modelar controles existentes ou se definir um controle que forneça um modelo padrão como parte de um pacote de controle. Quando você o usa para definir estilos e modelos, o XAML relevante geralmente é declarado como um arquivo XAML discreto com uma ResourceDictionary raiz.
  • XAML é o formato comum para suporte de designer de criação de interface do usuário do aplicativo e troca do design da interface do usuário entre diferentes aplicativos de designer. Mais notavelmente, o XAML para o aplicativo pode ser trocado entre diferentes ferramentas de design XAML (ou janelas de design dentro de ferramentas).
  • Várias outras tecnologias também definem a interface do usuário básica em XAML. Em relação ao XAML do Windows Presentation Foundation (WPF) e ao XAML do Microsoft Silverlight, o XAML para Windows Runtime usa o mesmo URI para seu namespace XAML padrão compartilhado. O vocabulário XAML para o Tempo de Execução do Windows se sobrepõe significativamente ao vocabulário XAML para interface do usuário também usado pelo Silverlight e, em menor grau, pelo WPF. Assim, o XAML promove um caminho de migração eficiente para a interface do usuário originalmente definida para tecnologias precursoras que também usavam XAML.
  • O XAML define a aparência visual de uma interface do usuário e um arquivo code-behind associado define a lógica. Você pode ajustar o design da interface do usuário sem fazer alterações na lógica no code-behind. O XAML simplifica o fluxo de trabalho entre designers e desenvolvedores.
  • Devido à riqueza do designer visual e do suporte à superfície de design para a linguagem XAML, o XAML dá suporte à prototipagem rápida da interface do usuário nas fases iniciais de desenvolvimento.

Dependendo de sua própria função no processo de desenvolvimento, talvez você não interaja muito com o XAML. O grau em que você interage com arquivos XAML também depende de qual ambiente de desenvolvimento você está usando, se você usa recursos de ambiente de design interativo, como caixas de ferramentas e editores de propriedades, e o escopo e a finalidade do seu aplicativo do Tempo de Execução do Windows. No entanto, é provável que, durante o desenvolvimento do aplicativo, você edite um arquivo XAML no nível do elemento usando um editor de texto ou XML. Usando essas informações, você pode editar o XAML com confiança em uma representação de texto ou XML e manter a validade das declarações e da finalidade desse arquivo XAML quando ele for consumido por ferramentas, operações de compilação de marcação ou a fase de tempo de execução do seu aplicativo do Tempo de Execução do Windows.

Otimize seu XAML para desempenho de carga

Aqui estão algumas dicas para definir elementos de interface do usuário em XAML usando as práticas recomendadas de desempenho. Muitas dessas dicas estão relacionadas ao uso de recursos XAML, mas estão listadas aqui na visão geral do XAML por conveniência. Para obter mais informações sobre recursos XAML, consulte ResourceDictionary e referências de recursos XAML. Para obter mais algumas dicas sobre desempenho, incluindo XAML que demonstra propositalmente algumas das práticas de desempenho ruim que você deve evitar em seu XAML, consulte Otimizar sua marcação XAML.

  • Se você usar o mesmo pincel de cores com frequência em seu XAML, defina a SolidColorBrush como um recurso em vez de usar uma cor nomeada como um valor de atributo a cada vez.
  • Se você usar o mesmo recurso em mais de uma página de interface do usuário, considere defini-lo em Resources vez de em cada página. Por outro lado, se apenas uma página usar um recurso, não o defina em Application.Resources e, em vez disso, defina-o apenas para a página que precisa dele. Isso é bom tanto para fatoração XAML durante a criação do aplicativo quanto para desempenho durante a análise XAML.
  • Para recursos que seu aplicativo empacota, verifique se há recursos não utilizados (um recurso que tem uma chave, mas não há nenhuma referência StaticResource em seu aplicativo que o usa). Remova-os do XAML antes de lançar o aplicativo.
  • Se você estiver usando arquivos XAML separados que fornecem recursos de design (MergedDictionaries), considere comentar ou remover recursos não utilizados desses arquivos. Mesmo que você tenha um ponto de partida XAML compartilhado que esteja usando em mais de um aplicativo ou que forneça recursos comuns para todo o seu aplicativo, ainda é seu aplicativo que empacota os recursos XAML a cada vez e, potencialmente, precisa carregá-los.
  • Não defina elementos de interface do usuário que você não precisa para a composição e use os modelos de controle padrão sempre que possível (esses modelos já foram testados e verificados quanto ao desempenho de carregamento).
  • Use contêineres como Border overdraws deliberados de elementos de interface do usuário, em vez de exageros. Basicamente, não desenhe o mesmo pixel várias vezes. Para obter mais informações sobre overdraw e como testá-lo, consulte DebugSettings.IsOverdrawHeatMapEnabled.
  • Use os modelos de itens padrão para ListView ou GridView; eles têm uma lógica especial do Presenter que resolve problemas de desempenho ao criar a árvore visual para um grande número de itens de lista.

Depurar XAML

Como o XAML é uma linguagem de marcação, algumas das estratégias típicas de depuração no Microsoft Visual Studio não estão disponíveis. Por exemplo, não há como definir um ponto de interrupção em um arquivo XAML. No entanto, há outras técnicas que podem ajudá-lo a depurar problemas com definições de interface do usuário ou outra marcação XAML enquanto você ainda está desenvolvendo seu aplicativo.

Quando há problemas com um arquivo XAML, o resultado mais comum é que algum sistema ou seu aplicativo gerará uma exceção de análise XAML. Sempre que há uma exceção de análise XAML, o XAML carregado pelo analisador XAML falha ao criar uma árvore de objetos válida. Em alguns casos, como quando o XAML representa a primeira "página" do aplicativo carregada como o visual raiz, a exceção de análise XAML não é recuperável.

O XAML geralmente é editado em um IDE, como o Visual Studio e uma de suas superfícies de design XAML. O Visual Studio geralmente pode fornecer validação em tempo de design e verificação de erros de uma fonte XAML à medida que você a edita. Por exemplo, ele pode exibir "rabiscos" no editor de texto XAML assim que você digitar um valor de atributo inválido, e você nem precisará esperar por uma passagem de compilação XAML para ver que algo está errado com a definição da interface do usuário.

Depois que o aplicativo realmente for executado, se algum erro de análise XAML não tiver sido detectado em tempo de design, ele será relatado pelo CLR (Common Language Runtime) como um XamlParseException. Para obter mais informações sobre o que você pode fazer para um XamlParseException em tempo de execução, consulte Tratamento de exceções para aplicativos do Tempo de Execução do Windows em C# ou Visual Basic.

Observação

Os aplicativos que usam C++/CX para código não obtêm o XamlParseException específico. Mas a mensagem na exceção esclarece que a origem do erro está relacionada ao XAML e inclui informações de contexto, como números de linha em um arquivo XAML, assim como XamlParseException faz.

Para obter mais informações sobre como depurar um aplicativo do Tempo de Execução do Windows, consulte Iniciar uma sessão de depuração.