Visão geral do XAML

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

O que é XAML?

XAML (Extensible Application Markup Language) é 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 backup 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 dá 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 formato de intercâmbio, as funções de designer e de desenvolvedor podem ser mantidas separadas ou reunidas, e designers e desenvolvedores podem colaborar durante a produção de um aplicativo.

Quando você os vê como parte de seus projetos de aplicativo do Windows Runtime, 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 que recebem um significado diferente e mais completo enquanto ainda são válidos em XML de acordo com a especificação XML 1.0. Por exemplo, o XAML dá suporte à sintaxe do elemento de propriedade, em que os valores de propriedade podem ser definidos dentro de elementos e não 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, ele é válido para XML simples, mas não tem o mesmo significado.

XAML e Visual Studio

O Microsoft Visual Studio ajuda você a produzir uma 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 com cada pressionamento de tecla. A 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 essa for sua primeira experiência com XAML, ainda poderá 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 organizador que determina como os identificadores de 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 nomes de escopo e assim por diante. O XAML tem seu próprio conceito de namespace XAML que serve a essa finalidade para a linguagem XAML. Veja como o XAML se 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 de 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 uma declaração ou uso. 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 XAML ou constructo, do elemento pai ao elemento filho. Por exemplo, se você definir um namespace no elemento raiz de um arquivo XAML, todos os elementos nesse arquivo herdarão essa definição de namespace. Se um elemento ainda mais na página redefinir o namespace, os descendentes desse elemento herdarão a nova definição.
• 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 Windows Runtime, esse namespace padrão contém todo o vocabulário XAML interno para o Windows Runtime usado para definições de interface do usuário: os controles padrão, elementos de texto, elementos gráficos XAML e animações, tipos de suporte de vinculação de dados e estilo e assim por diante. A maior parte do XAML que você escreverá para aplicativos do Windows Runtime poderá, portanto, evitar o uso de namespaces XAML e prefixos ao se referir a elementos comuns da interface do usuário.

Aqui está um trecho de código que mostra uma raiz de Page criada a partir de um modelo para a página inicial de um aplicativo (mostrando apenas a marca de abertura, 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 da linguagem XAML

Um namespace XAML específico que é declarado em quase todos os arquivos XAML do Windows Runtime é o namespace em 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 Windows Runtime 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 de linguagem XAML/prefixo "x" contém vários construtos de programação que você usa frequentemente em seu XAML. Aqui estão as mais comuns:

Outras construções de programação no namespace XAML em linguagem XAML existem, 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 Windows Runtime. Você pode definir seus próprios tipos personalizados na linguagem de programação do aplicativo e referenciar seus tipos personalizados na marcação XAML. O suporte à extensão por meio de tipos personalizados é integrado ao funcionamento da linguagem XAML. Estruturas ou desenvolvedores de aplicativos são responsáveis por criar os objetos de backup que o XAML faz referência. Nem frameworks nem o desenvolvedor de aplicativos são obrigados pelas 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 Windows Runtime fornece todo o suporte necessário.)

Se você usar XAML para tipos provenientes de bibliotecas diferentes das bibliotecas e metadados principais do Windows Runtime, 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, juntamente com outras definições de namespace XAML.

Para fazer 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 string que faz referência, pelo nome, ao namespace específico de suporte de código que contém seus tipos personalizados.

O prefixo define o token de marcação usado para fazer referência 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 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

Geralmente, você vê arquivos XAML que definem os prefixos "d" (para namespace de designer) e "mc" (para compatibilidade de marcação). Geralmente, elas são para suporte à infraestrutura ou para habilitar cenários em uma ferramenta de tempo de projeto. Para obter mais informações, consulte a seção "Outros namespaces XAML" do tópico de 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 Windows Runtime. As extensões de marcação geralmente representam algum tipo de "atalho" que permite que um arquivo XAML acesse um valor ou comportamento sem simplesmente declarar 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 do atributo XAML, as chaves "{" e "}" indicam a utilização de uma extensão de marcação XAML. Esse uso direciona o processamento XAML para escapar do tratamento geral de valores de atributo como uma cadeia de caracteres literal ou um valor conversível de cadeia de caracteres diretamente. 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 ou resultado de comportamento alternativo que o analisador XAML precisa. As extensões de marcação podem ter argumentos, os quais seguem o nome da extensão de marcação e também estão contidos dentro das chaves. Normalmente, uma extensão de marcação avaliada fornece um valor de retorno de objeto. Durante a análise, esse valor retornado é inserido na posição da árvore de objetos em que o uso da extensão de markup estava no XAML de origem.

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

• {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 gama de argumentos.
• {Binding}: dá suporte à vinculação de dados, que adia a avaliação da propriedade até o tempo de execução ao executar a inspeção de objetos de uso geral em tempo de execução. Essa extensão de marcação dá suporte a uma ampla gama de argumentos.
• {StaticResource}: dá suporte à referência a valores de recurso definidos em um ResourceDictionary. Esses recursos podem estar em um arquivo XAML diferente, mas, em última análise, devem ser localizados pelo analisador XAML no tempo de carregamento. O argumento de uma {StaticResource} utilização identifica a chave (o nome) para um recurso chaveado em um ResourceDictionary.
• {ThemeResource}: semelhante a {StaticResource}, mas pode responder a alterações de tema em tempo de execução. {ThemeResource} aparece frequentemente nos modelos XAML padrão do Windows Runtime, pois a maioria desses modelos são projetados 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 no 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 modelo.
• {CustomResource}: para cenários avançados de pesquisa de recursos.

O Windows Runtime 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 usá-lo em um modelo de controle para uma CheckBox, que interpreta nulo como um estado de verificação indeterminado (disparando 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, você geralmente 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 Estilo é 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 no 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 dê suporte a uma sintaxe de atributo para instanciação de objeto direto. Ou você pode habilitar um comportamento específico que adie 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 valor da propriedade FrameworkElement.Style de uma Borda usando a sintaxe de 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, nesse 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 obter mais informações, consulte o 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 de evento XAML pode integrar os eventos declarados por XAML por meio do modelo de programação do Windows Runtime. Especifique o nome do evento como um nome de atributo no objeto em que o evento é tratado. Para o valor do atributo, especifique 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 Windows Runtime são definidos por fontes de marcação e code-behind.

Aqui está um exemplo simples. A classe Button dá suporte a um evento chamado Click. Você pode escrever um manipulador para Clique que executa o código que deve ser invocado depois que o usuário clica no Botão. No XAML, especifique Clique como um atributo no Botão. Para o valor do atributo, forneça uma cadeia de caracteres que é 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);
    };
}

Em um projeto, o XAML é escrito como um arquivo .xaml e você usa o idioma que prefere (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 no XAML e como eles se relacionam com os modelos de programação e aplicativos, consulte Eventos e a visão geral de eventos roteados.

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 obter mais informações, consulte as referências de recursos ResourceDictionary e XAML.

XAML e XML

A linguagem XAML é fundamentalmente baseada na linguagem XML. Mas o XAML estende o XML significativamente. Em particular, trata o conceito de esquema de maneira bastante diferente devido à sua relação com o conceito de tipo de apoio e adiciona elementos de linguagem, como membros associados e extensões de marcação. xml:lang é válido em XAML, mas influencia o comportamento em tempo de execução em vez do comportamento de análise, e normalmente é mapeada 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 é relevante apenas para cenários descritos no tópico XAML e whitespace . O atributo de codificação é válido em XAML. Há suporte apenas para codificações UTF-8 e UTF-16. Não há suporte para codificação UTF-32.

Sensibilidade a maiúsculas e minúsculas em XAML

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 são sensíveis a maiúsculas e minúsculas. O valor de um atributo pode ser sensível a maiúsculas e minúsculas; isto depende de como o valor do atributo é gerenciado 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 de 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 que a propriedade Name declara tratam a cadeia de caracteres do nome como diferenciando maiúsculas e minúsculas.

Namescopes XAML

A linguagem XAML define o conceito de um 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 confiados para serem identificadores exclusivos. Os namescopes XAML são abordados com mais detalhes em um tópico separado; consulte namescopes XAML.

A função de 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 de um aplicativo e elementos 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 interface do usuário de navegação. Outros arquivos XAML podem declarar recursos, como modelos ou estilos.
• Use 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 raiz ResourceDictionary .
• XAML é o formato comum para suporte ao design da interface do usuário de aplicativos e para troca do design da interface entre diferentes aplicativos de design. 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 WPF (Windows Presentation Foundation) 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 Windows Runtime se sobrepõe significativamente ao vocabulário XAML para interface do usuário também usado pelo Silverlight e, em menor medida, 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.
• 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 em code-behind. O XAML simplifica o fluxo de trabalho entre designers e desenvolvedores.
• Devido à riqueza do suporte do designer visual e da superfície de design para a linguagem XAML, o XAML dá suporte à criação 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 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 interativos de ambiente de design, como caixas de ferramentas e editores de propriedades, e o escopo e a finalidade do seu aplicativo do Windows Runtime. 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 é consumido por ferramentas, operações de compilação de marcação ou a fase de tempo de execução do aplicativo Windows Runtime.

Otimize seu XAML para desempenho ao carregar

Aqui estão algumas dicas para definir elementos de interface do usuário no XAML usando as práticas recomendadas para o desempenho. Muitas dessas dicas estão relacionadas ao uso de recursos XAML, mas estão listadas aqui na visão geral do XAML para conveniência. Para obter mais informações sobre recursos XAML, consulte referências de recursos ResourceDictionary e 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 frequentemente 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 da 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 usar um recurso, não defina-o em Application.Resources e, em vez disso, defina-o apenas para a página que precisa dele. Isso é bom tanto para fatoramento XAML ao projetar seu aplicativo quanto para desempenho durante a análise XAML.
• Para obter 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 use). Remova-os do XAML antes de lançar seu 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 está usando em mais de um aplicativo ou que forneça recursos comuns para todo o aplicativo, ainda é seu aplicativo que empacota os recursos XAML todas as vezes e potencialmente tem que carregá-los.
• Não defina os elementos de 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 para desempenho de carga).
• Use contêineres como Border ao invés de sobredesenhos deliberados de elementos da interface do usuário. Basicamente, não desenhe o mesmo pixel várias vezes. Para obter mais informações sobre a sobrecarga de desenho e como testá-la, consulte DebugSettings.IsOverdrawHeatMapEnabled.
• Use os modelos de itens padrão para ListView ou GridView; eles têm uma lógica especial do Apresentador 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 para 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 típico é que algum sistema ou seu aplicativo lançará uma exceção de análise XAML. Sempre que houver 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 frequentemente pode prover validação em tempo de design e verificação de erros de uma origem XAML enquanto 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á aguardar uma passagem de compilação XAML para ver se algo está errado com sua definição de interface do usuário.

Depois que o aplicativo for realmente executado, se algum erro de análise XAML não tiver sido detectado no momento do design, eles serão relatados 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ção para aplicativos do Windows Runtime em C# ou Visual Basic.

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