Visão geral do XAML

Este artigo apresenta a linguagem XAML e os conceitos XAML para o público do desenvolvedor de aplicativos do Tempo de Execução do Windows e descreve as diferentes maneiras de declarar objetos e definir atributos em XAML como 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 oferece suporte à extensão de tipos. Você pode criar elementos visíveis da interface do usuário 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 ambiente de desenvolvimento interativo (IDE) ou entre desenvolvedores primários e desenvolvedores de localização. Usando XAML como formato de troca, as funções de designer e de desenvolvedor podem ser mantidas separadas ou combinadas, e designers e desenvolvedores podem iterar durante o desenvolvimento de uma aplicação.

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

XAML tem uma sintaxe básica que se baseia em XML. Por definição, XAML válido também deve ser XML válido. Mas o XAML também tem conceitos de sintaxe aos quais é atribuído um significado diferente e mais completo, embora ainda seja válido em XML de acordo com a especificação XML 1.0. Por exemplo, o XAML oferece suporte à sintaxe do elemento de propriedade, onde 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 regular, 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 listas suspensas do Microsoft IntelliSense, mostrando bibliotecas de elementos da 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 pontos finos 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, desambiguar identificadores por meio de qualificações de namespace, impor regras para definir o escopo de nomes e assim por diante. XAML tem seu próprio conceito de namespace XAML que serve 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 usos de prefixo em elementos e atributos fazem referência a esse namespace.
XAML tem um conceito de um namespace padrão, que é o namespace usado quando nenhum prefixo existe 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 são herdadas num ficheiro ou numa construção XAML, de elemento pai para 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 maioria dos 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 trecho que mostra o elemento raiz de Página criado a partir de um modelo para a página inicial de um aplicativo (mostrando apenas a tag de abertura e de forma 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 que é declarado em quase todos os arquivos XAML do Tempo de Execução do Windows é o namespace de linguagem XAML. Esse namespace inclui elementos e conceitos definidos pela especificação da linguagem XAML. Por convenção, o namespace 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 em linguagem XAML (prefixo "x") como parte do elemento raiz.

O namespace XAML da linguagem XAML com prefixo "x" contém várias construções de programação que utiliza com frequência no seu XAML. Aqui estão os mais comuns:

Term	Description
x:Chave	Define uma chave exclusiva definida pelo usuário para cada recurso em um ResourceDictionary XAML. A cadeia de caracteres do token da chave é o argumento para a extensão de marcação StaticResource e usa-se essa chave posteriormente para obter o recurso XAML de outro uso de XAML noutra parte no XAML da aplicação.
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 compilação 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 a 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 em 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 se declarasse uma variável nomeada no código. Como irás aprender mais tarde, é exatamente isso que acontece quando o teu XAML é carregado como um componente de uma aplicação do Windows Runtime. ObservaçãoNome é uma propriedade semelhante na estrutura, mas nem todos os elementos oferecem suporte a ela. Use x:Name para identificação de elemento sempre que não houver suporte para FrameworkElement.Name nesse tipo de elemento.
x:Uid	Identifica elementos que devem usar recursos localizados para alguns de seus valores de propriedade. Para saber mais sobre como usar x:Uid, veja Guia de início rápido: traduzindo recursos da interface do usuário.
Tipos de dados intrínsecos XAML	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 são tipicamente definidos como parte das definições intrínsecas de cada linguagem de programação. Por exemplo, pode ser necessário um objeto que represente um valor Booleano verdadeiro para usar num estado visual ObjectAnimationUsingKeyFrames storyboarded. Para esse valor em XAML, você usaria o tipo intrínseco x:Boolean como o elemento object, da seguinte 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 aspetos 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 seu aplicativo e, em seguida, fazer referência aos seus tipos personalizados na marcação XAML. O suporte para extensão por meio de tipos personalizados é fundamentalmente incorporado 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 em 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 elementos 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 faça referência a tipos personalizados, primeiro especifique a palavra-chave xmlns:, depois 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 (:) vai entre o prefixo e a entidade a ser referenciada dentro do namespace XAML.

Por exemplo, a sintaxe do 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 saber mais sobre como mapear namespaces XAML para tipos personalizados, incluindo considerações especiais para extensões de componente do Visual C++ (C++/CX), veja Namespaces XAML e mapeamento de namespace.

Outros namespaces XAML

Você geralmente vê arquivos XAML que definem os prefixos "d" (para namespace de design) e "mc" (para compatibilidade de markup). Geralmente, estes são para suporte de infraestrutura ou para habilitar cenários numa ferramenta de conceção. 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 da linguagem XAML frequentemente usado na implementação XAML do Windows Runtime. As extensões de marcação geralmente representam algum tipo de "atalho" que permite a um arquivo XAML aceder a um valor ou comportamento, que não se limita simplesmente a declarar elementos com base em tipos subjacentes. Algumas extensões de marcação podem definir propriedades com cadeias de caracteres simples ou com elementos adicionalmente aninhados, com o objetivo de simplificar a sintaxe ou a fatoração entre diferentes arquivos XAML.

Na sintaxe do atributo XAML, as chaves "{" e "}" indicam um uso de extensão de marcação XAML. Esta utilização direciona o processamento XAML para sair do tratamento geral que considera valores de atributo como uma cadeia de caracteres literal ou um valor diretamente conversível em cadeia de caracteres. Em vez disso, um analisador XAML chama 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 de 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 encaracoladas. Normalmente, uma extensão de marcação avaliada fornece um valor de retorno de objeto. Durante a análise, esse valor de retorno é inserido na posição na árvore de objetos onde 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 compreendidas pelo analisador XAML do Tempo de Execução do Windows:

{x:Bind}: suporta vinculação de dados, que adia a avaliação da propriedade até o tempo de execução, executando código de finalidade especial, que gera em tempo de compilação. Esta extensão de marcação suporta uma ampla gama de argumentos.
{Binding}: suporta vinculação de dados, que adia a avaliação de propriedades até o tempo de execução, executando inspeção geral de objetos durante o tempo de execução. Esta extensão de marcação suporta uma ampla gama de argumentos.
{StaticResource}: suporta a referência a valores de recursos definidos em um ResourceDictionary. Esses recursos podem estar em um arquivo XAML diferente, mas devem ser localizáveis pelo analisador XAML no momento do carregamento. O argumento de uma {StaticResource} utilização identifica a chave (o nome) para um recurso com chave num 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, porque a maioria desses modelos é projetada para compatibilidade com o usuário alternando o tema enquanto o aplicativo está em execução.
{TemplateBinding}: um caso especial de {Binding} que suporta modelos de controle em XAML e seu eventual uso em tempo de execução.
{RelativeSource}: habilita uma forma específica de vinculação de modelo onde os valores vêm do pai modelado.
{CustomResource}: para cenários avançados de pesquisa de recursos.

Windows Runtime também suporta a 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 uma 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 objetos do aplicativo ou adia a atribuição de 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 ter exigido uma sintaxe de elemento de propriedade.

Por exemplo, aqui está a sintaxe para referenciar um estilo reutilizável de um ResourceDictionary: <Button Style="{StaticResource SearchButtonStyle}"/>. Um 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 propriedade FrameworkElement.Style .

Usando extensões de marcação, cada propriedade que é configurável em XAML é potencialmente configurável 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 ofereça suporte a uma sintaxe de atributo para instanciação direta de objeto. 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 de XAML define o valor da propriedade FrameworkElement.Style de um Border usando a sintaxe do atributo. A FrameworkElement.Style propriedade usa uma instância da classe Style , 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, neste caso, o atributo faz referência a 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 saber mais, veja Guia de sintaxe XAML.

Events

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 de evento XAML pode então integrar os eventos declarados em XAML através 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 onde o evento é manipulado. Para o valor do atributo, especifique o nome de uma função do manipulador de eventos que você define no código. O processador XAML usa esse nome para criar uma representação de representante na árvore de objetos carregada e adiciona o manipulador especificado a uma lista de manipuladores internos. Quase todos os aplicativos do Windows Runtime são definidos por fontes de marcação e code-behind.

Aqui está um exemplo simples. A classe Button 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 nomeado 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 evento Click . 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);
    };
}

Dentro de um projeto, o XAML é escrito como um arquivo .xaml e você usa a linguagem que preferir (C#, Visual Basic, C++/CX) para escrever um arquivo code-behind. Quando um arquivo XAML é compilado com marcação como parte de uma ação de compilação 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 saber mais sobre como esses mecanismos funcionam em XAML e como eles se relacionam com a programação e os modelos de aplicativo, veja 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 é 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 recursos

Criar um ResourceDictionary é uma tarefa comum que geralmente é realizada criando 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 maior que está fora do escopo deste tópico. Para saber mais , veja 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 forma bastante diferente por causa de 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 é aliado a uma propriedade de nível de estrutura. Para obter mais informações, consulte FrameworkElement.Language. xml:base é válido na marcação, mas os analisadores a 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. Apenas 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 é sensível a maiúsculas e minúsculas. Essa é mais uma consequência de o XAML ser baseado em XML, que diferencia maiúsculas de minúsculas. Os nomes dos elementos e atributos XAML são sensíveis a maiúsculas e minúsculas. O valor de um atributo é potencialmente case-sensitive; isto depende de como o valor do atributo é tratado em relação a 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 de membro de enumeração não diferencia maiúsculas de minúsculas. Por outro lado, o valor da propriedade Name e os métodos de utilitário para trabalhar com objetos com base no nome declarado pela propriedade Name tratam a cadeia de caracteres do nome como distingue maiúsculas de minúsculas.

namescopes de 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 de um aplicativo.
Você pode usar estilos e modelos para criar modelos de 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 raiz ResourceDictionary .
XAML é o formato comum para suporte à criação de UI de aplicativos por designers e troca de design de UI entre diferentes ferramentas de design. Mais notavelmente, o XAML para o aplicativo pode ser intercambiado 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 o Tempo de Execução do Windows 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 oferece 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, você pode não interagir muito com 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, pode editar XAML com confiança numa representação de texto ou XML e manter a validade das declarações e da finalidade desse arquivo XAML quando for consumido por ferramentas, operações de compilação de marcação ou pela fase de execução da sua aplicação Windows Runtime.

Otimize seu XAML para desempenho de carga

Aqui estão algumas dicas para definir elementos da interface do usuário em XAML usando práticas recomendadas para desempenho. Muitas dessas dicas estão relacionadas ao uso de recursos XAML, mas estão listadas aqui na visão geral de XAML por conveniência. Para saber mais sobre recursos XAML, veja 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 ruins 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 um 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 Application.Resources em vez de em cada página. Por outro lado, se apenas uma página usa 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 a fatoração XAML ao projetar seu aplicativo quanto para o 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 seu XAML antes de lançar seu aplicativo.
Se você estiver usando arquivos XAML separados que forneçam 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 todos os seus aplicativos, ainda é seu aplicativo que empacota os recursos XAML cada vez e, potencialmente, precisa carregá-los.
Não defina elementos da interface do usuário que você não precisa para 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 carga).
Use contêineres como Border em vez de superações deliberadas de elementos da interface do usuário. Basicamente, não desenhe o mesmo pixel várias vezes. Para obter mais informações sobre o excesso de sorteio 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 dentro de 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 outras marcações XAML enquanto você ainda está desenvolvendo seu aplicativo.

Quando há problemas com um arquivo XAML, o resultado mais típico é que algum sistema ou seu aplicativo lançará uma exceção de análise XAML. Sempre que há uma exceção de análise XAML, o XAML carregado pelo analisador XAML não conseguiu criar uma árvore de objetos válida. Em alguns casos, como quando o XAML representa a primeira "página" do seu aplicativo que é 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 "linhas onduladas" no editor de texto XAML assim que inserires um valor de atributo inválido, e nem precisas esperar por uma passagem de compilação XAML para ver que algo está errado com a tua definição de UI.

Quando o aplicativo realmente é executado, se algum erro de análise XAML não for detetado em tempo de design, eles serão relatados pelo Common Language Runtime (CLR) como um XamlParseException. Para saber mais sobre o que você pode fazer para um XamlParseException em tempo de execução, veja Tratamento de exceções para aplicativos do Tempo de Execução do Windows em C# ou Visual Basic.