Что такое xaml

Особенности XAML

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

Маловероятно, что вам придется писать код XAML вручную. Вместо этого вы будете пользоваться инструментом, генерирующим необходимый код XAML. Если вы — дизайнер графики, скорее всего, таким инструментом будет программа графического дизайна вроде Expression Blend. Если же вы — разработчик, то наверняка начнете с Visual Studio. Поскольку оба инструмента поддерживают XAML, вы можете создать базовый пользовательский интерфейс в Visual Studio, а затем передать его команде дизайнеров, которые доведут его до совершенства, добавив специальную графику с помощью Expression Blend. Фактически такая способность интегрировать рабочий процесс разработчиков и дизайнеров — одна из ключевых причин создания Microsoft языка XAML.

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

Графический интерфейс пользователя до WPF

В традиционных технологиях отображения не существовало простого способа отделить графическое содержимое от кода. Ключевая проблема приложений Windows Forms состоит в том, что каждая форма, которую вы создаете, целиком определяется в коде C#. При помещении элементов управления на поверхность проектирования и их конфигурировании Visual Studio молча вносит изменения в код соответствующего класса формы. К сожалению, дизайнеры графики не располагают инструментами, которые могут работать с кодом C#.

Вместо этого художники вынуждены создавать и экспортировать свой продукт в растровом формате. Эти растровые изображения затем могут использоваться для оформления окон, кнопок и других элементов управления. Такой подход хорошо работает с простыми интерфейсами, которые мало изменяются с течением времени, но весьма ограничен в других сценариях. К его проблемам можно отнести перечисленные ниже:

• Каждый графический элемент (фон, кнопка и т.п.) должен экспортироваться как отдельное растровое изображение. Это ограничивает возможности их комбинирования и применения динамических эффектов, таких как сглаживание, прозрачность и тени.
• Значительная часть логики пользовательского интерфейса должна быть встроена в код разработчиком. Сюда относятся размеры кнопок, позиционирование, эффекты от перемещения курсора мыши и анимация. Дизайнер графики не может контролировать эти детали.
• Не существует внутренней связи между разными графическими элементами, так что легко создать не соответствующие друг другу наборы изображений. Отслеживание всех этих элементов привносит дополнительную сложность.
• Растровые изображения не могут изменяться в размерах без потери качества. По этой причине пользовательский интерфейс на основе растрового изображения зависит от разрешения. Это значит, что он не может быть адаптирован к большим мониторам и дисплеям высокого разрешения, что нарушает основы проектной философии WPF.

Если вам когда-либо доводилось проходить через процесс проектирования приложений Windows Forms с использованием специальной графики в командной среде, вы, несомненно, сталкивались с массой разочарований. Даже если интерфейс спроектирован с нуля дизайнером графики, он должен быть воссоздан в коде C#. Обычно дизайнеру графики просто приходится подготавливать макет, который затем нужно мучительно транслировать в работающее приложение.

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

Важно понимать, что WPF не требует обязательного применения XAML. Нет причин, по которым система Visual Studio не могла бы использовать подход Windows Forms и сразу создавать операторы кода, конструирующие окна WPF. Но в этом случае окно будет «заперто» в среде Visual Studio и доступно только программистам.

Другими словами, для WPF не требуется XAML. Однако XAML открывает возможности для кооперации, поскольку другие инструменты проектирования понимают формат XAML. Например, изобретательный дизайнер может использовать такой инструмент, как Expression Design, чтобы настроить графику для приложения WPF, или же инструмент вроде Expression Blend, чтобы построить для него изощренную анимацию.

XAML играет ту же роль для приложений Windows, что управляющие дескрипторы для вебприложений ASP.NET. Отличие состоит в том, что синтаксис дескрипторов ASP.NET задуман похожим на HTML, так что дизайнеры могут создавать веб-страницы, используя обычные приложения для веб-дизайна, такие как FrontPage и Dreamweaver. Как и в WPF, сам код веб-страницы ASP.NET обычно размещается в отдельном файле, облегчая проектирование.

Разновидности XAML

Существует несколько разных способов использования термина XAML. До сих пор он применялся для ссылки на весь язык XAML, предлагающий основанный на XML синтаксис для представления дерева объектов .NET. (Эти объекты могут быть кнопками и текстовыми полями в окне, а также специальным, определенным вами классом. Фактически XAML даже может использоваться на других платформах, чтобы представлять объекты, не имеющие отношения к .NET.)

Существует несколько подмножеств XAML:

WPF XAML

Включает элементы, описывающие содержимое WPF, такое как векторная графика, элементы управления и документы. В настоящее время это наиболее важное применение XAML.

XPS XAML

Часть WPF XAML, определяющая XML-представление форматированных электронных документов. Она опубликована как отдельный стандарт XML Paper Specification (XPS).

Silverlight XAML

Подмножество WPF XAML, предназначенное для Silverlight-приложений. Silverlight — это межплатформенный браузерный подключаемый модуль, который позволяет создавать расширенное веб-содержимое с двумерной графикой, анимацией, аудио и видео.

WF XAML

Включает элементы, описывающие содержимое Windows Workflow Foundation (WF).

Что такое XAML?

XAML (eXtensible Application Markup Language), что в переводе значит «Расширяемый Язык Разметки для Приложений», это вариант языка XML от Microsoft, описывающий GUI. В предыдущих итерациях фреймворков для GUI, например в WinForms, интерфейс пользователя создавался на том же языке, на котором Вы взаимодействовали с ним (например C#/VB.NET) и, обычно поддерживался средой разработки (например Visual Studio), но начиная с XAML Microsoft сменила вектор развития. Данный язык очень похож на HTML, и его помощью становится возможным легко разрабатывать и редактировать Ваш графический интерфейс.

Все это нельзя назвать полноценным руководством по языку разметки XAML, но я постараюсь кратко рассказать Вам, как им пользоваться, поскольку он является важной частью системы WPF. Независимо от того, что вы создаете: Окно или Страницу – они будут состоять из XAML документа и кода программной части (CodeBehind file), которые совместно создают Окно/Страницу. Файл XAML описывает интерфейс пользователя со всеми его элементами управления, тогда как CodeBehind обрабатывает все события и имеет доступ к управлению элементами XAML.

В следующих главах мы рассмотрим как работает XAML, и как его использовать для создания интерфейса пользователя.

This article has been fully translated into the following languages:

Is your preferred language not on the list? Click here to help us translate this article into your language!

XAML

XAML (eXtensible Application Markup Language) — язык разметки, используемый для инициализации объектов в технологиях на платформе .NET. Применительно к WPF (а также к Silverlight) данный язык используется прежде всего для создания пользовательского интерфейса декларативным путем. Хотя функциональность XAML только графическими интерфейсами не ограничивается: данный язык также используется в технологиях WCF и WF, где он никак не связан с графическим интерфейсом. То есть его область шире. Применительно к WPF мы будем говорить о нем чаще всего именно как о языке разметки, который позволяет создавать декларативным путем интерфейс, наподобие HTML в веб-программировании. Однако опять же повторюсь, сводить XAML к одному интерфейсу было бы неправильно, и далее на примерах мы это увидим.

XAML — не является обязательной частью приложения, мы вобще можем обходиться без него, создавая все элементы в файле связанного с ним кода на языке C#. Однако использование XAML все-таки несет некоторые преимущества:

• Возможность отделить графический интерфейс от логики приложения, благодаря чему над разными частями приложения могут относительно автономно работать разные специалисты: над интерфейсом — дизайнеры, над кодом логики — программисты.
• Компактность, понятность, код на XAML относительно легко поддерживать.

При компиляции приложения в Visual Studio код в xaml-файлах также компилируется в бинарное представление кода xaml, которое называется BAML (Binary Application Markup Language). И затем код baml встраивается в финальную сборку приложения — exe или dll-файл.

Структура и пространства имен XAML

При создании нового проекта WPF он уже содержит файлы с кодом xaml. Так, создаваемый по умолчанию в проекте файл MainWindow.xaml будет иметь следующую разметку:

Если вы совершенно не знакомы с xaml и с xml, то даже этот небольшой минимальный код окна может вызывать затруднения.

Подобно структуре веб-страничке на html, здесь есть некоторая иерархия элементов. Элементов верхнего уровня является Window , который представляет собой окно приложения. При создании других окон в приложении нам придется всегда начинать объявление интерфейса с элемента Window, поскольку это элемент самого верхнего уровня.

Кроме Window существует еще два элемента верхнего уровня:

Элемент Window имеет вложенный пустой элемент Grid , а также подобно html-элементам ряд атрибутов (Title, Width, Height) — они задают заголовок, ширину и высоту окна соответственно.

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

При создании кода на языке C#, чтобы нам были доступны определенные классы, мы подключаем пространства имен с помощью директивы using , например, using System.Windows; .

Чтобы задействовать элементы в XAML, мы также подключаем пространства имен. Вторая и третья строчки как раз и представляют собой пространства имен, подключаемые в проект по умолчанию. А атрибут xmlns представляет специальный атрибут для определения пространства имен в XML.

Так, пространство имен http://schemas.microsoft.com/winfx/2006/xaml/presentation содержит описание и определение большинства элементов управления. Так как является пространством имен по умолчанию, то объявляется без всяких префиксов.

http://schemas.microsoft.com/winfx/2006/xaml — это пространство имен, которое определяет некоторые свойства XAML, например свойство Name или Key. Используемый префикс x в определении xmlns:x означает, что те свойства элементов, которые заключены в этом пространстве имен, будут использоваться с префиксом x — x:Name или x:Key . Это же пространство имен используется уже в первой строчке x:Class=»XamlApp.MainWindow» — здесь создается новый класс MainWindow и соответствующий ему файл кода, куда будет прописываться логика для данного окна приложения.

Это два основных пространства имен. Рассмотрим остальные:

• xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″ : предоставляет поддержку атрибутов в режиме дизайнера. Это пространство имен преимущественно предназначено для другого инструмента по созданию дизайна на XAML — Microsoft Expression Blend
• xmlns:mc=»http://schemas.openxmlformats.org/markup-compatibility/2006″ : обеспечивает режим совместимости разметок XAML. В определении объекта Window двумя строчками ниже можно найти его применение:

mc:Ignorable="d"

Важно понимать, что эти пространства имен не эквивалентны тем пространствам имен, которые подключаются при помощи директивы using в c#. Так, например, http://schemas.microsoft.com/winfx/2006/xaml/presentation подключает в проект следующие пространства имен:

• System.Windows
• System.Windows.Automation
• System.Windows.Controls
• System.Windows.Controls.Primitives
• System.Windows.Data
• System.Windows.Documents
• System.Windows.Forms.Integration
• System.Windows.Ink
• System.Windows.Input
• System.Windows.Media
• System.Windows.Media.Animation
• System.Windows.Media.Effects
• System.Windows.Media.Imaging
• System.Windows.Media.Media3D
• System.Windows.Media.TextFormatting
• System.Windows.Navigation
• System.Windows.Shapes
• System.Windows.Shell

Элементы и их атрибуты

XAML предлагает очень простую и ясную схему определения различных элементов и их свойств. Каждый элемент, как и любой элемент XML, должен иметь открытый и закрытый тег, как в случае с элементом Window:

Либо элемент может иметь сокращенню форму с закрывающим слешем в конце, наподобие:

Но в отличие от элементов xml каждый элемент в XAML соответствует определенному классу C#. Например, элемент Button соответствует классу System.Windows.Controls.Button . А свойства этого класса соответствуют атрибутам элемента Button.

Например, добавим кнопку в создаваемую по умолчанию разметку окна:

Сначала идет элемент самого высшего уровня — Window, затем идет вложенный элемент Grid — контейнер для других элементов, и в нем уже определен элемент Button, представляющий кнопку.

Для кнопки мы можем определить свойства в виде атрибутов. Здесь определены атрибуты x:Name (имя кнопки), Width , Height и Content . Причем, атрибут x:Name берется в данном случае из пространства имен «http://schemas.microsoft.com/winfx/2006/xaml», которое сопоставляется с префиксом x . А остальные атрибуты не используют префиксы, поэтому берутся из основного пространства имен «http://schemas.microsoft.com/winfx/2006/xaml/presentation».

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

Определив разметку xaml, мы можем запустить проект, и нам отобразится графически весь код xaml — то есть наша кнопка:

Специальные символы

При определении интерфейса в XAML мы можем столкнуться с некоторыми ограничениями. В частости, мы не можем использовать специальные символы, такие как знак амперсанда & , кавычки » и угловые скобки < и >. Например, мы хотим, чтобы текст кнопки был следующим: . У кнопки есть свойство Content , которое задает содержимое кнопки. И можно предположить, что нам надо написать так:

Но такой вариант ошибочен и даже не скомпилирутся. В этом случае нам надо использовать специальные коды символов:

Символ	Код
	<
>	>
&	&
«	"

Еще одна проблема, с которой мы можем столкнуться в XAML — добавление пробелов. Возьмем, к примеру, следующее определение кнопки:

 Hello World 

Здесь свойство Content задается неявно в виде содержимого между тегами . . Но несмотря на то, что у нас несколько пробелов между словами «Hello» и «World», XAML по умолчанию будет убирать все эти пробелы. И чтобы сохранить пробелы, нам надо использовать атрибут xml:space=»preserve» :

 Hello World 

Обзор языка 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 в спецификации XML 1.0. Например, XAML поддерживает синтаксис элементов свойств, при котором значения свойств могут быть установлены в элементах, а не в качестве строковых значений в атрибутах или в качестве содержимого. Для обычного XML элемент свойства XAML — это элемент, в имени которого содержится точка, то есть он является допустимым, но имеет другое значение.

XAML и Visual Studio

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

Собственное пространство имен языка XAML

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

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

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

Сопоставление настраиваемых типов с пространствами имен XAML

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

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

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

Префикс задает токен для ссылки на это пространство имен XAML в оставшейся части разметки этого файла XAML. Префикс отделяется двоеточием (:) от элемента в пространстве имен XAML, на который он ссылается.

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

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

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

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

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

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

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

Реализация XAML в среде выполнения Windows использует следующие расширения разметки, которые определены в пространстве имен XAML по умолчанию и распознаются синтаксическим анализатором XAML среды выполнения Windows:

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

Среда выполнения Windows также поддерживает расширение разметки . Используйте его, чтобы установить значение null для значений Nullable в XAML. Например, вы можете использовать его в шаблоне элемента управления для CheckBox, который интерпретирует null как неопределенное состояние проверка (активирует визуальное состояние «Неопределенное»).

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

Например, ниже приведен синтаксис ссылки на повторно используемый StyleResourceDictionaryиз : «/> . Является Style ссылочным типом, а не простым значением, поэтому без использования вам потребуется элемент свойства и определение в нем, чтобы задать FrameworkElement.Style свойство.

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

Чтобы проиллюстрировать, следующий пример XAML задает значение FrameworkElement.Style свойства объекта Border с помощью синтаксиса атрибута. Свойство FrameworkElement.Style принимает экземпляр Windows.UI.Xaml.Style класса , ссылочный тип, который по умолчанию не может быть создан с помощью строки синтаксиса атрибута. Но в этом случае атрибут ссылается на определенное расширение разметки StaticResource. После обработки это расширение разметки возвращает ссылку на элемент Style, который был ранее определен как ресурс с ключом в словаре ресурсов.

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

Из-за расширений разметки требуется особый синтаксис для значения литерала »

События

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

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

Show updates 

Теперь компилятор ожидает, что метод 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< . 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-страницы задается указанием пространства имен и класса как атрибута 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 и пробелов . Атрибут encoding является допустимым в XAML. Поддерживаются только кодировки UTF-8 и UTF-16. Кодировка UTF-32 не поддерживается.

Учет регистра в XAML

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

Пространства имен 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. Будучи родственным языкам Windows Presentation Foundation (WPF) XAML и Microsoft Silverlight XAML, язык XAML для среды выполнения Windows использует тот же универсальный код ресурса (URI) для общего пространства имен XAML по умолчанию. Словарь XAML для среды выполнения Windows существенно пересекается со словарем XAML для пользовательского интерфейса, который также используется в Silverlight и — в несколько меньшей степени — в WPF. Таким образом, язык XAML — это эффективный способ переноса пользовательских интерфейсов, которые первоначально определялись для предшествующих технологий, также использовавших XAML.
• Код на XAML задает внешний вид пользовательского интерфейса, а связанный с ним файл программной части кода — логику работы. При этом вы можете корректировать макет пользовательского интерфейса, не внося изменений в программную часть. XAML упрощает взаимодействие между дизайнерами и разработчиками.
• Благодаря возможностям визуального конструктора и тому, что поверхность разработки поддерживает язык XAML, в XAML-коде можно быстро создавать прототип пользовательского интерфейса на ранних этапах разработки.

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

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

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

• Если вы часто используете одну и ту же цветную кисть в XAML, определите SolidColorBrush как ресурс, а не именованный цвет в качестве значения атрибута каждый раз.
• Если вы используете один и тот же ресурс на нескольких страницах пользовательского интерфейса, рекомендуется определить его в Resources , а не на каждой странице. И наоборот, если ресурс используется только на одной странице, не определяйте его в Application.Resources. Определите его только для страницы, на которой он нужен. Это оптимальный подход и для разделения XAML на составляющие в ходе разработки приложения, и для обеспечения производительности во время синтаксического анализа XAML.
• Среди ресурсов, которые упаковывает ваше приложение, поищите неиспользуемые ресурсы (имеющие ключ, но без ссылки StaticResource в приложении, которое использует эти ресурсы). Удалите их из кода XAML перед выпуском приложения.
• Если вы используете отдельные xaml-файлы, предоставляющие ресурсы разработки (MergedDictionaries), рассмотрите возможность комментирования или удаления неиспользуемых ресурсов из этих файлов. Даже если у вас есть код XAML, который вы используете как отправную точку в нескольких приложениях или который предоставляет общие ресурсы для всех ваших приложений, именно приложение каждый раз упаковывает ресурсы XAML и в некоторых случаях вынуждено загружать их.
• Не определяйте элементы пользовательского интерфейса, которые не нужны для композиции, и по возможности всегда используйте шаблоны элементов управления по умолчанию (эти шаблоны уже протестированы и проверены на предмет производительности загрузки).
• Используйте контейнеры, такие как , а Border не преднамеренные перерисовки элементов пользовательского интерфейса. В целом не следует рисовать один и тот же пиксель несколько раз. Дополнительные сведения о overdraw и о том, как протестировать его, см. в разделе 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.

Приложения, использующие C++/CX для кода, не получают определенное исключение XamlParseException. При этом в сообщении исключения поясняется, что источник ошибки связан с XAML, и указывается контекстная информация, например номера строк в XAML-файле, как и в исключении XamlParseException.

Дополнительные сведения об отладке приложения среда выполнения Windows см. в статье Запуск сеанса отладки.