Общие сведения об XAML

В этой статье представлены основные понятия языка XAML и XAML для аудитории разработчика приложения среды выполнения Windows, а также описываются различные способы объявления объектов и задания атрибутов в XAML, которые используются для создания приложения среды выполнения Windows.

Что такое XAML?

Расширяемый язык разметки приложений (XAML) является декларативным языком. В частности, XAML может инициализировать объекты и задать свойства объектов с помощью языковой структуры, которая показывает иерархические связи между несколькими объектами и соглашение о типе резервного типа, поддерживающее расширение типов. Вы можете создать видимые элементы пользовательского интерфейса в декларативной разметке XAML. Затем можно связать отдельный файл кода программной части для каждого XAML-файла, который может реагировать на события и управлять объектами, которые изначально объявляются в XAML.

Язык XAML поддерживает обмен источниками между различными инструментами и ролями в процессе разработки, например обмен источниками XAML между средствами разработки и интерактивной средой разработки (IDE) или между основными разработчиками и разработчиками локализации. Используя XAML в качестве формата обмена, роли конструктора и роли разработчика можно хранить отдельно или объединять, а конструкторы и разработчики могут выполнять итерацию во время производства приложения.

Когда вы видите их в рамках проектов приложений среды выполнения Windows, файлы XAML являются файлами XML с расширением .xaml.

Базовый синтаксис XAML

XAML имеет базовый синтаксис, который основан на XML. По определению, допустимый XAML также должен быть допустимым XML. Но XAML также имеет синтаксические понятия, которые приобретают другое и более полное значение, сохраняя корректность согласно спецификации XML 1.0. Например, XAML поддерживает синтаксис элемента свойства, где значения свойств могут быть заданы внутри элементов, а не как строковые значения атрибутов или содержимого. Для обычного XML элемент свойства XAML является элементом с точкой в его имени, поэтому он действителен для обычного XML, но не имеет того же значения.

XAML и Visual Studio

Microsoft Visual Studio помогает создавать допустимый синтаксис XAML как в текстовом редакторе XAML, так и в более графической области конструктора XAML. При написании XAML для приложения с помощью Visual Studio не волнуйтесь слишком много о синтаксисе с каждым нажатием клавиш. Интегрированная среда разработки поощряет допустимый синтаксис XAML, предоставляя подсказки автозаполнения, отображая предложения в списках и раскрывающихся списках Microsoft IntelliSense, отображая библиотеки элементов пользовательского интерфейса в окне панели элементов или другие методы. Если это первый опыт работы с XAML, возможно, по-прежнему полезно знать правила синтаксиса и особенно терминологию, которая иногда используется для описания ограничений или вариантов при описании синтаксиса XAML в справочнике или других разделах. Тонкие точки синтаксиса XAML рассматриваются в отдельном разделе, руководстве по синтаксису XAML.

Пространства имен XAML

В общем программировании пространство имен — это упорядоченное понятие, определяющее, как интерпретируются идентификаторы для сущностей программирования. С помощью пространств имен программная среда может отделять объявленные пользователем идентификаторы от объявленных средой идентификаторов, однозначно идентифицировать идентификаторы с помощью квалификаций пространства имен, применять правила для определения области видимости имен и т. д. XAML имеет собственную концепцию пространства имен XAML, которая служит этой целью для языка XAML. Вот как XAML применяет и расширяет основные понятия пространства имен языка XML:

XAML использует зарезервированный XML-атрибут xmlns для объявлений пространства имен. Значение атрибута обычно является универсальным идентификатором ресурса (URI), который является соглашением, унаследованным от XML.
XAML использует префиксы в объявлениях для указания пространств имен, не являющихся пространствами имен по умолчанию, а обращения к префиксам в элементах и атрибутах ссылаются на это пространство имен.
XAML имеет концепцию пространства имен по умолчанию, которое является пространством имен, используемым, если префикс не существует в использовании или объявлении. Пространство имен по умолчанию можно определить по-разному для каждой платформы программирования XAML.
Определения пространства имен наследуются в XAML-файле или конструкции от родительского элемента к дочернему элементу. Например, если определить пространство имен в корневом элементе XAML-файла, все элементы в этом файле наследуют это определение пространства имен. Если элемент дальше по странице переопределяет пространство имен, потомки этого элемента наследуют новое определение.
Атрибуты элемента наследуют пространства имен элемента. Встречать префиксы в атрибутах XAML довольно необычно.

XAML-файл почти всегда объявляет пространство имен XAML по умолчанию в корневом элементе. Пространство имен XAML по умолчанию определяет, какие элементы можно объявить без их определения префиксом. Для типичных проектов приложений среды выполнения Windows это пространство имен по умолчанию содержит все встроенные словари XAML для среды выполнения Windows, используемого для определений пользовательского интерфейса: элементы управления по умолчанию, текстовые элементы, графические и анимации XAML, типы поддержки привязки данных и стилизации и т. д. Большая часть XAML, которую вы напишете для приложений среды выполнения Windows, таким образом, сможет избежать использования пространств имен XAML и префиксов при обращении к общим элементам пользовательского интерфейса.

Ниже приведен фрагмент кода, показывающий корень Page начальной страницы приложения, созданной с помощью шаблона (отображается только открывающий тег и в упрощенном виде). Он объявляет пространство имен по умолчанию, а также пространство имен x (которое мы объясним далее).

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

Пространство имен XAML, используемое в языке XAML

Одно из определенных пространств имен XAML, объявленное почти во всех XAML-файлах среды выполнения Windows, — это пространство имен языка XAML. Это пространство имен включает элементы и понятия, определенные спецификацией языка XAML. По соглашению пространство имен языка XAML связывается с префиксом "x". Шаблоны проектов и файлов по умолчанию для проектов приложений среды выполнения Windows всегда определяют пространство имен XAML по умолчанию (без префикса, просто xmlns=) и пространство имен XAML языка XAML (префикс x) как часть корневого элемента.

Пространство имен XAML с префиксом x или языком XAML содержит несколько конструкций программирования, которые часто используются в XAML. Ниже приведены наиболее распространенные из них:

Срок	Description
x:Key	Задает уникальный определяемый пользователем ключ для каждого ресурса в XAML ResourceDictionary. Строка маркера ключа является аргументом расширения разметки StaticResource, и этот ключ будет использоваться позже для извлечения ресурса XAML из другого использования в XAML вашего приложения.
x:Class	Указывает пространство имен кода и имя класса кода для класса, который предоставляет код для страницы XAML. Это имя класса, созданного или присоединенного к действиям сборки при сборке приложения. Эти действия сборки поддерживают компилятор разметки XAML и объединяют разметку и код программной части при компиляции приложения. Для поддержки кода на странице XAML необходимо использовать такой класс. Window.Content в модели активации среды выполнения Windows по умолчанию.
x:Name	Указывает имя объекта в режиме выполнения для экземпляра, существующего в коде времени выполнения после обработки элемента объекта, определенного в XAML-коде. Вы можете подумать о настройке x:Name в XAML так же, как объявление именованной переменной в коде. Как вы узнаете позже, это именно то, что происходит при загрузке XAML в качестве компонента приложения среды выполнения Windows. ПримечаниеИмя является аналогичным свойством в платформе, но не все элементы поддерживают его. Используйте x:Name для идентификации элементов всякий раз, когда FrameworkElement.Name не поддерживается в этом типе элемента.
x:Uid	Определяет элементы, которые должны использовать локализованные ресурсы для некоторых их значений свойств. Дополнительные сведения об использовании x:Uid см. в кратком руководстве по переводу ресурсов пользовательского интерфейса.
Встроенные типы данных XAML	Эти типы могут указывать значения для простых типов значений, если это необходимо для атрибута или ресурса. Эти встроенные типы соответствуют простым типам значений, которые обычно определяются как часть встроенных определений каждого языка программирования. Например, вам может понадобиться объект, представляющий истинное логическое значение для использования в визуальном состоянии, созданном с использованием ObjectAnimationUsingKeyFrames. Для этого значения в XAML вы будете использовать встроенный тип x:Boolean в качестве элемента объекта, как показано ниже: `<x:Boolean>True</x:Boolean>`

Другие конструкции программирования в пространстве имен XAML языка XAML существуют, но не являются общими.

Сопоставление пользовательских типов с пространствами имен XAML

Одним из самых мощных аспектов XAML в качестве языка является то, что легко расширить словарь XAML для приложений среды выполнения Windows. Вы можете определить собственные пользовательские типы на языке программирования приложения, а затем ссылаться на пользовательские типы в разметке XAML. Поддержка расширения с помощью пользовательских типов в основном встроенна в то, как работает язык XAML. Разработчики платформ или приложений отвечают за создание резервных объектов, на которые ссылается XAML. Ни платформы, ни разработчик приложения не привязаны к спецификациям того, что объекты в их словарях представляют или делают вне основных правил синтаксиса XAML. (Существуют некоторые ожидания относительно того, как типы XAML из пространства имен XAML должны себя вести, но среда выполнения Windows предоставляет всю необходимую поддержку.)

Если вы используете XAML для типов, поступающих из библиотек, отличных от основных библиотек и метаданных среды выполнения Windows, необходимо объявить и сопоставить пространство имен XAML с префиксом. Используйте этот префикс в использовании элементов, чтобы ссылаться на типы, определенные в библиотеке. Сопоставления префиксов объявляются с использованием атрибутов xmlns, обычно в корневом элементе вместе с другими определениями пространства имен XAML.

Чтобы создать собственное определение пространства имен, ссылающееся на пользовательские типы, сначала укажите ключевое слово xmlns:, а затем нужный префикс. Значение этого атрибута должно содержать ключевое слово с помощью: в качестве первой части значения. Оставшаяся часть значения — это строковый маркер, ссылающийся по имени на конкретное поддерживающее код пространство имен, которое содержит ваши пользовательские типы.

Префикс определяет маркер разметки, используемый для ссылки на это пространство имен XAML в оставшейся части разметки в этом XAML-файле. Символ двоеточия (:) стоит между префиксом и сущностью, на которую ссылаются в пространстве имен XAML.

Например, синтаксис атрибута для сопоставления префикса myTypes с пространством myCompany.myTypes имен: xmlns:myTypes="using:myCompany.myTypes"и использование репрезентативного элемента: <myTypes:CustomButton/>

Дополнительные сведения о сопоставлении пространств имен XAML для пользовательских типов, включая особые рекомендации по расширению компонентов Visual C++ (C++/CX), см. в статьях о пространствах имен XAML и сопоставлении пространств имен.

Другие пространства имен XAML

Часто можно увидеть XAML-файлы, которые определяют префиксы "d" (для пространства имен конструктора) и "mc" (для совместимости разметки). Как правило, они предназначены для поддержки инфраструктуры или для обеспечения сценариев в средстве разработки. Дополнительные сведения см. в разделе "Другие пространства имен XAML".

Расширения разметки

Расширения разметки — это концепция языка XAML, которая часто используется в реализации XAML среды выполнения Windows. Расширения разметки часто представляют собой какое-то сокращение, что позволяет файлу XAML получить доступ к значению или поведению, которое не заключается просто в объявлении элементов на основе резервных типов. Некоторые расширения разметки могут задавать свойства с обычными строками или с дополнительными вложенными элементами, с целью упрощения синтаксиса или факторинга между различными файлами XAML.

В синтаксисе атрибута XAML фигурные скобки "{" и "}" указывают использование расширения разметки XAML. Это использование направляет обработку XAML для исключения общей обработки значений атрибутов как литеральной строки или непосредственно преобразуемого строкового значения. Вместо этого средство синтаксического анализа XAML вызывает код, обеспечивающий поведение для этого конкретного расширения разметки, и этот код предоставляет альтернативный объект или результат поведения, необходимый средству синтаксического анализа XAML. Расширения разметки могут иметь аргументы, которые соответствуют имени расширения разметки и также содержатся в фигурных скобках. Как правило, вычисляемое расширение разметки предоставляет возвращаемое значение объекта. Во время синтаксического анализа возвращаемое значение вставляется в ту позицию в дереве объектов, где в исходном XAML использовалось расширение разметки.

Среда выполнения Windows XAML поддерживает эти расширения разметки, которые определены в пространстве имен XAML по умолчанию и понимаются анализатором XAML среды выполнения Windows.

{x:Bind}: поддерживает привязку данных, которая откладывает оценку свойств до выполнения путем выполнения кода специального назначения, который он создает во время компиляции. Это расширение разметки поддерживает широкий спектр аргументов.
{Binding}: поддерживает привязку данных, которая откладывает оценку свойств до выполнения, выполняя проверку объекта среды выполнения общего назначения. Это расширение разметки поддерживает широкий спектр аргументов.
{StaticResource}: поддерживает ссылки на значения ресурсов, определенные в ResourceDictionary. Эти ресурсы могут находиться в другом XAML-файле, но в конечном итоге должны быть доступны анализатору XAML во время загрузки. Аргумент {StaticResource} использования определяет ключ (имя) для ресурса с ключом в ResourceDictionary.
{ThemeResource}: аналогично {StaticResource} , но может реагировать на изменения темы во время выполнения. {ThemeResource} часто используется в стандартных шаблонах XAML среды выполнения Windows, поскольку большинство из них разработаны для обеспечения совместимости, когда пользователь переключает тему во время работы приложения.
{TemplateBinding}: особый случай {Binding} , поддерживающий шаблоны элементов управления в XAML и их последующее использование во время выполнения.
{RelativeSource}: включает определенную форму привязки шаблона, в которой значения приходят из шаблона родительского элемента.
{CustomResource}: для расширенных сценариев поиска ресурсов.

Среда выполнения Windows также поддерживает расширение разметки {x:NULL}. Этот параметр используется для задания Nullable значений в значение null в XAML. Например, это можно использовать в шаблоне элемента управления для CheckBox, который интерпретирует null как неопределенное состояние проверки (активируя визуальное состояние indeterminate).

Расширение разметки обычно возвращает существующий экземпляр из другой части графа объектов для приложения или откладывает значение во время выполнения. Потому что расширение разметки можно использовать в качестве значения атрибута, и это является типичным использованием, расширения разметки часто предоставляют значения для свойств ссылочного типа, которые иначе могли бы потребовать синтаксис элемента свойства.

Например, вот синтаксис для ссылки на многократно используемый стиль из ResourceDictionary: <Button Style="{StaticResource SearchButtonStyle}"/> Стиль — это ссылочный тип, а не простое значение, поэтому без использования {StaticResource}, вам потребовалось бы задать <Button.Style> элемент свойства и определение <Style> в нем, чтобы установить свойство FrameworkElement.Style.

С помощью расширений разметки каждое свойство, которое задано в XAML, потенциально настраивается в синтаксисе атрибутов. Синтаксис атрибута можно использовать для предоставления ссылочных значений для свойства, даже если он не поддерживает синтаксис атрибута для прямого создания экземпляра объектов. Или можно включить конкретное поведение, которое откладывает общее требование, чтобы свойства XAML заполнялись либо типами значений, либо новыми экземплярами ссылочных типов.

Для иллюстрации следующий пример XAML задает значение свойства FrameworkElement.Style границы с помощью синтаксиса атрибута. Свойство FrameworkElement.Style принимает экземпляр класса Style , ссылочный тип, который по умолчанию не удалось создать с помощью строки синтаксиса атрибута. Но в этом случае атрибут ссылается на определенное расширение разметки StaticResource. При обработке расширения разметки возвращается ссылка на элемент Style, который ранее был определен как ресурс с ключом в словаре ресурсов.

<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>

Расширения разметки можно вложить. Сначала вычисляется самое внутреннее расширение разметки.

Из-за расширений разметки требуется специальный синтаксис для значения литерала "{" в атрибуте. Дополнительные сведения см. в руководстве по синтаксису XAML.

Events

XAML — это декларативный язык для объектов и их свойств, но он также включает синтаксис для присоединения обработчиков событий к объектам в разметке. Затем синтаксис событий XAML может интегрировать объявленные в XAML события с помощью модели программирования среды выполнения Windows. Вы указываете имя события в качестве имени атрибута объекта, в котором обрабатывается событие. Для значения атрибута укажите имя функции обработчика событий, определяемой в коде. Процессор XAML использует это имя для создания делегата в загруженном дереве объектов и добавляет указанный обработчик во внутренний список обработчиков. Почти все приложения среды выполнения Windows определяются как источниками разметки, так и кодом.

Вот простой пример. Класс Button поддерживает событие с именем Click. Вы можете написать обработчик для Click , который запускает код, который должен вызываться после нажатия пользователем кнопки. В XAML вы указываете Click в качестве атрибута на Button. Для значения атрибута укажите строку, которая является именем метода обработчика.

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

При компиляции компилятор теперь ожидает, что в файле программной части будет определен метод с именем showUpdatesButton_Click, в пространстве имен, объявленном в значении x:Class страницы XAML. Кроме того, этот метод должен соответствовать контракту делегата для события Click . Рассмотрим пример.

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);
    };
}

В проекте XAML записывается в формате .xaml файла, и для написания программной части используется предпочитаемый вами язык (C#, Visual Basic, C++/CX). Если XAML-файл компилируется в рамках действия сборки для проекта, расположение файла кода XAML для каждой страницы XAML определяется путем указания пространства имен и класса в качестве атрибута x:Class корневого элемента страницы XAML. Дополнительные сведения о том, как эти механизмы работают в XAML и как они связаны с моделями программирования и приложений, см. в разделе "События" и обзор перенаправленных событий.

Замечание

Для C++/CX есть два файла программной части: один — заголовок (XAML.h), а другой — реализация (.xaml.cpp). Реализация ссылается на заголовок, и с технической точки зрения именно заголовок представляет точку входа для связи с кодом-позади.

Словари ресурсов

Создание ResourceDictionary — это общая задача, которая обычно выполняется путем создания словаря ресурсов в качестве области страницы XAML или отдельного XAML-файла. Словари ресурсов и их использование — это более крупная концептуальная область, которая находится за пределами этой темы. Дополнительные сведения см. в справочниках по ресурсам ResourceDictionary и XAML.

XAML и XML

Язык XAML основан на xml-языке. Но XAML значительно расширяет XML. В частности, он рассматривает концепцию схемы совершенно по-разному из-за связи с концепцией основного типа, и добавляет языковые элементы, такие как присоединенные элементы и расширения разметки. xml:lang является допустимым в XAML, но влияет на среду выполнения, а не синтаксический анализ, и обычно псевдоним является свойством уровня платформы. Дополнительные сведения см. в разделе FrameworkElement.Language. xml:base допустим в разметке, но парсеры игнорируют его. xml:space является допустимым, но относится только к сценариям, описанным в разделе XAML и пробелы. Атрибут кодирования действителен в XAML. Поддерживаются только кодировки UTF-8 и UTF-16. Кодировка UTF-32 не поддерживается.

Конфиденциальность регистра в XAML

XAML учитывает регистр. Это еще одно следствие того, что XAML основан на XML, который чувствителен к регистру. Имена элементов и атрибутов XAML чувствительны к регистру. Значение атрибута потенциально чувствительно к регистру, в зависимости от того, как обрабатывается значение атрибута для определенных свойств. Например, если значение атрибута объявляет имя элемента перечисления, встроенное поведение, которое преобразует строку имени члена для возврата значения элемента перечисления, не учитывает регистр. Напротив, значение свойства Name и служебные методы для работы с объектами на основе имени, указанного в свойстве Name, обрабатывают строку имени с учетом регистра.

Области имен XAML

Язык XAML определяет концепцию области имен XAML. Концепция области имен XAML влияет на то, как процессоры XAML должны обрабатывать значение x:Name или Name , примененное к элементам XAML, в частности области, в которых следует полагаться на уникальные идентификаторы. Области имен XAML подробно рассматриваются в отдельном разделе; см. области имен XAML.

Роль XAML в процессе разработки

XAML играет несколько важных ролей в процессе разработки приложений.

XAML — это основной формат для объявления пользовательского интерфейса и элементов приложения в этом пользовательском интерфейсе, если вы программируетсяе с помощью C#, Visual Basic или C++/CX. Как правило, один XAML-файл в проекте представляет метафору страницы в приложении для первоначально отображаемого пользовательского интерфейса. Дополнительные файлы XAML могут объявлять дополнительные страницы для пользовательского интерфейса навигации. Другие файлы XAML могут объявлять ресурсы, такие как шаблоны или стили.
Формат XAML используется для объявления стилей и шаблонов, применяемых к элементам управления и пользовательскому интерфейсу для приложения.
Вы можете использовать стили и шаблоны либо для создания шаблонов существующих элементов управления, либо если вы определяете элемент управления, предоставляющий шаблон по умолчанию в составе пакета элементов управления. При использовании его для определения стилей и шаблонов соответствующий XAML часто объявляется как дискретный XAML-файл с корнем ResourceDictionary .
XAML — это общий формат для поддержки конструктора создания пользовательского интерфейса приложения и обмена дизайном пользовательского интерфейса между различными приложениями конструктора. В частности, XAML для приложения можно обменять различными инструментами разработки XAML (или окнами разработки в средствах).
Несколько других технологий также определяют базовый пользовательский интерфейс в XAML. В отношении XAML для Windows Presentation Foundation (WPF) и Microsoft Silverlight XAML среда выполнения Windows использует тот же URI для общего пространства имен XAML по умолчанию. Словарь XAML для Windows Runtime значительно перекрывается со словарем XAML-for-UI, который также используется Silverlight и в меньшей степени WPF. Таким образом, XAML способствует эффективному пути миграции пользовательского интерфейса, первоначально определенного для технологий предшественников, которые также использовали XAML.
XAML определяет внешний вид пользовательского интерфейса, а связанный файл кода определяет логику. Вы можете настроить дизайн пользовательского интерфейса без внесения изменений в логику в коде программной части. XAML упрощает рабочий процесс между конструкторами и разработчиками.
Благодаря богатости визуального конструктора и поддержки поверхности конструктора для языка XAML XAML поддерживает быстрое создание прототипов пользовательского интерфейса на ранних этапах разработки.

В зависимости от собственной роли в процессе разработки вы можете не взаимодействовать с XAML. Степень взаимодействия с XAML-файлами также зависит от используемой среды разработки, а также от использования интерактивных функций среды разработки, таких как панели элементов и редакторы свойств, а также область и назначение приложения среды выполнения Windows. Тем не менее, скорее всего, во время разработки приложения вы будете редактировать XAML-файл на уровне элемента с помощью текстового или XML-редактора. Используя эту информацию, вы можете уверенно редактировать XAML в текстовом или XML представлении и обеспечивать правильность объявлений и соответствие цели этого файла XAML при использовании средств, операций компиляции разметки или на этапе выполнения вашего приложения Windows Runtime.

Оптимизируйте XAML для повышения производительности загрузки

Ниже приведены некоторые советы по определению элементов пользовательского интерфейса в XAML с помощью рекомендаций по повышению производительности. Многие из этих советов относятся к использованию ресурсов XAML, но перечислены здесь в общем обзоре XAML для удобства. Дополнительные сведения о ресурсах XAML см. в справочниках по ресурсам ResourceDictionary и XAML. Дополнительные советы по производительности, включая XAML, которые специально демонстрируют некоторые из плохих методик производительности, которые следует избежать в XAML, см. в статье "Оптимизация разметки XAML".

Если вы часто используете ту же кисть цвета в XAML, определите SolidColorBrush в качестве ресурса, а не используя именованный цвет в качестве значения атрибута каждый раз.
Если вы используете один ресурс на нескольких страницах пользовательского интерфейса, рекомендуется определить его в Application.Resources , а не на каждой странице. И наоборот, если только одна страница использует ресурс, не определите его в Application.Resources и вместо этого определите его только для страницы, которая нуждается в ней. Это хорошо подходит как для факторинга XAML при проектировании приложения, так и для производительности во время синтаксического анализа XAML.
Для ресурсов, которые упакованы в ваше приложение, проверьте наличие неиспользуемых ресурсов (ресурс с ключом, но в приложении нет ссылки StaticResource, использующего его). Удалите их из XAML перед выпуском приложения.
Если вы используете отдельные ФАЙЛЫ XAML, предоставляющие ресурсы проектирования (MergedDictionaries), рассмотрите возможность комментирования или удаления неиспользуемых ресурсов из этих файлов. Даже если у вас есть общая отправная точка XAML, которую вы используете в нескольких приложениях или которая предоставляет общие ресурсы для всех ваших приложений, это всё равно ваше приложение, которое каждый раз упаковывает ресурсы XAML и, возможно, должно загружать их.
Не определяйте элементы пользовательского интерфейса, которые не нужны для композиции, и используйте шаблоны элементов управления по умолчанию, когда это возможно (эти шаблоны уже проверены и проверены для производительности загрузки).
Используйте контейнеры, такие как Border , а не преднамеренные перезаписи элементов пользовательского интерфейса. В основном не рисуйте один и тот же пиксель несколько раз. Дополнительные сведения об овердроу и о том, как протестировать его, см. DebugSettings.IsOverdrawHeatMapEnabled.
Используйте шаблоны элементов по умолчанию для ListView или GridView; они имеют специальную логику докладчика , которая решает проблемы с производительностью при создании визуального дерева для большого количества элементов списка.

Отладка XAML

Так как XAML является языком разметки, некоторые из типичных стратегий отладки в Microsoft Visual Studio недоступны. Например, невозможно задать точку останова в XAML-файле. Однако существуют другие методы, которые помогут вам отлаживать проблемы с определениями пользовательского интерфейса или другой разметкой XAML во время разработки приложения.

При возникновении проблем с XAML-файлом обычно системы или приложение вызывают исключение синтаксического анализа XAML. Всякий раз, когда существует исключение синтаксического анализа XAML, код XAML, загруженный средством синтаксического анализа XAML, не удалось создать допустимое дерево объектов. В некоторых случаях, например, когда XAML представляет первую "страницу" приложения, загруженного в качестве корневого визуального элемента, исключение синтаксического анализа XAML невозможно восстановить.

XAML часто редактируется в интегрированной среде разработки, например Visual Studio и одной из ее поверхностей конструктора XAML. Visual Studio часто может предоставлять проверку во время разработки и проверку ошибок источника XAML при его редактировании. Например, он может отображать волнистые линии в текстовом редакторе XAML, как только вы вводите неверное значение атрибута, и вам даже не придется ждать этапа компиляции XAML, чтобы увидеть, что что-то не так с определением интерфейса пользователя.

После того как приложение фактически запускается, если ошибки синтаксического анализа XAML не были замечены во время разработки, они сообщаются средой CLR как XamlParseException. Дополнительные сведения о том, что вы можете сделать при возникновении XamlParseException, см. в статье об обработке исключений для приложений среды выполнения Windows в C# или Visual Basic.