Основы XAML

XAML в Universal Windows Platform

При разработке приложений UWP с помощью языка C# основной технологией для построения графического интерфейса является XAML (eXtensible Application Markup Language). XAML представляет язык разметки на основе XML, который используется для декларативного описания графического интерфейса.

XAML позволяет отделить определение интерфейса или внешнего вида приложения от его логики, которая пишется на C#. Кроме того, декларативное описание интерфейса делает код более компактным и понятным.

Если мы возьмем стандартный проект UWP по типу Blank Application , то как раз увидим файлы, которые используют XAML. Например, в проекте мы можем найти файл MainPage.xaml , который представляет декларативное описание графического интерфейса для единственной страницы в приложении:

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

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

При написании программы на C# мы можем подключать классы из внешних пространств имен с помощью директивы using, например, using System.Windows . В XAML также есть свои пространства имен, только они добавляются в документ с помощью атрибута xmlns . В частности, если мы посмотрим на содержание элемента Page, то мы как раз можем заметить подключенные пространства имен:

Рассмотрим все эти пространства.

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

Далее подключается пространство имен «http://schemas.microsoft.com/winfx/2006/xaml» . Оно определяет ряд атрибутов xaml таких, как Name или Key. Причем оно объявляется с помощью атрибута xmlns:x — префикс x после двоеточия означает, что те свойства элементов, которые содержатся в этом пространстве имен, будут использоваться с префиксом x. Например, x:Name или x:Key.

Так, на второй строке идет следующее выражение: x:Class=»XamlApp.MainPage» . Атрибут Class указывает на класс C#, который будет соответствовать данному элементу Page. И так как этот атрибут используется с префиксом x, то соответственно определение атрибута Class будет извлекаться из пространства имен xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»

Третье подключаемое пространство имен xmlns:local=»using:XamlApp» представляет текущее пространств имен проекта, который в моем случае называется XamlApp. То есть, все определенные в проекте классы, можно будет использовать в XAML с префиксом local.

Два последних пространства имен xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″ и xmlns:mc=»http://schemas.openxmlformats.org/markup-compatibility/2006″ используются преимущественно для визуализации дизайна страницы в окне дизайнера сверху. При запуске приложения они никак не используются и игнорируются, поэтому на следующей строке можно увидеть атрибут mc:Ignorable=»d» . Он указывает, что надо игнорировать пространство имен с префиксом d.

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

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

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

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

Например, добавим на страницу кнопку:

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

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

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

Xaml system windows input

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 двумя строчками ниже можно найти его применение:

Это выражение позволяет игнорировать парсерам XAML во время выполнения приложения дизайнерские атрибуты из пространства имен с префиксом d , то есть из «http://schemas.microsoft.com/expression/blend/2008»

xmlns:local=»clr-namespace:XamlApp» : пространство имен текущего проекта. Так как в моем случае проект называется XamlApp, то простраство имен называется аналогично. И через префикс local я смогу получить в XAML различные объекты, которые я определил в проекте.

Xaml Reader Class

Definition

Reads XAML input and creates an object graph, using the WPF default XAML reader and an associated XAML object writer.

Examples

The following example converts a Button into a string using the XamlWriter class. The string is then loaded back into a Button using the static Load method on the XamlReader class.

Remarks

The synchronous Load methods are static, but the asynchronous LoadAsync methods are not static and require an instance of the XamlReader class to use.

The output of the Load methods is a single object, which represents the root object of a created object tree or object graph. Object graphs that are created by XamlReader are typically added to the existing object tree of a WPF application at run time. Otherwise the new object graph is considered disconnected for purposes of the WPF application model. This means that it does not render, and cannot be accessed using any of the object tree techniques as applied to the WPF application’s main object tree (for example, the APIs FindName, LogicalTreeHelper, VisualTreeHelper). For more information on object tree concepts, see Trees in WPF.

XamlReader supports the following primary scenarios:

Cloning/object factory: Without additional mechanisms, a reference type generally cannot be included in more than one position in a WPF object tree. (Examples of additional mechanisms that offer support for sharing or re-use in WPF include objects that are based on Freezable, or support for commonly shareable objects such as Brush that are referenced as an item from a ResourceDictionary.) One way to clone an object that is already in the object tree is to serialize the object using XamlWriter.Save. You then use the serialized string as input for a call to Load, with a stream or XmlReader as an intermediary.

Constructing objects based on just-in-time information: There are often other ways to have late-binding or user-supplied input change the state of existing objects. For example you could use the same value to set more than one property, or use data binding. But if you have a scenario where even the type of object to create is only determinable at run time or with user interaction, then creating such an object by building up a string for Load input is often a useful technique.

Using existing resource techniques: The Stream type is used frequently in other frameworks or technologies for transferring data or objects across application boundaries or for similar situations. You can then use the Stream techniques to store or obtain XAML-formatted data that you eventually use to create an object as part of your application.

Fixed documents: Your application might load local or downloaded XPS documents for inclusion in a WPF application object tree and UI.

This documentation sometimes describes an object graph, as opposed to an object tree. A strict parent-child relationship does not always exist in the run time object relationships of a run time WPF application, so an object graph is a more widely applicable terminology. However, because WPF also includes two different tree conceptualization APIs (LogicalTreeHelper, VisualTreeHelper) the tree metaphor still applies adequately to most real-world cases in WPF. From the XAML language perspective however, the object graph is often the best way to think about how objects are created out of XAML, because the XAML language itself does not necessarily specify helper class methodologies that bring the relationships more into a tree structure again.

Code Access Security, Loose XAML, and XamlReader

XAML is a markup language that directly represents object instantiation and execution. Therefore, elements created in XAML have the same ability to interact with system resources (network access, file system IO, for example) as the equivalent generated code does.

WPF supports the .NET security framework Code Access Security (CAS). This means that WPF content running in the internet zone has reduced execution permissions. «Loose XAML» (pages of noncompiled XAML interpreted at load time by a XAML viewer) and XAML browser application (XBAP) are usually run in this internet zone and use the same permission set. However, XAML loaded in to a fully trusted application has the same access to the system resources as the hosting application does. For more information, see WPF Partial Trust Security.

The implications of these statements for XamlReader is that your application design must make trust decisions about the XAML you decide to load. If you are loading XAML that is not trusted, consider implementing your own sandboxing technique for how you load the resulting object graph.

XamlReader can also be called by partial trust code. In this case, Internet security zone is applied for code access security. If anything in the loaded XAML is invalid under Internet security zone, a XAML parse exception is thrown. Under XBAP and other cases that are partial trust at the platform level, where XamlReader is part of the execution, you get the same exception behavior as with explicit partial trust calls.

WPF XAML, XAML Readers/Writers, and XAML Language Versioning

XAML2009 includes language features such as x:Reference and x:FactoryMethod. You can use signatures of Load or Parse to load XAML that uses these features. However, those language features are not supported for XAML that needs to be markup compiled (such as XAML for the Page build action in a WPF application, or any XAML that involves the markup compile task in the build actions).

WPF types and the WPF technology in general support concepts that rely on access to WPF internals. For instance, how WPF implements dependency properties relies on internal techniques for efficient type-member lookup. Access to these internals is enabled by the XAML reading and writing APIs provided in XamlWriter and XamlReader from the System.Windows.Markup namespace and PresentationFramework assembly. However, the lower-level XAML readers and XAML writers from the System.Xaml assembly (classes based on System.Xaml.XamlReader, System.Xaml.XamlWriter) do not have access to the WPF internals. There is no dependency from System.Xaml to any WPF-specific assembly. Without access to the WPF internals, System.Xaml readers and writers cannot correctly load or save all WPF types, or types based on WPF types. In particular, the System.Xaml readers and writers do not understand concepts such as the WPF dependency property backing property store, or all the specifics of how WPF uses styles, resource dictionaries and templates. Therefore you have a choice to make:

If you are loading WPF types, and/or you are using XAML in BAML form in any way, use the PresentationFramework XAML readers and XAML writers.

If you are not relying on any WPF types or the BAML form of XAML, and are not using another specific technology’s XAML reader or XAML writer implementation for reasons that are specific to that framework, use the System.Xaml XAML readers and XAML writers.

System.Xaml Backing Implementation in .NET 4

XamlReader is the callable API surface for the WPF framework-level XAML parser. The same underlying XAML parser also performs the run-time XAML loading and parsing for WPF applications that target .NET Framework 3.0 and .NET Framework 3.5.

If you are targeting .NET Framework 4, the external API is the same, but parts of the implementation are built on the .NET Framework 4 general XAML implementation in the System.Xaml assembly, which improves many of the technical and reporting aspects of parsing XAML. Targeting .NET Framework 4 necessarily entails including System.Xaml as a reference, and details of implementation such as the exceptions reported may come from System.Xaml defined types.

Constructors

Initializes a new instance of the XamlReader class.

Methods

Aborts the current asynchronous load operation, if there is an asynchronous load operation pending.

Determines whether the specified object is equal to the current object.

(Inherited from Object) GetHashCode()

Serves as the default hash function.

(Inherited from Object) GetType()

Gets the Type of the current instance.

(Inherited from Object) GetWpfSchemaContext()

Returns a XamlSchemaContext object that represents the WPF schema context settings for a XamlReader.

Reads the XAML input in the specified Stream and returns an Object that is the root of the corresponding object tree.

Reads the XAML input in the specified Stream and returns an object that is the root of the corresponding object tree.

Reads the XAML input through a provided XamlReader and returns an object that is the root of the corresponding object tree.

Reads the XAML input in the specified XmlReader and returns an object that is the root of the corresponding object tree.

Reads the XAML input in the specified Stream and returns the root of the corresponding object tree.

Reads the XAML input in the specified Stream and returns the root of the corresponding object tree.

Reads the XAML input in the specified XmlReader and returns the root of the corresponding object tree.

Creates a shallow copy of the current Object.

(Inherited from Object) Parse(String)

Reads the XAML input in the specified text string and returns an object that corresponds to the root of the specified markup.

Reads the XAML markup in the specified text string (using a specified ParserContext) and returns an object that corresponds to the root of the specified markup.

Returns a string that represents the current object.

(Inherited from Object)

Events

Occurs when an asynchronous load operation completes.