Vue d’ensemble du langage XAMLXAML overview

Cet article présente les concepts du langage XAML et du XAML au Windows Runtime public des développeurs d’applications, et décrit les différentes façons de déclarer des objets et de définir des attributs en XAML, car il est utilisé pour créer une application Windows Runtime.This article introduces the XAML language and XAML concepts to the Windows Runtime app developer audience, and describes the different ways to declare objects and set attributes in XAML as it is used for creating a Windows Runtime app.

Qu’est-ce que le XAML ?What is XAML?

Le langage XAML (Extensible Application Markup Language) est un langage déclaratif.Extensible Application Markup Language (XAML) is a declarative language. En particulier, XAML peut initialiser des objets et définir des propriétés d’objets à l’aide d’une structure de langage qui affiche des relations hiérarchiques entre plusieurs objets et une convention de type de stockage qui prend en charge l’extension de types.Specifically, XAML can initialize objects and set properties of objects using a language structure that shows hierarchical relationships between multiple objects and a backing type convention that supports extension of types. Vous pouvez créer des éléments d’interface utilisateur visibles dans le balisage XAML déclaratif.You can create visible UI elements in the declarative XAML markup. Vous pouvez alors associer un fichier code-behind distinct pour chaque fichier XAML pouvant répondre à des événements et manipuler les objets que vous déclarez à l’origine en XAML.You can then associate a separate code-behind file for each XAML file that can respond to events and manipulate the objects that you originally declare in XAML.

Le langage XAML prend en charge l’échange de sources entre des outils et des rôles différents dans le processus de développement, tels que l’échange de sources XAML entre les outils de conception et un environnement de développement interactif (IDE) ou entre les développeurs principaux et les développeurs de localisation.The XAML language supports interchange of sources between different tools and roles in the development process, such as exchanging XAML sources between design tools and an interactive development environment (IDE) or between primary developers and localization developers. En utilisant XAML comme format d’échange, les rôles de concepteur et de développeur peuvent être isolés ou rassemblés, et les concepteurs et développeurs peuvent effectuer une itération pendant la production d’une application.By using XAML as the interchange format, designer roles and developer roles can be kept separate or brought together, and designers and developers can iterate during the production of an app.

Les fichiers XAML que vous découvrez dans le cadre de vos projets d’applications Windows Runtime sont en réalité des fichiers XML avec l’extension de nom de fichier .xaml.When you see them as part of your Windows Runtime app projects, XAML files are XML files with the .xaml file name extension.

Syntaxe XAML de baseBasic XAML syntax

La syntaxe de base du langage XAML s’appuie sur le langage XML.XAML has a basic syntax that builds on XML. Par définition, un code XAML valide doit également être un code XML valide.By definition, valid XAML must also be valid XML. Toutefois, XAML possède également des concepts de syntaxe qui se voient attribuer une signification différente et plus complète, tout en étant toujours valides dans XML conformément à la spécification XML 1,0.But XAML also has syntax concepts that are assigned a different and more complete meaning while still being valid in XML per the XML 1.0 specification. Par exemple, le code XAML prend en charge la syntaxe de l’élément de propriété, qui implique la possibilité de définir des valeurs de propriété au sein d’éléments plutôt qu’en tant que valeurs de chaîne dans les attributs ou en tant que contenu.For example, XAML supports property element syntax, where property values can be set within elements rather than as string values in attributes or as content. Pour le langage XML ordinaire, l’élément de propriété XAML constitue un élément dont le nom contient un point. Il est donc valide en langage XML brut, mais n’a pas la même signification.To regular XML, a XAML property element is an element with a dot in its name, so it's valid to plain XML but doesn't have the same meaning.

XAML et Visual StudioXAML and Visual Studio

Microsoft Visual Studio vous aide à produire une syntaxe XAML valide, à la fois dans l’éditeur de texte XAML et dans l’aire de conception XAML, plus orientée vers les graphiques.Microsoft Visual Studio helps you to produce valid XAML syntax, both in the XAML text editor and in the more graphically oriented XAML design surface. Quand vous écrivez du code XAML pour votre application à l’aide de Visual Studio, ne vous inquiétez pas trop de la syntaxe avec chaque séquence de touches.When you write XAML for your app using Visual Studio, don't worry too much about the syntax with each keystroke. L’IDE encourage la syntaxe XAML valide en fournissant des indicateurs de saisie semi-automatique, en présentant des suggestions dans les listes déroulantes et listes Microsoft IntelliSense, en présentant les bibliothèques d’éléments d’interface utilisateur dans la fenêtre boîte à outils ou d’autres techniques.The IDE encourages valid XAML syntax by providing autocompletion hints, showing suggestions in Microsoft IntelliSense lists and dropdowns, showing UI element libraries in the Toolbox window, or other techniques. S’il s’agit de votre première expérience en XAML, il peut être utile de connaître les règles de syntaxe et, en particulier, la terminologie utilisée parfois pour décrire les restrictions ou les choix lors de la description de la syntaxe XAML dans les rubriques de référence ou d’autres rubriques.If this is your first experience with XAML, it might still be useful to know the syntax rules and particularly the terminology that is sometimes used to describe the restrictions or choices when describing XAML syntax in reference or other topics. Les points précis de la syntaxe XAML sont traités dans une rubrique distincte, Guide de syntaxe XAML.The fine points of XAML syntax are covered in a separate topic, XAML syntax guide.

Espaces de noms XAMLXAML namespaces

En programmation au sens large, un espace de noms est un concept d’organisation qui détermine la façon dont les identificateurs pour les entités de programmation sont interprétés.In general programming, a namespace is an organizing concept that determines how identifiers for programming entities are interpreted. Grâce aux espaces de noms, une infrastructure de programmation peut séparer les identificateurs déclarés par l’utilisateur de ceux déclarés par l’infrastructure, éliminer l’ambiguïté des identificateurs par le biais des qualifications d’espaces de noms, appliquer des règles de création d’étendue de noms, etc.By using namespaces, a programming framework can separate user-declared identifiers from framework-declared identifiers, disambiguate identifiers through namespace qualifications, enforce rules for scoping names, and so on. XAML a son propre concept d’espace de noms XAML qui assume cette fonction pour le langage XAML.XAML has its own XAML namespace concept that serves this purpose for the XAML language. Voici comment XAML applique et étend les concepts d’espaces de noms du langage XML :Here's how XAML applies and extends the XML language namespace concepts:

  • XAML utilise l’attribut XML xmlns réservé pour les déclarations d’espaces de noms.XAML uses the reserved XML attribute xmlns for namespace declarations. La valeur de l’attribut est généralement un URI (Uniform Resource Identifier), qui est une convention héritée de XML.The value of the attribute is typically a Uniform Resource Identifier (URI), which is a convention inherited from XML.
  • Les déclarations de préfixes en XAML servent à déclarer les espaces de noms différents de l’espace de noms par défaut, et les utilisations de préfixe dans des éléments et attributs font référence à ces espaces de noms.XAML uses prefixes in declarations to declare non-default namespaces, and prefix usages in elements and attributes reference that namespace.
  • Le langage XAML possède un concept d’espace de noms par défaut, qui est l’espace de noms utilisé lorsqu’une utilisation ou déclaration ne comprend aucun préfixe.XAML has a concept of a default namespace, which is the namespace used when no prefix exists in a usage or declaration. L’espace de noms par défaut peut être défini de façon différente pour chaque infrastructure de programmation XAML.The default namespace can be defined differently for each XAML programming framework.
  • Dans une construction ou un fichier XAML, les définitions d’espaces de noms héritent d’élément parent à élément enfant.Namespace definitions inherit in a XAML file or construct, from parent element to child element. Par exemple, si vous définissez un espace de noms dans l’élément racine d’un fichier XAML, tous les éléments de ce fichier héritent de cette définition d’espace de noms.For example, if you define a namespace in the root element of a XAML file, all elements within that file inherit that namespace definition. Si un élément plus loin dans la page redéfinit l’espace de noms, les descendants de cet élément héritent de la nouvelle définition.If an element further into the page redefines the namespace, that element's descendants inherit the new definition.
  • Les attributs d’un élément héritent des espaces de noms de l’élément.Attributes of an element inherit the element's namespaces. Il est relativement peu courant de voir des préfixes sur des attributs XAML.It's fairly uncommon to see prefixes on XAML attributes.

Un fichier XAML déclare presque toujours un espace de noms XAML par défaut dans son élément racine.A XAML file almost always declares a default XAML namespace in its root element. L’espace de noms XAML par défaut définit les éléments que vous pouvez déclarer sans les qualifier à l’aide d’un préfixe.The default XAML namespace defines which elements you can declare without qualifying them by a prefix. Pour les projets d’application Windows Runtime standard, cet espace de noms par défaut contient tout le vocabulaire XAML intégré pour Windows Runtime qui est utilisé pour les définitions d’interface utilisateur : contrôles par défaut, éléments de texte, animations et graphiques XAML, types de prise en charge d’application de style et de liaison de données, etc.For typical Windows Runtime app projects, this default namespace contains all the built-in XAML vocabulary for the Windows Runtime that's used for UI definitions: the default controls, text elements, XAML graphics and animations, databinding and styling support types, and so on. La plupart du code XAML que vous écrivez pour les applications Windows Runtime est donc capable d’éviter les préfixes et les espaces de noms XAML dans les références aux éléments d’interface utilisateur courants.Most of the XAML you'll write for Windows Runtime apps will thus be able to avoid using XAML namespaces and prefixes when referring to common UI elements.

Voici un extrait de code qui montre une racine créée par un modèle Page de la page initiale pour une application (affichant uniquement la balise d’ouverture et simplifiée).Here's a snippet that shows a template-created Page root of the initial page for an app (showing the opening tag only, and simplified). il déclare l’espace de noms par défaut et également l’espace de noms x (que nous allons ensuite expliquer).It declares the default namespace and also the x namespace (which we'll explain next).

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

Espace de noms XAML de langage XAMLThe XAML-language XAML namespace

Un espace de noms XAML particulier qui est déclaré dans presque tous les fichiers XAML Windows Runtime est l’espace de noms de langage XAML.One particular XAML namespace that is declared in nearly every Windows Runtime XAML file is the XAML-language namespace. Cet espace de noms comprend des éléments et des concepts qui sont définis par la spécification du langage XAML.This namespace includes elements and concepts that are defined by the XAML language specification. Par convention, l’espace de noms XAML de langage XAML est mappé au préfixe « x ».By convention, the XAML-language XAML namespace is mapped to the prefix "x". Les modèles de projet et de fichier par défaut des projets d’applications Windows Runtime définissent toujours à la fois l’espace de noms XAML par défaut (sans préfixe, juste xmlns=) et l’espace de noms XAML de langage XAML (préfixe « x ») dans le cadre de l’élément racine.The default project and file templates for Windows Runtime app projects always define both the default XAML namespace (no prefix, just xmlns=) and the XAML-language XAML namespace (prefix "x") as part of the root element.

Le préfixe « x »/l’espace de noms XAML de langage XAML contient plusieurs constructions de programmation que vous utilisez souvent dans votre code XAML.The "x" prefix/XAML-language XAML namespace contains several programming constructs that you use often in your XAML. Voici les plus couramment employées :Here are the most common ones:

TermeTerm DescriptionDescription
x:Keyx:Key Définit une clé définie par l’utilisateur unique pour chaque ressource dans un XAML ResourceDictionary .Sets a unique user-defined key for each resource in a XAML ResourceDictionary. La chaîne du jeton de la clé est l’argument de l’extension de balisage StaticResource. Vous utiliserez cette clé ultérieurement pour récupérer la ressource XAML d’une autre utilisation XAML à un autre endroit du code XAML de votre application.The key's token string is the argument for the StaticResource markup extension, and you use this key later to retrieve the XAML resource from another XAML usage elsewhere in your app's XAML.
x:Classx:Class Indique l’espace de noms de code et le nom de la classe de code qui fournit le code-behind pour une page XAML.Specifies the code namespace and code class name for the class that provides code-behind for a XAML page. Nomme ainsi la classe créée ou jointe par des actions de génération lorsque vous générez votre application.This names the class that is created or joined by the build actions when you build your app. Ces actions de génération prennent en charge le compilateur de balisage XAML, et combinent le balisage et le code-behind lorsque l’application est compilée.These build actions support the XAML markup compiler and combine your markup and code-behind when the app is compiled. Vous devez avoir une telle classe pour prendre en charge le code-behind pour une page XAML.You must have such a class to support code-behind for a XAML page. Window.Content dans le modèle d’activation par défaut Windows Runtime.Window.Content in the default Windows Runtime activation model.
x:Namex:Name Spécifie un nom d’objet au moment de l’exécution pour l’instance qui existe dans le code d’exécution après le traitement d’un élément objet défini en XAML.Specifies a run-time object name for the instance that exists in run-time code after an object element defined in XAML is processed. La définition de x:Name en XAML s’apparente à la déclaration d’une variable nommée dans le code.You can think of setting x:Name in XAML as being like declaring a named variable in code. Comme vous l’apprendrez plus tard, c’est exactement ce qui se produit lorsque votre code XAML est chargé en tant que composant d’une application Windows Runtime.As you'll learn later, that's exactly what happens when your XAML is loaded as a component of a Windows Runtime app.
Remarque Name est une propriété similaire dans le Framework, mais tous les éléments ne le prennent pas en charge.Note Name is a similar property in the framework, but not all elements support it. Utilisez x :Name pour l’identification de l’élément lorsque FrameworkElement.Name n’est pas pris en charge sur ce type d’élément.Use x:Name for element identification whenever FrameworkElement.Name is not supported on that element type.
x:Uidx:Uid Identifie les éléments qui doivent utiliser des ressources localisées pour certaines de leurs valeurs de propriétés.Identifies elements that should use localized resources for some of their property values. Pour plus d’informations sur l’utilisation de x:Uid, voir Démarrage rapide : traduction des ressources de l’interface utilisateur.For more info on how to use x:Uid, see Quickstart: Translating UI resources.
Types de données intrinsèques XAMLXAML intrinsic data types Ces types peuvent spécifier des valeurs pour des types à valeur simples lorsqu’un attribut ou une ressource l’exige.These types can specify values for simple value-types when that's required for an attribute or resource. Ces types intrinsèques correspondent aux types à valeur simples habituellement définies dans le cadre des définitions intrinsèques de chaque langage de programmation.These intrinsic types correspond to the simple value types that are typically defined as part of each programming language's intrinsic definitions. Par exemple, vous pouvez avoir besoin d’un objet représentant une vraie valeur booléenne à utiliser dans un état visuel de plan conceptuel ObjectAnimationUsingKeyFrames .For example, you might need an object representing a true Boolean value to use in an ObjectAnimationUsingKeyFrames storyboarded visual state. Pour cette valeur en XAML, vous utiliseriez le type intrinsèque x :Boolean comme élément objet, comme suit : <x:Boolean>True</x:Boolean>For that value in XAML, you'd use the x:Boolean intrinsic type as the object element, like this: <x:Boolean>True</x:Boolean>

Il existe d’autres constructions de programmation dans l’espace de noms XAML de langage XAML, mais elles ne sont pas aussi courantes.Other programming constructs in the XAML-language XAML namespace exist but are not as common.

Mappage de types personnalisés à des espaces de noms XAMLMapping custom types to XAML namespaces

La simplicité avec laquelle vous pouvez étendre le vocabulaire XAML des applications Windows Runtime représente l’un des aspects les plus puissants du langage XAML.One of the most powerful aspects of XAML as a language is that it's easy to extend the XAML vocabulary for your Windows Runtime apps. Vous pouvez définir vos propres types personnalisés dans le langage de programmation de votre application, puis référencer vos types personnalisés dans le balisage XAML.You can define your own custom types in your app's programming language and then reference your custom types in XAML markup. La prise en charge de l’extension via des types personnalisés est fondamentalement intégrée au mode de fonctionnement du langage XAML.Support for extension through custom types is fundamentally built-in to how the XAML language works. Les infrastructures ou les développeurs d’applications sont chargés de créer les objets de stockage référencés par le langage XAML.Frameworks or app developers are responsible for creating the backing objects that XAML references. Ni les infrastructures ni le développeur d’application ne sont liés par les spécifications de ce que les objets dans leurs vocabulaires représentent ou dépassent les règles de syntaxe XAML de base.Neither frameworks nor the app developer are bound by specifications of what the objects in their vocabularies represent or do beyond the basic XAML syntax rules. (Il existe certaines attentes quant à ce que les types d’espace de noms XAML en langage XAML doivent faire, mais le Windows Runtime fournit toute la prise en charge nécessaire.)(There are some expectations of what the XAML-language XAML namespace types should do, but the Windows Runtime provides all the necessary support.)

Si vous utilisez XAML pour des types qui proviennent d’autres bibliothèques que les bibliothèques et métadonnées principales Windows Runtime, vous devez déclarer et mapper un espace de noms XAML avec un préfixe.If you use XAML for types that come from libraries other than the Windows Runtime core libraries and metadata, you must declare and map a XAML namespace with a prefix. Utilisez ce préfixe dans les utilisations d’élément pour référencer les types définis dans votre bibliothèque.Use that prefix in element usages to reference the types that were defined in your library. Vous devez déclarer les mappages de préfixes en tant qu’attributs xmlns, généralement dans un élément racine avec d’autres définitions d’espace de noms XAML.You declare prefix mappings as xmlns attributes, typically in a root element along with the other XAML namespace definitions.

Pour créer votre propre définition d’espace de noms faisant référence aux types personnalisés, vous devez d’abord spécifier le mot clé xmlns:, puis le préfixe souhaité.To make your own namespace definition that references custom types, you first specify the keyword xmlns:, then the prefix you want. La valeur de cet attribut doit contenir le mot clé using: en tant que première partie de la valeur.The value of that attribute must contain the keyword using: as the first part of the value. Le reste de la valeur est un jeton de chaîne qui fait nominativement référence à l’espace de noms de stockage de code spécifique contenant vos types personnalisés.The remainder of the value is a string token that references the specific code-backing namespace that contains your custom types, by name.

Le préfixe définit le jeton de balisage utilisé pour faire référence à cet espace de noms XAML dans le reste du balisage dans ce fichier XAML.The prefix defines the markup token that is used to refer to that XAML namespace in the remainder of the markup in that XAML file. Un signe deux-points (:) est placé entre le préfixe et l’entité à référencer dans l’espace de noms XAML.A colon character (:) goes between the prefix and the entity to be referenced within the XAML namespace.

Par exemple, la syntaxe d’attribut pour mapper un préfixe myTypes à l’espace de noms myCompany.myTypes est : xmlns:myTypes="using:myCompany.myTypes" , et l’utilisation d’un élément représentatif est : <myTypes:CustomButton/>For example, the attribute syntax to map a prefix myTypes to the namespace myCompany.myTypes is: xmlns:myTypes="using:myCompany.myTypes", and a representative element usage is: <myTypes:CustomButton/>

Pour plus d’informations sur le mappage des espaces de noms XAML pour les types personnalisés, y compris les considérations spéciales pour les extensions de composant Visual C++ (C++/CX), voir Espaces de noms XAML et mappage d’espaces de noms.For more info on mapping XAML namespaces for custom types, including special considerations for Visual C++ component extensions (C++/CX), see XAML namespaces and namespace mapping.

Autres espaces de noms XAMLOther XAML namespaces

On voit souvent des fichiers XAML qui définissent les préfixes « d » (pour l’espace de noms du concepteur) et « mc » (pour la compatibilité du balisage).You often see XAML files that define the prefixes "d" (for designer namespace) and "mc" (for markup compatibility). En règle générale, il s’agit de la prise en charge de l’infrastructure ou d’activer des scénarios dans un outil au moment du Design.Generally, these are for infrastructure support or to enable scenarios in a design-time tool. Pour plus d’informations, voir la section « Autres espaces de noms XAML » de la rubrique sur les espaces de noms XAML.For more info, see the "Other XAML namespaces" section of the XAML namespaces topic.

Extensions de balisageMarkup extensions

Les extensions de balisage constituent un concept du langage XAML qui est souvent utilisé dans l’implémentation XAML Windows Runtime.Markup extensions are a XAML language concept that is often used in the Windows Runtime XAML implementation. Les extensions de balisage constituent souvent un type de raccourci permettant à un fichier XAML d’accéder à une valeur ou à un comportement qui ne se contente pas de déclarer les éléments en fonction des types de stockage.Markup extensions often represent some kind of "shortcut" that enables a XAML file to access a value or behavior that isn't simply declaring elements based on backing types. Certaines extensions de balisage peuvent définir des propriétés avec des chaînes brutes ou avec d’autres éléments imbriqués, le but étant de simplifier la syntaxe ou la refactorisation entre différents fichiers XAML.Some markup extensions can set properties with plain strings or with additionally nested elements, with the goal of streamlining the syntax or the factoring between different XAML files.

Dans la syntaxe d’attribut XAML, les accolades « { » et « } » indiquent l’utilisation d’une extension de balisage XAML.In XAML attribute syntax, curly braces "{" and "}" indicate a XAML markup extension usage. Cette utilisation ordonne au traitement XAML d’éviter le traitement général consistant à traiter les valeurs d’attributs en tant que chaîne littérale ou valeur directement convertible en chaîne.This usage directs the XAML processing to escape from the general treatment of treating attribute values as either a literal string or a directly string-convertible value. À la place, un analyseur XAML appelle le code qui fournit le comportement pour cette extension de balisage particulière, et ce code fournit un autre objet ou résultat de comportement exigé par l’analyseur XAML.Instead, a XAML parser calls code that provides behavior for that particular markup extension, and that code provides an alternate object or behavior result that the XAML parser needs. Les extensions de balisage peuvent posséder des arguments qui suivent le nom de l’extension de balisage et qui sont également contenus dans les accolades.Markup extensions can have arguments, which follow the markup extension name and are also contained within the curly braces. En général, une extension de balisage évaluée fournit une valeur de retour de type objet.Typically, an evaluated markup extension provides an object return value. Pendant l’analyse, cette valeur de retour est insérée à l’emplacement de l’arborescence d’objets où l’utilisation de l’extension de balisage se situait dans le code XAML source.During parsing, that return value is inserted into the position in the object tree where the markup extension usage was in the source XAML.

Le langage XAML Windows Runtime prend en charge ces extensions de balisage qui sont définies sous l’espace de noms XAML par défaut et comprises par son analyseur XAML :Windows Runtime XAML supports these markup extensions that are defined under the default XAML namespace and are understood by the Windows Runtime XAML parser:

  • {x :bind}: prend en charge la liaison de données, qui diffère l’évaluation de propriété jusqu’au moment de l’exécution en exécutant du code à usage spécial, qu’il génère au moment de la compilation.{x:Bind}: supports data binding, which defers property evaluation until run-time by executing special-purpose code, which it generates at compile-time. Cette extension de balisage prend en charge une large gamme d’arguments.This markup extension supports a wide range of arguments.
  • {Binding} : prend en charge la liaison de données, qui diffère l'évaluation de propriété jusqu'au moment de l'exécution par l'exécution d’une inspection d’objet runtime à usage général.{Binding}: supports data binding, which defers property evaluation until run-time by executing general-purpose runtime object inspection. Cette extension de balisage prend en charge une large gamme d’arguments.This markup extension supports a wide range of arguments.
  • {StaticResource}: prend en charge le référencement des valeurs de ressource définies dans un ResourceDictionary .{StaticResource}: supports referencing resource values that are defined in a ResourceDictionary. Ces ressources peuvent se trouver dans un autre fichier XAML, mais doivent en fin de compte être localisables par l’analyseur XAML au moment du chargement.These resources can be in a different XAML file but must ultimately be findable by the XAML parser at load time. L’argument d’une {StaticResource} utilisation identifie la clé (le nom) d’une ressource de clé dans un ResourceDictionary .The argument of a {StaticResource} usage identifies the key (the name) for a keyed resource in a ResourceDictionary.
  • {ThemeResource} : similaire à {StaticResource}, mais peut répondre à des modifications de thème au moment de l’exécution.{ThemeResource}: similar to {StaticResource} but can respond to run-time theme changes. {ThemeResource} apparaît assez souvent dans les modèles XAML Windows Runtime par défaut, car la plupart de ces modèles sont conçus afin d’assurer la compatibilité lorsque l’utilisateur change de thème pendant l’exécution de l’application.{ThemeResource} appears quite often in the Windows Runtime default XAML templates, because most of these templates are designed for compatibility with the user switching the theme while the app is running.
  • {TemplateBinding} : cas spécial de {Binding} qui prend en charge les modèles de contrôle en XAML et leur utilisation éventuelle au moment de l’exécution.{TemplateBinding}: a special case of {Binding} that supports control templates in XAML and their eventual usage at run time.
  • {RelativeSource} : autorise une forme particulière de liaison de modèles où les valeurs proviennent du parent basé sur un modèle.{RelativeSource}: enables a particular form of template binding where values come from the templated parent.
  • {CustomResource} : pour les scénarios de recherche de ressource avancés.{CustomResource}: for advanced resource lookup scenarios.

Windows Runtime prend également en charge l’extension de balisage {x:Null}.Windows Runtime also supports the {x:Null} markup extension. Celle-ci est utilisée pour définir les valeurs Nullable sur null en XAML.You use this to set Nullable values to null in XAML. Par exemple, vous pouvez l’utiliser dans un modèle de contrôle pour un CheckBox , qui interprète la valeur null comme un état d’activation indéterminé (déclenchant l’état visuel « indéterminé »).For example you might use this in a control template for a CheckBox, which interprets null as an indeterminate check state (triggering the "Indeterminate" visual state).

Une extension de balisage retourne généralement une instance existante d’une autre partie du graphique d’objets pour l’application ou diffère une valeur pour l’exécution.A markup extension generally returns an existing instance from some other part of the object graph for the app or defers a value to run time. Dans la mesure où vous pouvez utiliser une extension de balisage comme valeur d’attribut, et il s’agit là de son utilisation classique, vous voyez souvent des extensions de balisage fournissant des valeurs pour des propriétés de type référence qui auraient pu sinon requérir une syntaxe d’élément de propriété.Because you can use a markup extension as an attribute value, and that's the typical usage, you often see markup extensions providing values for reference-type properties that might have otherwise required a property element syntax.

Par exemple, voici la syntaxe permettant de référencer un réutilisable Style à partir d’un ResourceDictionary : <Button Style="{StaticResource SearchButtonStyle}"/> .For example, here's the syntax for referencing a reusable Style from a ResourceDictionary: <Button Style="{StaticResource SearchButtonStyle}"/>. Un Style est un type référence, et non une valeur simple. ainsi, sans l' {StaticResource} utilisation, vous auriez besoin d’un <Button.Style> élément Property et d’une <Style> définition dans celui-ci pour définir la FrameworkElement.Style propriété.A Style is a reference type, not a simple value, so without the {StaticResource} usage, you would've needed a <Button.Style> property element and a <Style> definition within it to set the FrameworkElement.Style property.

En utilisant des extensions de balisage, chaque propriété qui peut être définie en XAML peut éventuellement être définie dans la syntaxe d’attribut.By using markup extensions, every property that is settable in XAML is potentially settable in attribute syntax. Vous pouvez utiliser la syntaxe d’attribut pour fournir des valeurs de référence pour une propriété même si elle ne prend sinon pas en charge une syntaxe d’attribut pour l’instanciation directe des objets.You can use attribute syntax to provide reference values for a property even if it doesn't otherwise support an attribute syntax for direct object instantiation. Vous pouvez aussi activer un comportement spécifique qui diffère l’exigence générale selon laquelle les propriétés XAML sont renseignées par des types valeur ou des types référence nouvellement créés.Or you can enable specific behavior that defers the general requirement that XAML properties be filled by value types or by newly created reference types.

Pour illustrer cela, l’exemple XAML suivant définit la valeur de la FrameworkElement.Style propriété d’un Border à l’aide de la syntaxe d’attribut.To illustrate, the next XAML example sets the value of the FrameworkElement.Style property of a Border by using attribute syntax. La FrameworkElement.Style propriété prend une instance de la Windows.UI.Xaml.Style classe, un type référence qui, par défaut, n’a pas pu être créé à l’aide d’une chaîne de syntaxe d’attribut.The FrameworkElement.Style property takes an instance of the Windows.UI.Xaml.Style class, a reference type that by default could not be created using an attribute syntax string. Dans ce cas, par contre, l’attribut fait référence à une extension de balisage particulière, StaticResource.But in this case, the attribute references a particular markup extension, StaticResource. Quand cette extension de balisage est traitée, elle renvoie une référence à un élément Style précédemment défini sous forme de ressource à clé dans un dictionnaire de ressources.When that markup extension is processed, it returns a reference to a Style element that was defined earlier as a keyed resource in a resource dictionary.

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

Vous pouvez imbriquer des extensions de balisage.You can nest markup extensions. L'extension de balisage la plus profonde est évaluée en premier.The innermost markup extension is evaluated first.

En raison des extensions de balisage, vous devez utiliser une syntaxe spéciale pour une valeur « { » littérale dans un attribut.Because of markup extensions, you need special syntax for a literal "{" value in an attribute. Pour plus d’informations, voir Guide de la syntaxe XAML.For more info see XAML syntax guide.

ÉvénementsEvents

Le langage XAML est un langage déclaratif pour les objets et leurs propriétés, mais il inclut également une syntaxe pour attacher des gestionnaires d’événements aux objets dans le balisage.XAML is a declarative language for objects and their properties, but it also includes a syntax for attaching event handlers to objects in the markup. La syntaxe d’événement XAML peut alors intégrer les événements déclarés en XAML via le modèle de programmation Windows Runtime.The XAML event syntax can then integrate the XAML-declared events through the Windows Runtime programming model. Vous spécifiez le nom de l’événement sous forme de nom d’attribut sur l’objet dans lequel l’événement est géré.You specify the name of the event as an attribute name on the object where the event is handled. Pour la valeur de l’attribut, vous spécifiez le nom d’une fonction de gestionnaire d’événements que vous définissez dans le code.For the attribute value, you specify the name of an event-handler function that you define in code. Le processeur XAML utilise ce nom pour créer une représentation déléguée dans l’arborescence d’objets chargée, puis ajoute le gestionnaire spécifié à une liste de gestionnaires internes.The XAML processor uses this name to create a delegate representation in the loaded object tree, and adds the specified handler to an internal handler list. Presque toutes les applications Windows Runtime sont définies à la fois par un balisage et des sources code-behind.Nearly all Windows Runtime apps are defined by both markup and code-behind sources.

Voici un exemple simple.Here's a simple example. La Button classe prend en charge un événement nommé Click .The Button class supports an event named Click. Vous pouvez écrire un gestionnaire pour Click qui exécute du code appelé dès que l’utilisateur clique sur l’objet Button.You can write a handler for Click that runs code that should be invoked after the user clicks the Button. En XAML, vous spécifiez Click comme attribut de Button.In XAML, you specify Click as an attribute on the Button. Pour la valeur d’attribut, indiquez une chaîne représentant le nom de méthode de votre gestionnaire.For the attribute value, provide a string that is the method name of your handler.

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

Au moment de la compilation, le compilateur suppose qu’une méthode nommée showUpdatesButton_Click est définie dans le fichier code-behind, dans l’espace de noms déclaré dans la valeur x:Class de la page XAML.When you compile, the compiler now expects that there will be a method named showUpdatesButton_Click defined in the code-behind file, in the namespace declared in the XAML page's x:Class value. En outre, cette méthode doit satisfaire le contrat de délégué pour l' Click événement.Also, that method must satisfy the delegate contract for the Click event. Par exemple :For example:

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

Au sein d’un projet, le code XAML est écrit sous forme de fichier .xaml et vous utilisez le langage de votre choix (C#, Visual Basic, C++/CX) pour écrire un fichier code-behind.Within a project, the XAML is written as a .xaml file, and you use the language you prefer (C#, Visual Basic, C++/CX) to write a code-behind file. Lorsque le balisage d’un fichier XAML est compilé dans le cadre d’une action de génération du projet, l’emplacement du fichier XAML code-behind de chaque page XAML est identifié en spécifiant un espace de noms et une classe sous forme d’attribut x:Class de l’élément racine de la page XAML.When a XAML file is markup-compiled as part of a build action for the project, the location of the XAML code-behind file for each XAML page is identified by specifying a namespace and class as the x:Class attribute of the root element of the XAML page. Pour plus d’informations sur le fonctionnement de ces mécanismes en XAML et sur leur relation avec les modèles de programmation et d’application, voir Vue d’ensemble des événements et des événements routés.For more info on how these mechanisms work in XAML and how they relate to the programming and application models, see Events and routed events overview.

Notes

Pour C++/CX, il existe deux fichiers code-behind : l’un est un en-tête (. Xaml. h) et l’autre est Implementation (. Xaml. cpp).For C++/CX there are two code-behind files: one is a header (.xaml.h) and the other is implementation (.xaml.cpp). L’implémentation fait référence à l’en-tête. D’un point de vue technique, c’est l’en-tête qui représente le point d’entrée de la connexion code-behind.The implementation references the header, and it's technically the header that represents the entry point for the code-behind connection.

Dictionnaires de ressourcesResource dictionaries

La création d’un ResourceDictionary est une tâche courante qui est généralement accomplie en créant un dictionnaire de ressources sous la forme d’une zone d’une page XAML ou d’un fichier XAML distinct.Creating a ResourceDictionary is a common task that is usually accomplished by authoring a resource dictionary as an area of a XAML page or a separate XAML file. Les dictionnaires de ressources et leur mode d’utilisation représentent un domaine conceptuel plus important qui sort du cadre de cette rubrique.Resource dictionaries and how to use them is a larger conceptual area that is outside the scope of this topic. Pour plus d’informations, voir Références aux ressources ResourceDictionary et XAML.For more info see ResourceDictionary and XAML resource references.

XAML et XMLXAML and XML

Le langage XAML se base fondamentalement sur le langage XML.The XAML language is fundamentally based on the XML language. Mais il étend considérablement le langage XML.But XAML extends XML significantly. Plus précisément, il traite le concept de schéma légèrement différemment en raison de sa relation au concept de type de stockage et il ajoute des éléments de langage tels que les membres attachés et les extensions de balisage.In particular it treats the concept of schema quite differently because of its relationship to the backing type concept, and adds language elements such as attached members and markup extensions. L’attribut xml:lang est valide en langage XAML, mais il influence l’exécution au lieu du comportement d’analyse et dispose d’un alias qui est une propriété au niveau de l’infrastructure.xml:lang is valid in XAML, but influences runtime rather than parse behavior, and is typically aliased to a framework-level property. Pour en savoir plus, voir FrameworkElement.Language.For more info, see FrameworkElement.Language. xml:base est valide dans le balisage, mais les analyseurs l’ignorent.xml:base is valid in markup but parsers ignore it. L’attribut xml:space est valide, mais il est uniquement pertinent pour les scénarios décrits dans la rubrique XAML et espace blanc.xml:space is valid, but is only relevant for scenarios described in the XAML and whitespace topic. L’attribut encoding est valide en langage XAML.The encoding attribute is valid in XAML. Seuls les codages UTF-8 et UTF-16 sont pris en charge.Only UTF-8 and UTF-16 encodings are supported. Le codage UTF-32 n’est pas pris en charge.UTF-32 encoding is not supported.

Respect de la casse en langage XAMLCase sensitivity in XAML

Le langage XAML respecte la casse.XAML is case-sensitive. Il s’agit d’une autre conséquence du fait que le langage XAML soit basé sur le langage XML, lequel respecte la casse.This is another consequence of XAML being based on XML, which is case-sensitive. Les noms des éléments et attributs XAML respectent la casse.The names of XAML elements and attributes are case-sensitive. La valeur d’un attribut respecte potentiellement la casse ; cela dépend de la manière dont la valeur d’attribut est gérée pour des propriétés particulières.The value of an attribute is potentially case-sensitive; this depends on how the attribute value is handled for particular properties. Par exemple, si la valeur d’attribut déclare un nom de membre d’une énumération, le comportement intégré qui convertit le type d’une chaîne de nom de membre afin de renvoyer la valeur du membre de l’énumération ne tient pas compte de la casse.For example, if the attribute value declares a member name of an enumeration, the built-in behavior that type-converts a member name string to return the enumeration member value is not case-sensitive. Par opposition, la valeur de la propriété Name et les méthodes utilitaires permettant d’utiliser des objets en fonction du nom que la propriété Name déclare traitent la chaîne du nom en tenant compte de la casse.In contrast, the value of the Name property, and utility methods for working with objects based on the name that the Name property declares, treat the name string as case-sensitive.

Namescopes XAMLXAML namescopes

Le langage XAML définit un concept de namescope XAML.The XAML language defines a concept of a XAML namescope. Le concept de namescope XAML influence la manière dont les processeurs XAML doivent traiter la valeur de x:Name ou Name appliquée aux éléments XAML, en particulier les étendues dans lesquelles les noms doivent être des identificateurs uniques fiables.The XAML namescope concept influences how XAML processors should treat the value of x:Name or Name applied to XAML elements, particularly the scopes in which names should be relied upon to be unique identifiers. Pour plus d’informations sur les namescopes XAML, voir Namescopes XAML.XAML namescopes are covered in more detail in a separate topic; see XAML namescopes.

Rôle du langage XAML dans le processus de développementThe role of XAML in the development process

Le langage XAML assume plusieurs rôles importants dans le processus de développement d’application.XAML plays several important roles in the app development process.

  • Il s’agit du principal format pour la déclaration de l’interface utilisateur d’une application et des éléments de cette interface, si vous programmez en C#, Visual Basic ou C++/CX.XAML is the primary format for declaring an app's UI and elements in that UI, if you are programming using C#, Visual Basic or C++/CX. En général, au moins un fichier XAML dans votre projet représente une métaphore de page dans votre application pour l’interface utilisateur affichée initialement.Typically at least one XAML file in your project represents a page metaphor in your app for the initially displayed UI. D’autres fichiers XAML peuvent déclarer des pages supplémentaires pour l’interface utilisateur de navigation.Additional XAML files might declare additional pages for navigation UI. D’autres encore peuvent déclarer des ressources telles que des modèles ou des styles.Other XAML files can declare resources, such as templates or styles.
  • On utilise le format XAML pour déclarer des styles et des modèles appliqués aux contrôles et à l’interface utilisateur d’une application.You use the XAML format for declaring styles and templates applied to controls and UI for an app.
  • Vous pouvez utiliser des styles et des modèles pour écrire des modèles de contrôles existants ou si vous utilisez un contrôle qui fournit un modèle par défaut dans le cadre d’un package de contrôle.You might use styles and templates either for templating existing controls, or if you define a control that supplies a default template as part of a control package. Lorsque vous l’utilisez pour définir des styles et des modèles, le code XAML pertinent est souvent déclaré en tant que fichier XAML discret avec une ResourceDictionary racine.When you use it to define styles and templates, the relevant XAML is often declared as a discrete XAML file with a ResourceDictionary root.
  • XAML est le format courant pour la prise en charge de la création d’interface utilisateur d’application et l’échange de la conception d’interface utilisateur entre différentes applications de conception.XAML is the common format for designer support of creating app UI and exchanging the UI design between different designer apps. Plus spécifiquement, le code XAML de l’application peut être partagé par différents outils de conception XAML (ou fenêtres de conception au sein d’outils).Most notably, XAML for the app can be interchanged between different XAML design tools (or design windows within tools).
  • Plusieurs autres technologies définissent également l’interface utilisateur de base en XAML.Several other technologies also define the basic UI in XAML. En ce qui concerne le code XAML Windows Presentation Foundation (WPF) et le code XAML Microsoft Silverlight, le code XAML pour Windows Runtime utilise le même URI pour son espace de noms XAML par défaut partagé.In relationship to Windows Presentation Foundation (WPF) XAML and Microsoft Silverlight XAML, the XAML for Windows Runtime uses the same URI for its shared default XAML namespace. Le vocabulaire XAML pour Windows Runtime recoupe considérablement le vocabulaire XAML pour interface utilisateur également utilisé par Silverlight et, dans une moindre mesure, par WPF.The XAML vocabulary for Windows Runtime overlaps significantly with the XAML-for-UI vocabulary also used by Silverlight and to a slightly lesser extent by WPF. Ainsi, XAML assure la promotion d’un itinéraire de migration efficace pour une interface utilisateur initialement définie pour des technologies d’avant-garde qui utilisaient également XAML.Thus, XAML promotes an efficient migration pathway for UI originally defined for precursor technologies that also used XAML.
  • XAML définit l’apparence visuelle d’une interface utilisateur et un fichier code-behind associé définit la logique.XAML defines the visual appearance of a UI, and an associated code-behind file defines the logic. Vous pouvez ajuster la conception de l’interface utilisateur sans modifier la logique dans le code-behind.You can adjust the UI design without making changes to the logic in code-behind. XAML simplifie le flux de travail entre les concepteurs et les développeurs.XAML simplifies the workflow between designers and developers.
  • Grâce à la richesse de la prise en charge de l’aire de conception et du concepteur visuel pour le langage XAML, XAML prend en charge un prototypage d’interface utilisateur rapide durant les phases de développement initiales.Because of the richness of the visual designer and design surface support for the XAML language, XAML supports rapid UI prototyping in the early development phases.

Votre degré d’interaction avec les fichiers XAML dépendra de votre propre rôle dans le processus de développementDepending on your own role in the development process, you might not interact with XAML much. Le degré de votre interaction avec les fichiers XAML dépend également de votre environnement de développement, de l’utilisation éventuelle de fonctionnalités d’environnement de conception interactives telles que les boîtes à outils et les éditeurs de propriétés, ainsi que de l’étendue et de la finalité de votre application Windows Runtime.The degree to which you do interact with XAML files also depends on which development environment you are using, whether you use interactive design environment features such as toolboxes and property editors, and the scope and purpose of your Windows Runtime app. Néanmoins, il est probable que durant le développement de l’application vous modifierez un fichier XAML au niveau élément à l’aide d’un éditeur de texte ou d’un éditeur XAML.Nevertheless, it is likely that during development of the app, you will be editing a XAML file at the element level using a text or XML editor. Grâce à ces informations, vous pourrez en toute confiance modifier du code XAML dans une représentation texte ou XML et conserver la validité et la finalité des déclarations de ce fichier XAML quand il sera consommé par des outils, des opérations de compilation de balisage ou la phase d’exécution de votre application Windows Runtime.Using this info, you can confidently edit XAML in a text or XML representation and maintain the validity of that XAML file's declarations and purpose when it is consumed by tools, markup compile operations, or the run-time phase of your Windows Runtime app.

Optimiser le chargement du code XAMLOptimize your XAML for load performance

Voici certains conseils pour définir des éléments d’interface utilisateur en XAML dans un souci de performance.Here are some tips for defining UI elements in XAML using best practices for performance. Nombreux de ces conseils concernent l’utilisation de ressources XAML, mais sont répertoriés ici dans la vue d’ensemble du langage XAML pour des raisons pratiques.Many of these tips relate to using XAML resources, but are listed here in the general XAML overview for convenience. Pour plus d’informations sur les ressources XAML, voir Références aux ressources ResourceDictionary et XAML.For more info about XAML resources see ResourceDictionary and XAML resource references. Pour obtenir d’autres conseils relatifs aux performances, notamment sur XAML qui affiche délibérément certaines mauvaises pratiques en termes de performance que vous devrez éviter dans votre code XAML, voir Optimiser votre balisage XAML.For some more tips on performance, including XAML that purposely demonstrates some of the poor performance practices that you should avoid in your XAML, see Optimize your XAML markup.

  • Si vous utilisez le même pinceau de couleur souvent dans votre code XAML, définissez une SolidColorBrush en tant que ressource plutôt que d’utiliser une couleur nommée en tant que valeur d’attribut à chaque fois.If you use the same color brush often in your XAML, define a SolidColorBrush as a resource rather than using a named color as an attribute value each time.
  • Si vous utilisez la même ressource sur plusieurs pages de l’interface utilisateur, envisagez de la définir dans Resources plutôt que sur chaque page.If you use the same resource on more than one UI page, consider defining it in Resources rather than on each page. À l’inverse, si une seule page utilise une ressource spécifique, ne définissez pas celle-ci dans Application.Resources, mais uniquement pour la page qui en a besoin.Conversely, if only one page uses a resource, don't define it in Application.Resources and instead define it only for the page that needs it. Cette opération s’avère bénéfique à la fois pour la factorisation XAML pendant la conception de votre application et pour les performances pendant l’analyse XAML.This is good both for XAML factoring while designing your app and for performance during XAML parsing.
  • Pour les ressources empaquetées par votre application, déterminez si certaines sont inutilisées (ressource possédant une clé, mais qui n’est utilisée par aucune référence StaticResource dans votre application).For resources that your app packages, check for unused resources (a resource that has a key, but there's no StaticResource reference in your app that uses it). Supprimez-les complètement de votre code XAML avant de publier votre application.Remove these from your XAML before you release your app.
  • Si vous utilisez des fichiers XAML distincts qui fournissent des ressources de conception ( MergedDictionaries ), envisagez de commenter ou de supprimer des ressources inutilisées de ces fichiers.If you're using separate XAML files that provides design resources (MergedDictionaries), consider commenting or removing unused resources from these files. Même si votre processus de développement comprend un point de départ XAML commun à différentes applications ou fournit les ressources communes à toute votre application, votre application est responsable chaque fois du package des ressources XAML et potentiellement de leur chargement.Even if you have a shared XAML starting point that you're using in more than one app or that provides common resources for all your app, it's still your app that packages the XAML resources each time, and potentially has to load them.
  • Ne définissez pas d’éléments d’interface utilisateur superflus pour la composition, mais utilisez les modèles de contrôle par défaut chaque fois que cela est possible (la performance du chargement de ces modèles a déjà été testée et vérifiée).Don't define UI elements you don't need for composition, and use the default control templates whenever possible (these templates have already been tested and verified for load performance).
  • Utilisez des conteneurs tels que Border plutôt que des surdessins délibérés des éléments d’interface utilisateur.Use containers such as Border rather than deliberate overdraws of UI elements. En fait, ne dessinez pas le même pixel plusieurs fois.Basically, don't draw the same pixel multiple times. Pour plus d’informations sur le surdessin et sur la façon de le tester, consultez DebugSettings.IsOverdrawHeatMapEnabled .For more info on overdraw and how to test for it, see DebugSettings.IsOverdrawHeatMapEnabled.
  • Utilisez les modèles d’éléments par défaut pour ListView ou GridView . ceux-ci ont une logique de Présentation spéciale qui résout les problèmes de performances lors de la création de l’arborescence d’éléments visuels pour un grand nombre d’éléments de liste.Use the default items templates for ListView or GridView; these have special Presenter logic that solves performance issues when building the visual tree for large numbers of list items.

Déboguer XAMLDebug XAML

XAML étant un langage de balisage, certaines des stratégies ordinairement utilisées à des fins de débogage dans Microsoft Visual Studio ne sont pas disponibles.Because XAML is a markup language, some of the typical strategies for debugging within Microsoft Visual Studio are not available. Par exemple, il est impossible de définir un point d’arrêt dans un fichier XAML.For example, there is no way to set a breakpoint within a XAML file. Toutefois, vous pouvez recourir à d’autres techniques pour résoudre les problèmes liés aux définitions de l’interface utilisateur ou à un autre balisage XAML pendant la phase de développement de votre application.However, there are other techniques that can help you debug issues with UI definitions or other XAML markup while you're still developing your app.

En règle générale, quand un fichier XAML présente des problèmes, un système ou votre application déclenche une exception d’analyse XAML.When there are problems with a XAML file, the most typical result is that some system or your app will throw a XAML parse exception. Chaque fois qu’une exception d’analyse XAML se produit, le XAML chargé par l’analyseur XAML ne parvient pas à créer d’arborescence d’objet valide.Whenever there is a XAML parse exception, the XAML loaded by the XAML parser failed to create a valid object tree. Dans certains cas, l’exception d’analyse XAML n’est pas récupérable, comme, par exemple, quand le XAML représente la première « page » de votre application qui est chargée en tant que Visual racine.In some cases, such as when the XAML represents the first "page" of your application that is loaded as the root visual, the XAML parse exception is not recoverable.

Le XAML est souvent modifié dans un IDE tel que Visual Studio et l’une de ses aires de conception XAML.XAML is often edited within an IDE such as Visual Studio and one of its XAML design surfaces. Il est fréquent que Visual Studio valide le contenu et l’intégrité d’une source XAML en cours de conception.Visual Studio can often provide design-time validation and error checking of a XAML source as you edit it. Par exemple, il peut afficher des lignes ondulées dans l’éditeur de texte XAML dès que vous tapez une mauvaise valeur d’attribut, si bien que vous n’avez pas besoin de passer par une phase de compilation du XAML pour constater que quelque chose ne va pas avec votre définition de l’interface utilisateur.For example it might display "squiggles" in the XAML text editor as soon as you type a bad attribute value, and you won't even have to wait for a XAML compile pass to see that something's wrong with your UI definition.

Une fois que l’application s’exécute pour de bon, les erreurs d’analyse XAML éventuelles qui n’ont pas été détectées au moment de la conception sont signalées par le Common Language Runtime (CLR) en tant qu’objet XamlParseException.Once the app actually runs, if any XAML parse errors have gone undetected at design time, these are reported by the common language runtime (CLR) as a XamlParseException. Pour plus d’informations sur ce que vous pouvez effectuer avec XamlParseException au moment de l’exécution, voir Gestion des exceptions pour les applications Windows Runtime en C# ou Visual Basic.For more info on what you might be able to do for a run-time XamlParseException, see Exception handling for Windows Runtime apps in C# or Visual Basic.

Notes

Les applications qui utilisent C++/CX pour le code n’obtiennent pas le XamlParseExceptionspécifique.Apps that use C++/CX for code don't get the specific XamlParseException. Toutefois, le message dans l’exception est explicite quant au fait que la source de l’erreur est liée à XAML et comprend des informations contextuelles telles que les numéros de ligne d’un fichier XAML, à l’image de l’objet XamlParseException.But the message in the exception clarifies that the source of the error is XAML-related, and includes context info such as line numbers in a XAML file, just like XamlParseException does.

Pour plus d’informations sur le débogage d’une application Windows Runtime, consultez Démarrer une session de débogage.For more info on debugging a Windows Runtime app, see Start a debug session.