Vue d’ensemble de la liaison de donnéesData Binding Overview

La liaison de données Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) offre un moyen simple et cohérent pour les applications de présenter les données et d’interagir avec elles.Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) data binding provides a simple and consistent way for applications to present and interact with data. Les éléments peuvent être liés à des données provenant de diverses sources de données sous la forme d’objets common language runtime (CLR XMLXML) et.Elements can be bound to data from a variety of data sources in the form of common language runtime (CLR) objects and XMLXML. ContentControltels que Button et ItemsControl, tels ListBox queListView et, ont des fonctionnalités intégrées permettant d’activer le style flexible des éléments de données uniques ou des collections d’éléments de données.ContentControls such as Button and ItemsControls such as ListBox and ListView have built-in functionality to enable flexible styling of single data items or collections of data items. Des vues de tri, filtrage et groupage peuvent être générées sur la base des données.Sort, filter, and group views can be generated on top of the data.

La fonctionnalité de liaison de données dans WPFWPF présente plusieurs avantages par rapport aux modèles traditionnels, notamment une large gamme de propriétés qui prennent en charge par nature la liaison de données, une représentation Interface utilisateurUI flexible des données et une séparation nette de la logique métier de Interface utilisateurUI.The data binding functionality in WPFWPF has several advantages over traditional models, including a broad range of properties that inherently support data binding, flexible Interface utilisateurUI representation of data, and clean separation of business logic from Interface utilisateurUI.

Cette rubrique aborde en premier les concepts WPFWPF fondamentaux de la liaison de données, puis passe à Binding l’utilisation de la classe et d’autres fonctionnalités de la liaison de données.This topic first discusses concepts fundamental to WPFWPF data binding and then goes into the usage of the Binding class and other features of data binding.

Qu’est-ce que la liaison de données ?What Is Data Binding?

La liaison de données est le processus qui établit une connexion entre Interface utilisateurUI de l’application et logique métier.Data binding is the process that establishes a connection between the application Interface utilisateurUI and business logic. Si la liaison est correctement paramétrée et si les données fournissent les notifications appropriées, lorsque les données changent de valeur, les éléments qui sont liés aux données reflètent automatiquement ces changements.If the binding has the correct settings and the data provides the proper notifications, then, when the data changes its value, the elements that are bound to the data reflect changes automatically. La liaison de données peut également signifier que si une représentation externe des données dans un élément change, les données sous-jacentes peuvent être automatiquement mises à jour pour refléter les modifications.Data binding can also mean that if an outer representation of the data in an element changes, then the underlying data can be automatically updated to reflect the change. Par exemple, si l’utilisateur modifie la valeur dans un TextBox élément, la valeur de données sous-jacente est automatiquement mise à jour pour refléter cette modification.For example, if the user edits the value in a TextBox element, the underlying data value is automatically updated to reflect that change.

Une utilisation typique de la liaison de données consiste à placer des données de configuration locale ou de serveur dans des formulaires ou d’autres contrôles Interface utilisateurUI.A typical use of data binding is to place server or local configuration data into forms or other Interface utilisateurUI controls. Dans WPFWPF, ce concept est développé pour inclure la liaison d’une large gamme de propriétés à diverses sources de données.In WPFWPF, this concept is expanded to include the binding of a broad range of properties to a variety of data sources. Dans WPFWPF, les propriétés de dépendance des éléments peuvent être liées aux objets CLR (y compris les objets ADO.net ou les objets associés aux services Web XMLXML et aux propriétés Web) et aux données.In WPFWPF, dependency properties of elements can be bound to CLR objects (including ADO.NET objects or objects associated with Web Services and Web properties) and XMLXML data.

Pour obtenir un exemple de liaison de données, examinons l’application Interface utilisateurUI suivante de la Démonstration de la liaison de données :For an example of data binding, take a look at the following application Interface utilisateurUI from the Data Binding Demo:

Capture d’écran exemple de liaison de donnéesData binding sample screenshot

Ce qui précède est le Interface utilisateurUI d’une application qui affiche une liste d’éléments de vente aux enchères.The above is the Interface utilisateurUI of an application that displays a list of auction items. L’application illustre les fonctionnalités suivantes de la liaison de données :The application demonstrates the following features of data binding:

  • Le contenu de ListBox est lié à une collection d’objets AuctionItem .The content of the ListBox is bound to a collection of AuctionItem objects. An objet AuctionItem a des propriétés telles que Description, StartPrice, StartDate, Category, SpecialFeatures, etc.An AuctionItem object has properties such as Description, StartPrice, StartDate, Category, SpecialFeatures, etc.

  • Les données (objetsAuctionItem ) affichées dans le ListBox sont basées sur un modèle, de sorte que la description et le prix actuel sont affichés pour chaque élément.The data (AuctionItem objects) displayed in the ListBox is templated so that the description and the current price are shown for each item. Pour ce faire, utilisez DataTemplateun.This is done using a DataTemplate. En outre, l’apparence de chaque élément varie selon la valeur de SpecialFeatures de l’AuctionItem affiché.In addition, the appearance of each item depends on the SpecialFeatures value of the AuctionItem being displayed. Si la valeur SpecialFeatures de AuctionItem est Color, l’élément a une bordure bleue.If the SpecialFeatures value of the AuctionItem is Color, the item has a blue border. Si la valeur est Highlight, l’élément a une bordure orange et une étoile.If the value is Highlight, the item has an orange border and a star. La section Modèles de données fournit des informations sur les modèles de données.The Data Templating section provides information about data templating.

  • L’utilisateur peut regrouper, filtrer ou trier les données à CheckBoxl’aide des es fournies.The user can group, filter, or sort the data using the CheckBoxes provided. Dans l’image ci-dessus, l’option «regrouper par catégorie» et «trier CheckBoxpar catégorie et date» sont sélectionnées.In the image above, the "Group by category" and "Sort by category and date" CheckBoxes are selected. Vous avez peut-être remarqué que les données sont regroupées en fonction de la catégorie de produit et que les noms de catégorie sont dans l’ordre alphabétique.You may have noticed that the data is grouped based on the category of the product, and the category name is in alphabetical order. Cela est difficile à observer sur l’image, mais les éléments sont également triés par date de début dans chaque catégorie.It is difficult to notice from the image but the items are also sorted by the start date within each category. Cette opération est effectuée à l’aide d’une vue de collection.This is done using a collection view. La section Lier à des collections traite des vues de collection.The Binding to Collections section discusses collection views.

  • Lorsque l’utilisateur sélectionne un élément, ContentControl affiche les détails de l’élément sélectionné.When the user selects an item, the ContentControl displays the details of the selected item. Il s’agit du Scénario maître/détail.This is called the Master-Detail scenario. La section Scénario maître/détail fournit des informations sur ce type de scénario de liaison.The Master-Detail Scenario section provides information about this type of binding scenario.

  • Le type de la propriété StartDate est DateTime, qui retourne une date qui comprend l’heure à la milliseconde.The type of the StartDate property is DateTime, which returns a date that includes the time to the millisecond. Dans cette application, un convertisseur personnalisé a été utilisé afin qu’une chaîne de date courte soit affichée.In this application, a custom converter has been used so that a shorter date string is displayed. La section Conversion de données fournit des informations sur les convertisseurs.The Data Conversion section provides information about converters.

Lorsque l’utilisateur clique sur le bouton Ajouter un produit, le formulaire suivant s’affiche :When the user clicks the Add Product button, the following form comes up:

Page Ajouter la liste de produitsAdd Product Listing page

L’utilisateur peut modifier les champs dans le formulaire, consulter la liste de produits à l’aide de l’aperçu court et des volets d’aperçu plus détaillés, puis cliquer sur Envoyer pour ajouter la nouvelle liste de produits.The user can edit the fields in the form, preview the product listing using the short preview and the more detailed preview panes, and then click submit to add the new product listing. Tout regroupement, filtrage ou tri existant sera appliqué à la nouvelle entrée.Any existing grouping, filtering and sorting functionalities will apply to the new entry. Dans ce cas particulier, l’élément entré dans l’image ci-dessus s’affichera comme deuxième élément dans la catégorie Computer.In this particular case, the item entered in the above image will be displayed as the second item within the Computer category.

La logique de validation fournie dans la Date TextBoxde début n’est pas illustrée dans cette image.Not shown in this image is the validation logic provided in the Start Date TextBox. Si l’utilisateur entre une date non valide (mise en forme non valide ou date passée), l’utilisateur est averti avec ToolTip un et un point TextBoxd’exclamation rouge à côté de.If the user enters an invalid date (invalid formatting or a past date), the user will be notified with a ToolTip and a red exclamation point next to the TextBox. La section Validation des données explique comment créer une logique de validation.The Data Validation section discusses how to create validation logic.

Avant d’aborder les différentes fonctionnalités de liaison de données décrites ci-dessus, nous couvrirons d’abord dans la section suivante les concepts fondamentaux qui sont critiques pour la compréhension de la liaison de données WPFWPF.Before going into the different features of data binding outlined above, we will first discuss in the next section the fundamental concepts that are critical to understanding WPFWPF data binding.

Concepts de liaison de données de baseBasic Data Binding Concepts

Quels que soient l’élément que vous liez et la nature de votre source de données, chaque liaison suit toujours le modèle illustré par l’illustration suivante :Regardless of what element you are binding and the nature of your data source, each binding always follows the model illustrated by the following figure:

Diagramme qui montre le modèle de liaison de données de base.

Comme présenté sur l’illustration ci-dessus, la liaison de données est essentiellement la passerelle entre votre cible de liaison et de votre source de liaison.As illustrated by the above figure, data binding is essentially the bridge between your binding target and your binding source. L’illustration présente les concepts de liaison de données WPFWPF essentiels suivants :The figure demonstrates the following fundamental WPFWPF data binding concepts:

  • En général, chaque liaison possède ces quatre composants : un objet de cible de liaison, une propriété cible, une source de liaison et un chemin vers la valeur de la source de liaison à utiliser.Typically, each binding has these four components: a binding target object, a target property, a binding source, and a path to the value in the binding source to use. Par exemple, si vous souhaitez lier le contenu d' TextBox un à la propriété Name d’un objet Employee , votre objet Target est le TextBox, la propriété Target est la Text propriété, la valeur à utiliser est Nameet le l’objet source est l’objet Employee.For example, if you want to bind the content of a TextBox to the Name property of an Employee object, your target object is the TextBox, the target property is the Text property, the value to use is Name, and the source object is the Employee object.

  • La propriété cible doit être une propriété de dépendance.The target property must be a dependency property. La UIElement plupart des propriétés sont des propriétés de dépendance et la plupart des propriétés de dépendance, à l’exception de celles en lecture seule, prennent en charge la liaison de données par défaut.Most UIElement properties are dependency properties and most dependency properties, except read-only ones, support data binding by default. (Seuls DependencyObject les types peuvent définir des propriétés de UIElementdépendance et tous DependencyObjectles dérivés de.)(Only DependencyObject types can define dependency properties and all UIElements derive from DependencyObject.)

  • Bien que cela ne soit pas spécifié dans la figure, il convient de noter que l’objet de source de liaison n’est pas limité à un objet CLR personnalisé.Although not specified in the figure, it should be noted that the binding source object is not restricted to being a custom CLR object. WPFWPFla liaison de données prend en charge les données sous la XMLXMLforme d’objets CLR et.data binding supports data in the form of CLR objects and XMLXML. Pour fournir quelques exemples, votre source de liaison peut être UIElementun, n’importe quel objet de liste, un objet CLR associé à des données ADO.net ou des services Web, ou un XMLXML XMLNode qui contient vos données.To provide some examples, your binding source may be a UIElement, any list object, a CLR object that is associated with ADO.NET data or Web Services, or an XmlNode that contains your XMLXML data. Pour plus d’informations, consultez Vue d’ensemble de la liaison de ressources.For more information, see Binding Sources Overview.

Lorsque vous parcourez les autres rubriques du kit de développement logiciel (SDK), il est important de se souvenir que lorsque vous établissez une liaison, vous liez une cible de liaison à une source de liaison.As you read through other SDK topics, it is important to remember that when you are establishing a binding, you are binding a binding target to a binding source. Par exemple, si vous affichez des données XMLXML sous-jacentes ListBox dans un à l’aide de la XMLXML liaison ListBox de données, vous liez votre aux données.For example, if you are displaying some underlying XMLXML data in a ListBox using data binding, you are binding your ListBox to the XMLXML data.

Pour établir une liaison, vous utilisez l' Binding objet.To establish a binding, you use the Binding object. Le reste de cette rubrique traite de la plupart des concepts associés à et de certaines des propriétés et de l’utilisation Binding de l’objet.The rest of this topic discusses many of the concepts associated with and some of the properties and usage of the Binding object.

Direction du flux de donnéesDirection of the Data Flow

Comme mentionné précédemment et comme indiqué par la flèche de la figure ci-dessus, le workflow d’une liaison peut passer de la cible de liaison à la source de liaison (par exemple, la valeur source change quand un utilisateur modifie la valeur TextBoxd’un) et/ou de la source de liaison à la cible de liaison (par exemple, TextBox votre contenu est mis à jour avec les modifications dans la source de liaison) si la source de liaison fournit les notifications appropriées.As mentioned previously and as indicated by the arrow in the figure above, the data flow of a binding can go from the binding target to the binding source (for example, the source value changes when a user edits the value of a TextBox) and/or from the binding source to the binding target (for example, your TextBox content gets updated with changes in the binding source) if the binding source provides the proper notifications.

Vous souhaiterez peut-être que votre application permette aux utilisateurs de modifier les données et les propager à nouveau vers l’objet source.You may want your application to enable users to change the data and propagate it back to the source object. Ou vous souhaitez peut-être ne pas permettre aux utilisateurs de mettre à jour la source de données.Or you may not want to enable users to update the source data. Vous pouvez contrôler cela en définissant Mode la propriété de Binding votre objet.You can control this by setting the Mode property of your Binding object. L’exemple suivant illustre les différents types de flux de données :The following figure illustrates the different types of data flow:

Flux de données de liaison de donnéesData binding data flow

  • OneWayla liaison entraîne la mise à jour automatique de la propriété cible par les modifications apportées à la propriété source, mais les modifications apportées à la propriété cible ne sont pas propagées vers la propriété source.OneWay binding causes changes to the source property to automatically update the target property, but changes to the target property are not propagated back to the source property. Ce type de liaison est approprié si le contrôle lié est implicitement en lecture seule.This type of binding is appropriate if the control being bound is implicitly read-only. Par exemple, vous pouvez lier à une source comme un affichage de cotations boursières, ou il se peut que votre propriété cible ne possède aucune interface de contrôle pour apporter des modifications, comme une couleur d’arrière-plan liée aux données d’une table.For instance, you may bind to a source such as a stock ticker or perhaps your target property has no control interface provided for making changes, such as a data-bound background color of a table. S’il n’est pas nécessaire de surveiller les modifications de la propriété cible, l’utilisation du mode de liaison OneWay permet d’éviter la surcharge du mode de liaison TwoWay.If there is no need to monitor the changes of the target property, using the OneWay binding mode avoids the overhead of the TwoWay binding mode.

  • TwoWayla liaison entraîne la mise à jour automatique de l’autre des modifications apportées à la propriété source ou à la propriété cible.TwoWay binding causes changes to either the source property or the target property to automatically update the other. Ce type de liaison convient aux formulaires modifiables ou à d’autres scénarios Interface utilisateurUI entièrement interactifs.This type of binding is appropriate for editable forms or other fully-interactive Interface utilisateurUI scenarios. La plupart des propriétés OneWay ont par défaut la liaison, mais certaines propriétés de dépendance (en général, les propriétés Text des contrôles modifiables par l’utilisateur, tels que la propriété de TextBox et la propriété de CheckBox) ont par défaut la IsChecked valeur TwoWay liaison.Most properties default to OneWay binding, but some dependency properties (typically properties of user-editable controls such as the Text property of TextBox and the IsChecked property of CheckBox) default to TwoWay binding. Un moyen de déterminer par programmation si une propriété de dépendance établit par défaut une liaison unidirectionnelle ou bidirectionnelle consiste à obtenir les métadonnées de la propriété à l’aide de GetMetadata, puis à vérifier la valeur booléenne de la propriété BindsTwoWayByDefault.A programmatic way to determine whether a dependency property binds one-way or two-way by default is to get the property metadata of the property using GetMetadata and then check the Boolean value of the BindsTwoWayByDefault property.

  • OneWayToSourceest l’inverse de OneWay la liaison; il met à jour la propriété source lorsque la propriété cible change.OneWayToSource is the reverse of OneWay binding; it updates the source property when the target property changes. Un exemple de scénario est si vous devez seulement réévaluer la valeur source à partir de Interface utilisateurUI.One example scenario is if you only need to re-evaluate the source value from the Interface utilisateurUI.

  • La liaison n’est OneTime pas illustrée dans la figure, ce qui amène la propriété source à initialiser la propriété cible, mais les modifications ultérieures ne se propagent pas.Not illustrated in the figure is OneTime binding, which causes the source property to initialize the target property, but subsequent changes do not propagate. Cela signifie que si le contexte de données subit une modification ou que l’objet dans le contexte des données change, la modification n'est pas répercutée dans la propriété cible.This means that if the data context undergoes a change or the object in the data context changes, then the change is not reflected in the target property. Ce type de liaison est approprié si vous utilisez des données réellement statiques ou qui se prêtent à l’utilisation d’un instantané de l’état actuel.This type of binding is appropriate if you are using data where either a snapshot of the current state is appropriate to use or the data is truly static. Ce type de liaison est également utile si vous souhaitez initialiser votre propriété cible avec une valeur d’une propriété source et que le contexte de données n’est pas connu à l’avance.This type of binding is also useful if you want to initialize your target property with some value from a source property and the data context is not known in advance. Il s’agit essentiellement d’une forme simplifiée de la liaison OneWay qui offre de meilleures performances dans les cas où la valeur source ne change pas.This is essentially a simpler form of OneWay binding that provides better performance in cases where the source value does not change.

Notez que pour détecter les modifications de la source OneWay ( TwoWay applicables aux liaisons et), la source doit implémenter un mécanisme de notification de INotifyPropertyChangedmodification de propriété approprié, tel que.Note that to detect source changes (applicable to OneWay and TwoWay bindings), the source must implement a suitable property change notification mechanism such as INotifyPropertyChanged. Pour obtenir un exemple d'implémentation INotifyPropertyChanged, consultez implémenter la notification de modification de propriété.See Implement Property Change Notification for an example of an INotifyPropertyChanged implementation.

La Mode page de propriétés fournit des informations supplémentaires sur les modes de liaison et un exemple de spécification de la direction d’une liaison.The Mode property page provides more information about binding modes and an example of how to specify the direction of a binding.

Ce qui déclenche les mises à jour de la sourceWhat Triggers Source Updates

Les liaisons qui sont TwoWay ou OneWayToSource écoutent les modifications dans la propriété cible et les propagent vers la source.Bindings that are TwoWay or OneWayToSource listen for changes in the target property and propagate them back to the source. On appelle cela la mise à jour de la source.This is known as updating the source. Par exemple, vous pouvez modifier le texte d’une zone de texte pour modifier la valeur source sous-jacente.For example, you may edit the text of a TextBox to change the underlying source value. Comme décrit dans la dernière section, la direction du workflow est déterminée par la valeur de la Mode propriété de la liaison.As described in the last section, the direction of the data flow is determined by the value of the Mode property of the binding.

Toutefois, est-ce que votre valeur source est mise à jour lorsque vous modifiez le texte ou après avoir fini de modifier le texte et pointé votre souris en dehors de la zone de texte ?However, does your source value get updated while you are editing the text or after you finish editing the text and point your mouse away from the TextBox? La UpdateSourceTrigger propriété de la liaison détermine ce qui déclenche la mise à jour de la source.The UpdateSourceTrigger property of the binding determines what triggers the update of the source. Les points des flèches droite de la figure suivante illustrent le rôle de la UpdateSourceTrigger propriété:The dots of the right arrows in the following figure illustrate the role of the UpdateSourceTrigger property:

Diagramme qui montre le rôle de la propriété UpdateSourceTrigger.

Si la UpdateSourceTrigger valeur est PropertyChanged, la valeur désignée par la flèche droite de TwoWay ou les OneWayToSource liaisons est mise à jour dès que la propriété cible est modifiée.If the UpdateSourceTrigger value is PropertyChanged, then the value pointed to by the right arrow of TwoWay or the OneWayToSource bindings gets updated as soon as the target property changes. Toutefois, si la UpdateSourceTrigger valeur est LostFocus, cette valeur est uniquement mise à jour avec la nouvelle valeur lorsque la propriété cible perd le focus.However, if the UpdateSourceTrigger value is LostFocus, then that value only gets updated with the new value when the target property loses focus.

Comme pour la Mode propriété, différentes propriétés de dépendance ont des UpdateSourceTrigger valeurs par défaut différentes.Similar to the Mode property, different dependency properties have different default UpdateSourceTrigger values. La valeur par défaut de la plupart des propriétés de dépendance est PropertyChanged, tandis que celle de la propriété Text a comme valeur par défaut LostFocus.The default value for most dependency properties is PropertyChanged, while the Text property has a default value of LostFocus. Cela signifie que les mises à jour de la source se produisent généralement chaque fois que la propriété cible CheckBoxchange, ce qui est parfait pour es et d’autres contrôles simples.This means that source updates usually happen whenever the target property changes, which is fine for CheckBoxes and other simple controls. Toutefois, pour les champs de texte, la mise à jour après chaque frappe de clavier peut réduire les performances et empêche l’utilisateur de revenir en arrière pour corriger les fautes de frappe avant de valider la nouvelle valeur.However, for text fields, updating after every keystroke can diminish performance and it denies the user the usual opportunity to backspace and fix typing errors before committing to the new value. C’est la raison Text pour laquelle la propriété a une LostFocus valeur par PropertyChangeddéfaut au lieu de.That is why the Text property has a default value of LostFocus instead of PropertyChanged.

Pour plus UpdateSourceTrigger d’informations sur la recherche de la valeur par défaut UpdateSourceTrigger d’une propriété de dépendance, consultez la page de propriétés.See the UpdateSourceTrigger property page for information about how to find the default UpdateSourceTrigger value of a dependency property.

Le tableau suivant fournit un exemple de scénario pour UpdateSourceTrigger chaque valeur à TextBox l’aide de la comme exemple:The following table provides an example scenario for each UpdateSourceTrigger value using the TextBox as an example:

Valeur UpdateSourceTriggerUpdateSourceTrigger value Quand la valeur source est mise à jourWhen the Source Value Gets Updated Exemple de scénario pour TextBoxExample Scenario for TextBox
LostFocus (valeur par TextBox.Textdéfaut pour)LostFocus (default for TextBox.Text) Lorsque le contrôle TextBox perd le focusWhen the TextBox control loses focus Qui TextBox est associé à la logique de validation (voir la section Validation des données)A TextBox that is associated with validation logic (see Data Validation section)
PropertyChangedPropertyChanged À mesure que vous tapez dans laTextBoxAs you type into the TextBox TextBoxcontrôles dans une fenêtre de salle de conversationTextBox controls in a chat room window
ExplicitExplicit Lorsque l’application appelleUpdateSourceWhen the application calls UpdateSource TextBoxcontrôles dans un formulaire modifiable (met à jour les valeurs sources uniquement lorsque l’utilisateur clique sur le bouton Envoyer)TextBox controls in an editable form (updates the source values only when the user clicks the submit button)

Pour un exemple, consultez Contrôler quand le texte TextBox met à jour la source.For an example, see Control When the TextBox Text Updates the Source.

Création d’une liaisonCreating a Binding

Pour récapituler certains des concepts abordés dans les sections précédentes, vous établissez une liaison à l' Binding aide de l’objet, et chaque liaison a généralement quatre composants: la cible de liaison, la propriété cible, la source de liaison et un chemin d’accès à la valeur source à utiliser.To recapitulate some of the concepts discussed in the previous sections, you establish a binding using the Binding object, and each binding usually has four components: binding target, target property, binding source, and a path to the source value to use. Cette section explique comment configurer une liaison.This section discusses how to set up a binding.

Prenons l’exemple suivant, dans lequel l’objet de source de liaison est une classe nommée MyData qui est définie dans l’espace de noms SDKSample.Consider the following example, in which the binding source object is a class named MyData that is defined in the SDKSample namespace. À des fins de démonstration, la classe MyData a une propriété de chaîne nommée ColorName, dont la valeur est définie sur « Rouge ».For demonstration purposes, MyData class has a string property named ColorName, of which the value is set to "Red". Par conséquent, cet exemple génère un bouton avec un arrière-plan rouge.Thus, this example generates a button with a red background.

<DockPanel
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:c="clr-namespace:SDKSample">
  <DockPanel.Resources>
    <c:MyData x:Key="myDataSource"/>
  </DockPanel.Resources>
  <DockPanel.DataContext>
    <Binding Source="{StaticResource myDataSource}"/>
  </DockPanel.DataContext>
  <Button Background="{Binding Path=ColorName}"
          Width="150" Height="30">I am bound to be RED!</Button>
</DockPanel>

Pour plus d’informations sur la syntaxe de déclaration de liaison et pour obtenir des exemples montrant comment définir une liaison dans le code, consultez Vue d'ensemble des déclarations de liaison.For more details on the binding declaration syntax and for examples of how to set up a binding in code, see Binding Declarations Overview.

Si nous appliquons cet exemple à notre diagramme de base, l’illustration qui en résulte ressemble à ce qui suit.If we apply this example to our basic diagram, the resulting figure looks like the following. Il s’agit OneWay d’une liaison, car la OneWay propriété Background prend en charge la liaison par défaut.This is a OneWay binding because the Background property supports OneWay binding by default.

Diagramme qui affiche la propriété d’arrière-plan de liaison de données.

Vous vous demandez peut-être pourquoi cela fonctionne même si la propriété colorname est de type Background chaîne alors que la Brushpropriété est de type.You may wonder why this works even though the ColorName property is of type string while the Background property is of type Brush. Il s’agit de la conversion de type par défaut en action, et nous l’évoquons dans la section Conversion de données.This is default type conversion at work and is discussed in the Data Conversion section.

Spécifier la source de liaisonSpecifying the Binding Source

Notez que dans l’exemple précédent, la source de liaison est spécifiée en définissant la DataContext propriété sur l' DockPanel élément.Notice that in the previous example, the binding source is specified by setting the DataContext property on the DockPanel element. Hérite Button DockPanelensuite de la valeurde,quiestDataContext son élément parent.The Button then inherits the DataContext value from the DockPanel, which is its parent element. Pour rappel, l’objet de source de liaison est un des quatre composants nécessaires d’une liaison.To reiterate, the binding source object is one of the four necessary components of a binding. Par conséquent, sans objet de source de liaison spécifié, la liaison ne fait rien.Therefore, without the binding source object being specified, the binding would do nothing.

Il existe plusieurs façons de spécifier l’objet de source de liaison.There are several ways to specify the binding source object. L’utilisation DataContext de la propriété sur un élément parent est utile lorsque vous liez plusieurs propriétés à la même source.Using the DataContext property on a parent element is useful when you are binding multiple properties to the same source. Cependant, il peut parfois être plus approprié de spécifier la source de liaison sur des déclarations de liaison individuelles.However, sometimes it may be more appropriate to specify the binding source on individual binding declarations. Pour l’exemple précédent, au lieu d’utiliser DataContext la propriété, vous pouvez spécifier la source de liaison en Source définissant la propriété directement sur la déclaration de liaison du bouton, comme dans l’exemple suivant:For the previous example, instead of using the DataContext property, you can specify the binding source by setting the Source property directly on the binding declaration of the button, as in the following example:

<DockPanel.Resources>
  <c:MyData x:Key="myDataSource"/>
</DockPanel.Resources>
<Button Width="150" Height="30"
        Background="{Binding Source={StaticResource myDataSource},
                             Path=ColorName}">I am bound to be RED!</Button>

En dehors de la DataContext définition directe de la propriété sur un élément, DataContext en héritant de la valeur d’un ancêtre (tel que le bouton dans le premier exemple) et en spécifiant explicitement Source la source de liaison en définissant la propriété sur Binding (tel que le bouton du dernier exemple), vous pouvez également utiliser la ElementName propriété ou la RelativeSource propriété pour spécifier la source de liaison.Other than setting the DataContext property on an element directly, inheriting the DataContext value from an ancestor (such as the button in the first example), and explicitly specifying the binding source by setting the Source property on the Binding (such as the button the last example), you can also use the ElementName property or the RelativeSource property to specify the binding source. La ElementName propriété est utile lorsque vous effectuez une liaison à d’autres éléments dans votre application, par exemple lorsque vous utilisez un curseur pour ajuster la largeur d’un bouton.The ElementName property is useful when you are binding to other elements in your application, such as when you are using a slider to adjust the width of a button. La RelativeSource propriété est utile lorsque la liaison est spécifiée dans un ControlTemplate ou un Style.The RelativeSource property is useful when the binding is specified in a ControlTemplate or a Style. Pour plus d’informations, consultez Spécifier la source de liaison.For more information, see Specify the Binding Source.

Spécification du chemin vers la valeurSpecifying the Path to the Value

Si votre source de liaison est un objet, vous utilisez Path la propriété pour spécifier la valeur à utiliser pour votre liaison.If your binding source is an object, you use the Path property to specify the value to use for your binding. Si vous effectuez une liaison XMLXML à des données, vous XPath utilisez la propriété pour spécifier la valeur.If you are binding to XMLXML data, you use the XPath property to specify the value. Dans certains cas, il peut s’avérer nécessaire d’utiliser Path la propriété même lorsque vos données XMLXMLsont.In some cases, it may be applicable to use the Path property even when your data is XMLXML. Par exemple, si vous souhaitez accéder à la propriété Name d’un XmlNode retourné (à la suite d’une requête XPath), vous devez utiliser la Path propriété en plus de la XPath propriété.For example, if you want to access the Name property of a returned XmlNode (as a result of an XPath query), you should use the Path property in addition to the XPath property.

Pour obtenir des informations de syntaxe et des Path exemples XPath , consultez les pages de propriétés et.For syntax information and examples, see the Path and XPath property pages.

Notez que, bien que nous ayons insisté Path sur le fait que la valeur à utiliser est l’un des quatre composants nécessaires d’une liaison, dans les scénarios que vous souhaitez lier à un objet entier, la valeur à utiliser serait la même que l’objet de source de liaison.Note that although we have emphasized that the Path to the value to use is one of the four necessary components of a binding, in the scenarios which you want to bind to an entire object, the value to use would be the same as the binding source object. Dans ce cas, il est applicable de ne pas spécifier Pathde.In those cases, it is applicable to not specify a Path. Prenons l'exemple suivant :Consider the following example:

<ListBox ItemsSource="{Binding}"
         IsSynchronizedWithCurrentItem="true"/>

L’exemple ci-dessus utilise la syntaxe de liaison vide : {Binding}.The above example uses the empty binding syntax: {Binding}. Dans ce cas, le ListBox hérite du DataContext d’un élément DockPanel parent (non illustré dans cet exemple).In this case, the ListBox inherits the DataContext from a parent DockPanel element (not shown in this example). Lorsque le chemin d’accès n’est pas spécifié, le comportement par défaut consiste à lier à l’objet entier.When the path is not specified, the default is to bind to the entire object. En d’autres termes, dans cet exemple, le chemin d’accès a été omis, car la ItemsSource propriété est liée à la totalité de l’objet.In other words, in this example, the path has been left out because we are binding the ItemsSource property to the entire object. (Voir la section Lier à des collections pour une discussion détaillée.)(See the Binding to Collections section for an in-depth discussion.)

En plus de la liaison à une collection, ce scénario est utile lorsque vous souhaitez lier un objet entier plutôt qu’une seule propriété d’un objet.Other than binding to a collection, this scenario is also useful when you want to bind to an entire object instead of just a single property of an object. Par exemple, si votre objet source est simplement de type chaîne et que vous souhaitez lier la chaîne elle-même.For example, if your source object is of type string and you simply want to bind to the string itself. Un autre scénario courant est lorsque vous souhaitez lier un élément à un objet avec plusieurs propriétés.Another common scenario is when you want to bind an element to an object with several properties.

Notez que vous devrez peut-être appliquer une logique personnalisée afin que les données soient significatives pour votre propriété cible liée aux données.Note that you may need to apply custom logic so that the data is meaningful to your bound target property. La logique personnalisée peut être sous la forme d’un convertisseur personnalisé (si la conversion de type par défaut n’existe pas).The custom logic may be in the form of a custom converter (if default type conversion does not exist). Consultez Conversion de données pour plus d’informations sur les convertisseurs.See Data Conversion for information about converters.

Binding et BindingExpressionBinding and BindingExpression

Avant d’entrer dans d’autres fonctionnalités et utilisations de la liaison de données, il serait utile d' BindingExpression introduire la classe.Before getting into other features and usages of data binding, it would be useful to introduce the BindingExpression class. Comme vous l’avez vu dans les sections précédentes Binding , la classe est la classe de haut niveau pour la déclaration d’une liaison Binding ; la classe fournit de nombreuses propriétés qui vous permettent de spécifier les caractéristiques d’une liaison.As you have seen in previous sections, the Binding class is the high-level class for the declaration of a binding; the Binding class provides many properties that allow you to specify the characteristics of a binding. Une classe connexe BindingExpression,, est l’objet sous-jacent qui gère la connexion entre la source et la cible.A related class, BindingExpression, is the underlying object that maintains the connection between the source and the target. Une liaison contient toutes les informations qui peuvent être partagées entre plusieurs expressions de liaison.A binding contains all the information that can be shared across several binding expressions. Un BindingExpression est une expression Bindingd’instance qui ne peut pas être partagée et qui contient toutes les informations d’instance de.A BindingExpression is an instance expression that cannot be shared and contains all the instance information of the Binding.

Par exemple, considérez les éléments suivants, où myDataObject est une instance de la classe MyData , myBinding est l’objet source Binding et la classe MyData est une classe définie qui contient une propriété de type chaîne nommée MyDataProperty.For example, consider the following, where myDataObject is an instance of MyData class, myBinding is the source Binding object, and MyData class is a defined class that contains a string property named MyDataProperty. Cet exemple lie le contenu de texte de mytext, une instance de TextBlock, à MyDataProperty.This example binds the text content of mytext, an instance of TextBlock, to MyDataProperty.

// Make a new source.
MyData myDataObject = new MyData(DateTime.Now);      
Binding myBinding = new Binding("MyDataProperty");
myBinding.Source = myDataObject;
// Bind the new data source to the myText TextBlock control's Text dependency property.
myText.SetBinding(TextBlock.TextProperty, myBinding);
' Make a new source.
Dim data1 As New MyData(DateTime.Now)
Dim binding1 As New Binding("MyDataProperty")
binding1.Source = data1
' Bind the new data source to the myText TextBlock control's Text dependency property.
Me.myText.SetBinding(TextBlock.TextProperty, binding1)

Vous pouvez utiliser le même objet myBinding pour créer d’autres liaisons.You can use the same myBinding object to create other bindings. Par exemple, vous pouvez utiliser l’objet myBinding pour lier le contenu textuel d’une case à cocher à MyDataProperty.For example, you may use myBinding object to bind the text content of a check box to MyDataProperty. Dans ce scénario, il y aura deux instances de BindingExpression partage de l’objet myBinding .In that scenario, there will be two instances of BindingExpression sharing the myBinding object.

Un BindingExpression objet peut être obtenu via la valeur de retour de GetBindingExpression l’appel de sur un objet lié aux données.A BindingExpression object can be obtained through the return value of calling GetBindingExpression on a data-bound object. Les rubriques suivantes montrent quelques-unes des utilisations de la BindingExpression classe:The following topics demonstrate some of the usages of the BindingExpression class:

Conversion de donnéesData Conversion

Dans l’exemple précédent, le bouton est rouge, car Background sa propriété est liée à une propriété de type chaîne avec la valeur «Red».In the previous example, the button is red because its Background property is bound to a string property with the value "Red". Cela fonctionne, car un convertisseur de type est présent Brush sur le type pour convertir la valeur Brushde chaîne en.This works because a type converter is present on the Brush type to convert the string value to a Brush.

Pour ajouter ces informations à l’illustration dans la section Création d’une liaison, le diagramme présente l’aspect suivant :To add this information to the figure in the Creating a Binding section, the diagram looks like the following:

Diagramme qui affiche la propriété de liaison de données par défaut.

Toutefois, que se passe-t-il si, au lieu d’avoir une propriété de type chaîne, votre Colorobjet de source de liaison a une propriété Color de type?However, what if instead of having a property of type string your binding source object has a Color property of type Color? Dans ce cas, pour que la liaison fonctionne, vous devez d’abord transformer la valeur de la propriété Color en un nom que Background la propriété accepte.In that case, in order for the binding to work you would need to first turn the Color property value into something that the Background property accepts. Vous devez créer un convertisseur personnalisé en implémentant l' IValueConverter interface, comme dans l’exemple suivant:You would need to create a custom converter by implementing the IValueConverter interface, as in the following example:

[ValueConversion(typeof(Color), typeof(SolidColorBrush))]
public class ColorBrushConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        Color color = (Color)value;
        return new SolidColorBrush(color);
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return null;
    }
}
<ValueConversion(GetType(Color), GetType(SolidColorBrush))>
Public Class ColorBrushConverter
    Implements IValueConverter
    Public Function Convert(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements IValueConverter.Convert
        Dim color As Color = CType(value, Color)
        Return New SolidColorBrush(color)
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetType As Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements IValueConverter.ConvertBack
        Return Nothing
    End Function
End Class

La IValueConverter page de référence fournit plus d’informations.The IValueConverter reference page provides more information.

Maintenant, le convertisseur personnalisé est utilisé au lieu de la conversion par défaut, et notre diagramme ressemble à ceci :Now the custom converter is used instead of default conversion, and our diagram looks like this:

Diagramme qui montre le convertisseur personnalisé de liaison de données.

Pour rappel, des conversions par défaut peuvent être disponibles si des convertisseurs de type sont présents dans le type lié.To reiterate, default conversions may be available because of type converters that are present in the type being bound to. Ce comportement dépendra des convertisseurs de type sont disponibles dans la cible.This behavior will depend on which type converters are available in the target. En cas de doute, créez votre propre convertisseur.If in doubt, create your own converter.

Voici quelques scénarios classiques où il est préférable d’implémenter un convertisseur de données :Following are some typical scenarios where it makes sense to implement a data converter:

  • Vos données devraient s’afficher différemment, selon la culture.Your data should be displayed differently, depending on culture. Par exemple, vous souhaitez peut-être implémenter un convertisseur de devise ou un convertisseur de date/heure de calendrier en fonction des valeurs ou des normes utilisées dans une culture particulière.For instance, you might want to implement a currency converter or a calendar date/time converter based on the values or standards used in a particular culture.

  • Les données utilisées ne sont pas nécessairement destinées à modifier la valeur du texte d’une propriété, mais plutôt à modifier une autre valeur, comme la source d’une image ou la couleur ou le style du texte affiché.The data being used is not necessarily intended to change the text value of a property, but is instead intended to change some other value, such as the source for an image, or the color or style of the display text. Les convertisseurs peuvent être utilisés ici en convertissant la liaison d’une propriété qui peut ne pas sembler appropriée, comme la liaison d’un champ de texte à la propriété Background d’une cellule de tableau.Converters can be used in this instance by converting the binding of a property that might not seem to be appropriate, such as binding a text field to the Background property of a table cell.

  • Plusieurs contrôles ou propriétés de contrôles sont liés aux mêmes données.More than one control or to multiple properties of controls are bound to the same data. Dans ce cas, la liaison principale peut afficher uniquement le texte, tandis que les autres liaisons gèrent des problèmes d’affichage spécifiques, mais utilisent toujours la même liaison comme informations source.In this case, the primary binding might just display the text, whereas other bindings handle specific display issues but still use the same binding as source information.

  • Jusqu’à présent, nous n’avons MultiBindingpas encore abordé, où une propriété cible a une collection de liaisons.So far we have not yet discussed MultiBinding, where a target property has a collection of bindings. Dans le cas d’un MultiBinding, vous utilisez un personnalisé IMultiValueConverter pour produire une valeur finale à partir des valeurs des liaisons.In the case of a MultiBinding, you use a custom IMultiValueConverter to produce a final value from the values of the bindings. Par exemple, la couleur peut être calculée à partir des valeurs rouge, vert et bleu, qui peuvent être des valeurs à partir d’objets de source de liaison identiques ou différents.For example, color may be computed from red, blue, and green values, which can be values from the same or different binding source objects. Pour obtenir MultiBinding des exemples et des informations, consultez la page de la classe.See the MultiBinding class page for examples and information.

Lier à des collectionsBinding to Collections

Un objet de source de liaison peut être traité comme un objet unique dont les propriétés contiennent des données, ou comme une collection de données d’objets polymorphiques souvent regroupées ensemble (par exemple, le résultat d’une requête sur une base de données).A binding source object can be treated either as a single object of which the properties contain data or as a data collection of polymorphic objects that are often grouped together (such as the result of a query to a database). Jusqu'à présent, nous avons seulement vu la liaison à des objets individuels, mais la liaison à une collection de données est un scénario courant.So far we've only discussed binding to single objects, however, binding to a data collection is a common scenario. Par exemple, un scénario courant consiste à utiliser un ItemsControl tel ListBoxque, ListViewou TreeView pour afficher une collection de données, par exemple dans l’application indiquée dans la section qu’est-ce que la liaison de données? .For example, a common scenario is to use an ItemsControl such as a ListBox, ListView, or TreeView to display a data collection, such as in the application shown in the What Is Data Binding? section.

Heureusement, notre diagramme de base est toujours applicable.Fortunately, our basic diagram still applies. Si vous liez un ItemsControl à une collection, le diagramme se présente comme suit:If you are binding an ItemsControl to a collection, the diagram looks like this:

Diagramme qui affiche l’objet ItemsControl de liaison de données.

Comme indiqué dans ce diagramme, pour lier un ItemsControl à un objet de collection ItemsSource , la propriété est la propriété à utiliser.As shown in this diagram, to bind an ItemsControl to a collection object, ItemsSource property is the property to use. Vous pouvez considérer ItemsSource la propriété comme le contenu ItemsControldu.You can think of ItemsSource property as the content of the ItemsControl. Notez que la liaison est OneWay due au ItemsSource fait que OneWay la propriété prend en charge la liaison par défaut.Note that the binding is OneWay because the ItemsSource property supports OneWay binding by default.

Guide d’implémentation des collectionsHow to Implement Collections

Vous pouvez énumérer n’importe quelle collection qui implémente IEnumerable l’interface.You can enumerate over any collection that implements the IEnumerable interface. Toutefois, pour configurer des liaisons dynamiques afin que les insertions ou les suppressions dans la collection Interface utilisateurUI mettent à jour automatiquement, la collection INotifyCollectionChanged doit implémenter l’interface.However, to set up dynamic bindings so that insertions or deletions in the collection update the Interface utilisateurUI automatically, the collection must implement the INotifyCollectionChanged interface. Cette interface expose un événement qui doit être déclenché chaque fois que la collection sous-jacente est modifiée.This interface exposes an event that should be raised whenever the underlying collection changes.

WPFWPFfournit la ObservableCollection<T> classe, qui est une implémentation intégrée d’une collection de données qui expose l' INotifyCollectionChanged interface.provides the ObservableCollection<T> class, which is a built-in implementation of a data collection that exposes the INotifyCollectionChanged interface. Notez que pour prendre entièrement en charge le transfert des valeurs de données des objets source vers les cibles, chaque objet de votre collection qui prend en INotifyPropertyChanged charge les propriétés pouvant être liées doit également implémenter l’interface.Note that to fully support transferring data values from source objects to targets, each object in your collection that supports bindable properties must also implement the INotifyPropertyChanged interface. Pour plus d’informations, consultez Vue d’ensemble de la liaison de ressources.For more information, see Binding Sources Overview.

Avant d’implémenter votre propre collection, ObservableCollection<T> envisagez d’utiliser ou une des classes de List<T>collection existantes, BindingList<T>telles que, Collection<T>et, parmi de nombreuses autres.Before implementing your own collection, consider using ObservableCollection<T> or one of the existing collection classes, such as List<T>, Collection<T>, and BindingList<T>, among many others. Si vous avez un scénario avancé et que vous souhaitez implémenter votre propre collection, IListenvisagez d’utiliser, qui fournit une collection non générique d’objets accessibles individuellement par index, et donc des performances optimales.If you have an advanced scenario and want to implement your own collection, consider using IList, which provides a non-generic collection of objects that can be individually accessed by index and thus the best performance.

Vues de collectionCollection Views

Une fois ItemsControl que votre est lié à une collection de données, vous souhaiterez peut-être Trier, filtrer ou regrouper les données.Once your ItemsControl is bound to a data collection, you may want to sort, filter, or group the data. Pour ce faire, vous utilisez des vues de collection, qui sont des classes ICollectionView qui implémentent l’interface.To do that, you use collection views, which are classes that implement the ICollectionView interface.

Que sont les vues de collection ?What Are Collection Views?

Une vue de collection est une couche sur une collection de sources de liaison qui vous permet de parcourir et d’afficher la collection source sur la base de requêtes de tri, de filtrage et de groupage, sans avoir à modifier la collection source sous-jacente elle-même.A collection view is a layer on top of a binding source collection that allows you to navigate and display the source collection based on sort, filter, and group queries, without having to change the underlying source collection itself. Une vue de collection maintient également un pointeur vers l’élément actuel dans la collection.A collection view also maintains a pointer to the current item in the collection. Si la collection source implémente l' INotifyCollectionChanged interface, les modifications déclenchées par CollectionChanged l’événement sont propagées aux vues.If the source collection implements the INotifyCollectionChanged interface, the changes raised by the CollectionChanged event are propagated to the views.

Étant donné que les vues ne modifient pas les collections source sous-jacentes, chaque collection source peut avoir plusieurs vues associées.Because views do not change the underlying source collections, each source collection can have multiple views associated with it. Par exemple, vous pouvez avoir une collection d’objets Task.For example, you may have a collection of Task objects. À l’aide de vues, vous pouvez afficher ces mêmes données de différentes façons.With the use of views, you can display that same data in different ways. Par exemple, sur le côté gauche de votre page, vous souhaitez peut-être afficher les tâches triées par priorité et, sur le côté droit, les regrouper par domaine.For example, on the left side of your page you may want to show tasks sorted by priority, and on the right side, grouped by area.

Guide de création d’une vueHow to Create a View

Un moyen de créer et utiliser une vue consiste à instancier l’objet de vue directement et de l’utiliser comme source de liaison.One way to create and use a view is to instantiate the view object directly and then use it as the binding source. Par exemple, considérez l’application Démonstration de liaison de données présentée dans la section Qu’est-ce que la liaison de données ?.For example, consider the Data Binding Demo application shown in the What Is Data Binding? section. L’application est implémentée de telle ListBox sorte que le lie à une vue sur la collection de données plutôt que directement à la collection de données.The application is implemented such that the ListBox binds to a view over the data collection instead of the data collection directly. L’exemple suivant est extrait de l’application Démonstration de liaison de données.The following example is extracted from the Data Binding Demo application. La CollectionViewSource classe est le langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) proxy d’une classe qui hérite de CollectionView.The CollectionViewSource class is the langage XAML (eXtensible Application Markup Language)Extensible Application Markup Language (XAML) proxy of a class that inherits from CollectionView. Dans cet exemple particulier, le Source de la vue est lié à la collection AuctionItems (de type ObservableCollection<T>) de l’objet d’application actuel.In this particular example, the Source of the view is bound to the AuctionItems collection (of type ObservableCollection<T>) of the current application object.

<Window.Resources>
<CollectionViewSource 
      Source="{Binding Source={x:Static Application.Current}, Path=AuctionItems}"   
      x:Key="listingDataView" />
</Window.Resources>

La ressource listingDataView sert ensuite de source de liaison pour les éléments de l’application, tels que ListBox:The resource listingDataView then serves as the binding source for elements in the application, such as the ListBox:

<ListBox Name="Master" Grid.Row="2" Grid.ColumnSpan="3" Margin="8"
    ItemsSource="{Binding Source={StaticResource listingDataView}}">
</ListBox>

Pour créer une autre vue pour la même collection, vous pouvez créer CollectionViewSource une autre instance et lui attribuer x:Key un nom différent.To create another view for the same collection, you can create another CollectionViewSource instance and give it a different x:Key name.

Le tableau suivant répertorie les types de données d’affichage qui sont créés en tant que CollectionViewSource vue de collection par défaut ou en fonction du type de collection source.The following table shows which view data types are created as the default collection view or by CollectionViewSource based on the source collection type.

Type de collection sourceSource collection type Type de vue de collectionCollection view type NotesNotes
IEnumerable Type interne basé surCollectionViewAn internal type based on CollectionView Impossible de grouper les éléments.Cannot group items.
IList ListCollectionView Le plus rapide.Fastest.
IBindingList BindingListCollectionView
Utilisation d’une vue par défautUsing a Default View

La spécification d’une vue de collection comme source de liaison est un moyen de créer et utiliser une vue de collection.Specifying a collection view as a binding source is one way to create and use a collection view. WPF crée également une vue de collection par défaut pour chaque collection utilisée comme source de liaison.WPF also creates a default collection view for every collection used as a binding source. Si vous liez directement à une collection, WPF crée une liaison sur sa vue par défaut.If you bind directly to a collection, WPF binds to its default view. Notez que cette vue par défaut est partagée par toutes les liaisons à la même collection, ainsi une modification apportée à une vue par défaut par un code ou contrôle lié (par exemple avec un tri ou une modification du pointeur d’élément actuel, dont nous parlons plus loin) se répercute dans toutes les autres liaisons à la même collection.Note that this default view is shared by all bindings to the same collection, so a change made to a default view by one bound control or code (such as sorting or a change to the current item pointer, discussed later) is reflected in all other bindings to the same collection.

Pour obtenir la vue par défaut, utilisez la GetDefaultView méthode.To get the default view, you use the GetDefaultView method. Pour un exemple, consultez Obtenir la vue par défaut d'une collection de données.For an example, see Get the Default View of a Data Collection.

Vues de collection avec ADO.NET DataTablesCollection Views with ADO.NET DataTables

Pour améliorer les performances, les vues de DataTable collection DataView pour les ADO.net ou les objets délèguent le tri et le DataViewfiltrage à.To improve performance, collection views for ADO.NET DataTable or DataView objects delegate sorting and filtering to the DataView. Cela entraîne le partage du tri et du filtrage sur toutes les vues de collection de la source de données.This causes sorting and filtering to be shared across all collection views of the data source. Pour permettre à chaque vue de collection de trier et filtrer indépendamment, initialisez chaque vue de collection DataView avec son propre objet.To enable each collection view to sort and filter independently, initialize each collection view with its own DataView object.

TriSorting

Comme mentionné précédemment, les vues peuvent appliquer un ordre de tri à une collection.As mentioned before, views can apply a sort order to a collection. Comme cela existe dans la collection sous-jacente, vos données peuvent avoir ou non un ordre inhérent pertinent.As it exists in the underlying collection, your data may or may not have a relevant, inherent order. La vue sur la collection vous permet d’imposer un ordre, ou de modifier l’ordre par défaut, en fonction de critères de comparaison que vous fournissez.The view over the collection allows you to impose an order, or change the default order, based on comparison criteria that you supply. Comme il s’agit d’une vue de données côté client, un scénario courant est que l’utilisateur peut souhaiter trier les colonnes des données tabulaires par la valeur à laquelle la colonne correspond.Because it is a client-based view of the data, a common scenario is that the user might want to sort columns of tabular data per the value that the column corresponds to. À l’aide de vues, ce tri défini par l’utilisateur peut être appliqué, à nouveau sans apporter de modifications à la collection sous-jacente ou même avoir à redemander le contenu de la collection.Using views, this user-driven sort can be applied, again without making any changes to the underlying collection or even having to requery for the collection content. Pour un exemple, consultez Trier une colonne GridView lors d'un clic sur un en-tête.For an example, see Sort a GridView Column When a Header Is Clicked.

L’exemple suivant illustre la logique de tri de la section «Trier par catégorie et CheckBox date» de Interface utilisateurUI l’application dans la section qu’est-ce que la liaison de données? :The following example shows the sorting logic of the "Sort by category and date" CheckBox of the application Interface utilisateurUI in the What Is Data Binding? section:

private void AddSorting(object sender, RoutedEventArgs args)
{
    // This sorts the items first by Category and within each Category,
    // by StartDate. Notice that because Category is an enumeration,
    // the order of the items is the same as in the enumeration declaration
    listingDataView.SortDescriptions.Add(
        new SortDescription("Category", ListSortDirection.Ascending));
    listingDataView.SortDescriptions.Add(
        new SortDescription("StartDate", ListSortDirection.Ascending));
}
Private Sub AddSorting(ByVal sender As Object, ByVal args As RoutedEventArgs)
    'This sorts the items first by Category and within each Category, by StartDate
    'Notice that because Category is an enumeration, the order of the items is the same as in the 
    'enumeration declaration
    listingDataView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))
    listingDataView.SortDescriptions.Add(New SortDescription("StartDate", ListSortDirection.Ascending))
End Sub

FiltrageFiltering

Les vues peuvent également appliquer un filtre à une collection.Views can also apply a filter to a collection. Cela signifie que même si un élément peut exister dans la collection, cette vue particulière est destinée à afficher uniquement un sous-ensemble spécifique de la collection complète.This means that although an item might exist in the collection, this particular view is intended to show only a certain subset of the full collection. Vous pouvez filtrer sur une condition dans les données.You might filter on a condition in the data. Par exemple, comme c’est le cas de l’application dans la section qu’est-ce que la liaison de données? , CheckBox le «afficher uniquement les bonnes affaires» contient une logique pour filtrer les éléments qui coûtent $25 ou plus.For instance, as is done by the application in the What Is Data Binding? section, the "Show only bargains" CheckBox contains logic to filter out items that cost $25 or more. Le code suivant est exécuté pour définir ShowOnlyBargainsFilter comme Filter gestionnaire d’événements lorsque cette CheckBox option est sélectionnée:The following code is executed to set ShowOnlyBargainsFilter as the Filter event handler when that CheckBox is selected:

listingDataView.Filter += new FilterEventHandler(ShowOnlyBargainsFilter);
AddHandler listingDataView.Filter, AddressOf ShowOnlyBargainsFilter

Le gestionnaire d’événements ShowOnlyBargainsFilter présente l’implémentation suivante :The ShowOnlyBargainsFilter event handler has the following implementation:

private void ShowOnlyBargainsFilter(object sender, FilterEventArgs e)
{
    AuctionItem product = e.Item as AuctionItem;
    if (product != null)
    {
        // Filter out products with price 25 or above
        if (product.CurrentPrice < 25)
        {
            e.Accepted = true;
        }
        else
        {
            e.Accepted = false;
        }
    }
}
Private Sub ShowOnlyBargainsFilter(ByVal sender As Object, ByVal e As FilterEventArgs)
    Dim product As AuctionItem = CType(e.Item, AuctionItem)
    If Not (product Is Nothing) Then
        'Filter out products with price 25 or above
        If product.CurrentPrice < 25 Then
            e.Accepted = True
        Else
            e.Accepted = False
        End If
    End If
End Sub

Si vous utilisez l’une des CollectionView classes directement au lieu de CollectionViewSource, vous pouvez utiliser la Filter propriété pour spécifier un rappel.If you are using one of the CollectionView classes directly instead of CollectionViewSource, you would use the Filter property to specify a callback. Pour obtenir un exemple, consultez Filtrer les données d'une vue.For an example, see Filter Data in a View.

RegroupementGrouping

À l’exception de la classe interne qui IEnumerable affiche une collection, toutes les vues de collection prennent en charge la fonctionnalité de regroupement, qui permet à l’utilisateur de partitionner la collection de la vue de collection en groupes logiques.Except for the internal class that views an IEnumerable collection, all collection views support the functionality of grouping, which allows the user to partition the collection in the collection view into logical groups. Les groupes peuvent être explicites, si l’utilisateur fournit une liste de groupes, ou implicites, si les groupes sont générés dynamiquement en fonction des données.The groups can be explicit, where the user supplies a list of groups, or implicit, where the groups are generated dynamically depending on the data.

L’exemple suivant illustre la logique de la «regrouper par CheckBoxcatégorie»:The following example shows the logic of the "Group by category" CheckBox:

// This groups the items in the view by the property "Category"
PropertyGroupDescription groupDescription = new PropertyGroupDescription();
groupDescription.PropertyName = "Category";
listingDataView.GroupDescriptions.Add(groupDescription);
'This groups by property "Category"
Dim groupDescription As PropertyGroupDescription = New PropertyGroupDescription
groupDescription.PropertyName = "Category"
listingDataView.GroupDescriptions.Add(groupDescription)

Pour un autre exemple de groupement, consultez Grouper des éléments dans un ListView implémentant un GridView.For another grouping example, see Group Items in a ListView That Implements a GridView.

Pointeurs d’élément actuelCurrent Item Pointers

Les vues prennent également en charge la notion d’élément actuel.Views also support the notion of a current item. Vous pouvez naviguer parmi les objets dans une vue de collection.You can navigate through the objects in a collection view. Lorsque vous naviguez, vous déplacez un pointeur d’élément qui vous permet de récupérer l’objet qui existe à cet emplacement précis de la collection.As you navigate, you are moving an item pointer that allows you to retrieve the object that exists at that particular location in the collection. Pour un exemple, consultez Naviguer dans les objets d'un CollectionView de données.For an example, see Navigate Through the Objects in a Data CollectionView.

Étant donné que WPF crée une liaison à une collection à l’aide d’une vue (une vue que vous spécifiez, ou la vue par défaut de la collection), toutes les liaisons à des collections ont un pointeur d’élément actuel.Because WPF binds to a collection only by using a view (either a view you specify, or the collection's default view), all bindings to collections have a current item pointer. Lors de la liaison à une vue, la barre oblique (« / ») dans une valeur Path désigne l’élément actuel de la vue.When binding to a view, the slash ("/") character in a Path value designates the current item of the view. Dans l’exemple suivant, le contexte de données est une vue de collection.In the following example, the data context is a collection view. La première ligne lie à la collection.The first line binds to the collection. La deuxième ligne lie à l’élément actuel dans la collection.The second line binds to the current item in the collection. La troisième ligne lie à la propriété Description de l’élément actuel dans la collection.The third line binds to the Description property of the current item in the collection.

<Button Content="{Binding }" />  
<Button Content="{Binding Path=/}" />  
<Button Content="{Binding Path=/Description}" />   

La syntaxe de barre oblique et de propriété peut également être empilée pour parcourir une hiérarchie de collections.The slash and property syntax can also be stacked to traverse a hierarchy of collections. L’exemple suivant lie l’élément actuel d’une collection nommée Offices, qui est une propriété de l’élément actuel de la collection source.The following example binds to the current item of a collection named Offices, which is a property of the current item of the source collection.

<Button Content="{Binding /Offices/}" />  

Le pointeur d’élément actuel peut être affecté par tout tri ou filtrage appliqué à la collection.The current item pointer can be affected by any sorting or filtering that is applied to the collection. Le tri conserve le pointeur d’élément actuel sur le dernier élément sélectionné, mais la vue de collection est désormais restructurée autour du tri.Sorting preserves the current item pointer on the last item selected, but the collection view is now restructured around it. (Par exemple, l’élément sélectionné était avant au début de la liste, mais il peut maintenant se trouver quelque part au milieu.) Le filtrage conserve l’élément sélectionné si cette sélection reste dans la vue après le filtrage.(Perhaps the selected item was at the beginning of the list before, but now the selected item might be somewhere in the middle.) Filtering preserves the selected item if that selection remains in view after the filtering. Sinon, le pointeur d’élément actuel est défini sur le premier élément de la vue de collection filtrée.Otherwise, the current item pointer is set to the first item of the filtered collection view.

Scénario de liaison maître/détailMaster-Detail Binding Scenario

La notion d’un élément actuel est utile non seulement pour le parcours d’éléments dans une collection, mais également pour le scénario de liaison maître/détail.The notion of a current item is useful not only for navigation of items in a collection, but also for the master-detail binding scenario. Considérez à nouveau l’application Interface utilisateurUI dans la section Qu’est-ce que la liaison de données ?.Consider the application Interface utilisateurUI in the What Is Data Binding? section again. Dans cette application, la sélection dans le ListBox détermine le contenu affiché dans le ContentControl.In that application, the selection within the ListBox determines the content shown in the ContentControl. Pour le placer d’une autre façon, lorsqu' ListBox un élément est sélectionné, ContentControl le affiche les détails de l’élément sélectionné.To put it in another way, when a ListBox item is selected, the ContentControl shows the details of the selected item.

Vous pouvez implémenter le scénario maître/détail simplement en ayant deux contrôles ou plus liés à la même vue.You can implement the master-detail scenario simply by having two or more controls bound to the same view. L’exemple suivant de la démonstration de la liaison de données montre le ListBox balisage ContentControl du et du que vous Interface utilisateurUI voyez sur l’application dans la section qu’est-ce que la liaison de données? :The following example from the Data Binding Demo shows the markup of the ListBox and the ContentControl you see on the application Interface utilisateurUI in the What Is Data Binding? section:

<ListBox Name="Master" Grid.Row="2" Grid.ColumnSpan="3" Margin="8"
    ItemsSource="{Binding Source={StaticResource listingDataView}}">
</ListBox>
<ContentControl Name="Detail" Grid.Row="3" Grid.ColumnSpan="3" 
        Content="{Binding Source={StaticResource listingDataView}}" 
        ContentTemplate="{StaticResource detailsProductListingTemplate}" 
        Margin="9,0,0,0"/>

Notez que les deux contrôles sont liés à la même source, la ressource statique listingDataView (voir la définition de cette ressource dans la section Guide de création d’une vue).Notice that both of the controls are bound to the same source, the listingDataView static resource (see the definition of this resource in the How to Create a View section). Cela fonctionne parce que lorsqu’un objet singleton ( ContentControl dans ce cas) est lié à une vue de collection, il est automatiquement lié à CurrentItem l’de la vue.This works because when a singleton object (the ContentControl in this case) is bound to a collection view, it automatically binds to the CurrentItem of the view. Notez que CollectionViewSource les objets synchronisent automatiquement la devise et la sélection.Note that CollectionViewSource objects automatically synchronize currency and selection. Si votre contrôle de liste n’est pas lié CollectionViewSource à un objet comme dans cet exemple, vous devez définir sa IsSynchronizedWithCurrentItem propriété sur true pour que cela fonctionne.If your list control is not bound to a CollectionViewSource object as in this example, then you would need to set its IsSynchronizedWithCurrentItem property to true for this to work.

Pour obtenir des exemples, consultez Effectuer une liaison à une collection et afficher des informations basées sur la sélection et Utiliser le modèle maître/détail avec des données hiérarchiques.For other examples, see Bind to a Collection and Display Information Based on Selection and Use the Master-Detail Pattern with Hierarchical Data.

Vous avez peut-être remarqué que l’exemple ci-dessus utilisait un modèle.You may have noticed that the above example uses a template. En fait, les données ne sont pas affichées comme nous le souhaitons sans l’utilisation de modèles (celui utilisé explicitement par le ContentControl et celui utilisé implicitement ListBoxpar).In fact, the data would not be displayed the way we wish without the use of templates (the one explicitly used by the ContentControl and the one implicitly used by the ListBox). Nous passons maintenant aux modèles de données dans la section suivante.We now turn to data templating in the next section.

Modèles de donnéesData Templating

Sans l’utilisation de modèles de données, notre application Interface utilisateurUI dans la section Qu’est-ce que la liaison de données ? se présente comme suit :Without the use of data templates, our application Interface utilisateurUI in the What Is Data Binding? section would look like the following:

Démo de liaison de données sans modèles de données

Comme indiqué dans l’exemple de la section précédente, le ListBox contrôle et le ContentControl sont liés à l’objet de collection entier (ou plus spécifiquement, la vue sur l’objet de collection) d' AuctionItems.As shown in the example in the previous section, both the ListBox control and the ContentControl are bound to the entire collection object (or more specifically, the view over the collection object) of AuctionItems. Sans instructions spécifiques sur l’affichage de la collection de données, ListBox le affiche une représentation sous forme de chaîne de chaque objet dans la collection ContentControl sous-jacente et le affiche une représentation sous forme de chaîne de l’objet auquel il est lié.Without specific instructions of how to display the data collection, the ListBox is displaying a string representation of each object in the underlying collection and the ContentControl is displaying a string representation of the object it is bound to.

Pour résoudre ce problème, l’application définit DataTemplates.To solve that problem, the application defines DataTemplates. Comme indiqué dans l’exemple de la section précédente, le ContentControl utilise explicitement detailsProductListingTemplateDataTemplate.As shown in the example in the previous section, the ContentControl explicitly uses the detailsProductListingTemplateDataTemplate. Le ListBox contrôle utilise implicitement les éléments DataTemplate suivants lors de l’affichage des objets AuctionItem dans la collection:The ListBox control implicitly uses the following DataTemplate when displaying the AuctionItem objects in the collection:

<DataTemplate DataType="{x:Type src:AuctionItem}">
    <Border BorderThickness="1" BorderBrush="Gray"
            Padding="7" Name="border" Margin="3" Width="500">
        <Grid>
          <Grid.RowDefinitions>
            <RowDefinition/>
            <RowDefinition/>
            <RowDefinition/>
            <RowDefinition/>
          </Grid.RowDefinitions>
          <Grid.ColumnDefinitions>
            <ColumnDefinition Width="20"/>
            <ColumnDefinition Width="86"/>
            <ColumnDefinition Width="*"/>
          </Grid.ColumnDefinitions>
              
            <Polygon Grid.Row="0" Grid.Column="0" Grid.RowSpan="4"
                     Fill="Yellow" Stroke="Black" StrokeThickness="1"
                     StrokeLineJoin="Round" Width="20" Height="20"
                     Stretch="Fill"
                     Points="9,2 11,7 17,7 12,10 14,15 9,12 4,15 6,10 1,7 7,7"
                     Visibility="Hidden" Name="star"/>

            <TextBlock Grid.Row="0" Grid.Column="1" Margin="0,0,8,0"
                       Name="descriptionTitle"
                       Style="{StaticResource smallTitleStyle}">Description:</TextBlock>
            <TextBlock Name="DescriptionDTDataType" Grid.Row="0" Grid.Column="2" 
                Text="{Binding Path=Description}" 
                Style="{StaticResource textStyleTextBlock}"/>

            <TextBlock Grid.Row="1" Grid.Column="1" Margin="0,0,8,0"
                       Name="currentPriceTitle"
                       Style="{StaticResource smallTitleStyle}">Current Price:</TextBlock>
            <StackPanel Grid.Row="1" Grid.Column="2" Orientation="Horizontal">
                <TextBlock Text="$" Style="{StaticResource textStyleTextBlock}"/>
                <TextBlock Name="CurrentPriceDTDataType" 
                    Text="{Binding Path=CurrentPrice}" 
                    Style="{StaticResource textStyleTextBlock}"/>
            </StackPanel>
        </Grid>
    </Border>
    <DataTemplate.Triggers>
        <DataTrigger Binding="{Binding Path=SpecialFeatures}">
            <DataTrigger.Value>
                <src:SpecialFeatures>Color</src:SpecialFeatures>
            </DataTrigger.Value>
          <DataTrigger.Setters>
            <Setter Property="BorderBrush" Value="DodgerBlue" TargetName="border" />
            <Setter Property="Foreground" Value="Navy" TargetName="descriptionTitle" />
            <Setter Property="Foreground" Value="Navy" TargetName="currentPriceTitle" />
            <Setter Property="BorderThickness" Value="3" TargetName="border" />
            <Setter Property="Padding" Value="5" TargetName="border" />
          </DataTrigger.Setters>
        </DataTrigger>
        <DataTrigger Binding="{Binding Path=SpecialFeatures}">
            <DataTrigger.Value>
                <src:SpecialFeatures>Highlight</src:SpecialFeatures>
            </DataTrigger.Value>
            <Setter Property="BorderBrush" Value="Orange" TargetName="border" />
            <Setter Property="Foreground" Value="Navy" TargetName="descriptionTitle" />
            <Setter Property="Foreground" Value="Navy" TargetName="currentPriceTitle" />
            <Setter Property="Visibility" Value="Visible" TargetName="star" />
            <Setter Property="BorderThickness" Value="3" TargetName="border" />
            <Setter Property="Padding" Value="5" TargetName="border" />
        </DataTrigger>
    </DataTemplate.Triggers>
</DataTemplate>

Avec l’utilisation de ces deux DataTemplate, l’interface utilisateur obtenue est celle qui est indiquée dans la section qu’est-ce que la liaison de données? .With the use of those two DataTemplates, the resulting UI is the one shown in the What Is Data Binding? section. Comme vous pouvez le voir dans cette capture d’écran, en plus de vous permettre de placer des DataTemplatedonnées dans vos contrôles, vous pouvez définir des visuels attrayants pour vos données.As you can see from that screenshot, in addition to letting you place data in your controls, DataTemplates allow you to define compelling visuals for your data. Par exemple, DataTriggerles objets sont utilisés dans les DataTemplate éléments ci-dessus afin que les s d’un reflet avec la valeur de mise en surbrillance de la valeur de mise en surbrillance apparaissent avec une bordure orange et une étoile.For example, DataTriggers are used in the above DataTemplate so that AuctionItems with SpecialFeatures value of HighLight would be displayed with an orange border and a star.

Pour plus d’informations sur les modèles de données, consultez Vue d’ensemble des modèles de données.For more information about data templates, see the Data Templating Overview.

Validation de donnéesData Validation

La plupart des applications qui acceptent l’entrée d’utilisateur doivent avoir une logique de validation pour vérifier que l’utilisateur a entré les informations attendues.Most applications that take user input need to have validation logic to ensure that the user has entered the expected information. Les contrôles de validation peuvent reposer sur un type, une plage, un format ou autres conditions requises spécifiques à l’application.The validation checks can be based on type, range, format, or other application-specific requirements. Cette section traite du fonctionnement de la validation des données dans le WPFWPF.This section discusses how data validation works in the WPFWPF.

Associer des règles de validation à une liaisonAssociating Validation Rules with a Binding

Le WPFWPF modèle de liaison de données vous permet ValidationRules d’associer Binding à votre objet.The WPFWPF data binding model allows you to associate ValidationRules with your Binding object. Par exemple, l’exemple suivant lie TextBox un à une propriété nommée StartPrice et ajoute un ExceptionValidationRule objet à la Binding.ValidationRules propriété.For example, the following example binds a TextBox to a property named StartPrice and adds a ExceptionValidationRule object to the Binding.ValidationRules property.

<TextBox Name="StartPriceEntryForm" Grid.Row="2" Grid.Column="1"
    Style="{StaticResource textStyleTextBox}" Margin="8,5,0,5">
  <TextBox.Text>
    <Binding Path="StartPrice" UpdateSourceTrigger="PropertyChanged">
      <Binding.ValidationRules>
        <ExceptionValidationRule />
      </Binding.ValidationRules>
    </Binding>
  </TextBox.Text>
</TextBox>

Un ValidationRule objet vérifie si la valeur d’une propriété est valide.A ValidationRule object checks whether the value of a property is valid. WPFWPFcontient les deux types d' ValidationRule objets intégrés suivants:has the following two types of built-in ValidationRule objects:

Vous pouvez également créer votre propre règle de validation en dérivant de la ValidationRule classe et en implémentant la Validate méthode.You can also create your own validation rule by deriving from the ValidationRule class and implementing the Validate method. L’exemple suivant illustre la règle utilisée par la liste ajouter un produit «date de TextBox début» de la section qu’est-ce que la liaison de données? :The following example shows the rule used by the Add Product Listing "Start Date" TextBox from the What Is Data Binding? section:

class FutureDateRule : ValidationRule
{
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        DateTime date;
        try
        {
            date = DateTime.Parse(value.ToString());
        }
        catch (FormatException)
        {
            return new ValidationResult(false, "Value is not a valid date.");
        }
        if (DateTime.Now.Date > date)
        {
            return new ValidationResult(false, "Please enter a date in the future.");
        }
        else
        {
            return ValidationResult.ValidResult;
        }
    }
}
Public Class FutureDateRule
    Inherits ValidationRule

    Public Overrides Function Validate(ByVal value As Object,
                                       ByVal cultureInfo As System.Globalization.CultureInfo) _
                                   As System.Windows.Controls.ValidationResult

        Dim DateVal As DateTime

        Try
            DateVal = DateTime.Parse(value.ToString)
        Catch ex As FormatException
            Return New ValidationResult(False, "Value is not a valid date.")
        End Try

        If DateTime.Now.Date > DateVal Then
            Return New ValidationResult(False, "Please enter a date in the future.")
        Else
            Return ValidationResult.ValidResult
        End If
    End Function
End Class

StartDateEntryFormTextBox utilise ce FutureDateRule, comme illustré dans l’exemple suivant:The StartDateEntryForm TextBox uses this FutureDateRule, as shown in the following example:

<TextBox Name="StartDateEntryForm" Grid.Row="3" Grid.Column="1" 
    Validation.ErrorTemplate="{StaticResource validationTemplate}" 
    Style="{StaticResource textStyleTextBox}" Margin="8,5,0,5">
    <TextBox.Text>
        <Binding Path="StartDate" UpdateSourceTrigger="PropertyChanged" 
            Converter="{StaticResource dateConverter}" >
            <Binding.ValidationRules>
                <src:FutureDateRule />
            </Binding.ValidationRules>
        </Binding>
    </TextBox.Text>
</TextBox>

Notez que, étant UpdateSourceTrigger donné que PropertyChangedla valeur est, le moteur de liaison met à jour la valeur source à chaque séquence de touches, ce qui signifie ValidationRules qu’il vérifie également chaque règle de la collection à chaque séquence de touches.Note that because the UpdateSourceTrigger value is PropertyChanged, the binding engine updates the source value on every keystroke, which means it also checks every rule in the ValidationRules collection on every keystroke. Nous reviendrons plus tard là-dessus dans la section Processus de validation.We discuss this further in the Validation Process section.

Fourniture de commentaires visuelsProviding Visual Feedback

Si l’utilisateur entre une valeur non valide, vous souhaiterez peut-être fournir des commentaires sur l’erreur sur l’application Interface utilisateurUI.If the user enters an invalid value, you may want to provide some feedback about the error on the application Interface utilisateurUI. Une façon de fournir ces commentaires consiste à définir la Validation.ErrorTemplate propriété jointe sur un ControlTemplatepersonnalisé.One way to provide such feedback is to set the Validation.ErrorTemplate attached property to a custom ControlTemplate. Comme indiqué dans la sous-section précédente, StartDateEntryForm TextBox utilise ErrorTemplate un validationTemplateappelé.As shown in the previous subsection, the StartDateEntryForm TextBox uses an ErrorTemplate called validationTemplate. L’exemple suivant montre la définition de validationTemplate :The following example shows the definition of validationTemplate:

<ControlTemplate x:Key="validationTemplate">
  <DockPanel>
    <TextBlock Foreground="Red" FontSize="20">!</TextBlock>
    <AdornedElementPlaceholder/>
  </DockPanel>
</ControlTemplate>

L' AdornedElementPlaceholder élément spécifie où le contrôle qui est orné doit être placé.The AdornedElementPlaceholder element specifies where the control being adorned should be placed.

En outre, vous pouvez également utiliser un ToolTip pour afficher le message d’erreur.In addition, you may also use a ToolTip to display the error message. StartDateEntryForm et StartPriceEntryFormTextBoxes utilisent le style textStyleTextBox, qui crée un qui affiche le ToolTip message d’erreur.Both the StartDateEntryForm and the StartPriceEntryFormTextBoxes use the style textStyleTextBox, which creates a ToolTip that displays the error message. L’exemple suivant montre la définition de textStyleTextBox.The following example shows the definition of textStyleTextBox. La propriété HasError jointe true est quand une ou plusieurs liaisons sur les propriétés de l’élément lié sont erronées.The attached property HasError is true when one or more of the bindings on the properties of the bound element are in error.

<Style x:Key="textStyleTextBox" TargetType="TextBox">
  <Setter Property="Foreground" Value="#333333" />
  <Setter Property="MaxLength" Value="40" />
  <Setter Property="Width" Value="392" />
  <Style.Triggers>
    <Trigger Property="Validation.HasError" Value="true">
      <Setter Property="ToolTip"
        Value="{Binding RelativeSource={RelativeSource Self},
                        Path=(Validation.Errors)[0].ErrorContent}"/>
    </Trigger>
  </Style.Triggers>
</Style>

Avec les ErrorTemplate TextBox et personnalisés, le StartDateEntryForm ressemble à ce qui suit lorsqu’il existe une erreur de validation: ToolTipWith the custom ErrorTemplate and the ToolTip, the StartDateEntryForm TextBox looks like the following when there is a validation error:

Erreur de validation de liaison de donnéesData binding validation error

Si votre Binding a des règles ErrorTemplate de validation associées mais que vous ne spécifiez pas de sur le contrôle ErrorTemplate lié, une valeur par défaut est utilisée pour avertir les utilisateurs en cas d’erreur de validation.If your Binding has associated validation rules but you do not specify an ErrorTemplate on the bound control, a default ErrorTemplate will be used to notify users when there is a validation error. La valeur ErrorTemplate par défaut est un modèle de contrôle qui définit une bordure rouge dans la couche d’ornement.The default ErrorTemplate is a control template that defines a red border in the adorner layer. Avec la valeur ErrorTemplate par défaut ToolTipet, Interface utilisateurUI le de l' StartPriceEntryForm TextBox ressemble à ce qui suit lorsqu’il existe une erreur de validation:With the default ErrorTemplate and the ToolTip, the Interface utilisateurUI of the StartPriceEntryForm TextBox looks like the following when there is a validation error:

Erreur de validation de liaison de donnéesData binding validation error

Pour obtenir un exemple montrant comment fournir une logique pour valider tous les contrôles dans une boîte de dialogue, consultez la section Boîtes de dialogue personnalisées dans Vue d'ensemble des boîtes de dialogue.For an example of how to provide logic to validate all controls in a dialog box, see the Custom Dialog Boxes section in the Dialog Boxes Overview.

Processus de validationValidation Process

La validation se produit généralement lorsque la valeur d’une cible est transférée à la propriété de source de liaison.Validation usually occurs when the value of a target is transferred to the binding source property. Cela se produit TwoWay sur OneWayToSource les liaisons et.This occurs on TwoWay and OneWayToSource bindings. Pour une réitération, ce qui provoque la mise à jour d’une source UpdateSourceTrigger dépend de la valeur de la propriété, comme décrit dans la section qu’est-ce qui déclenche les mises à jour de la source.To reiterate, what causes a source update depends on the value of the UpdateSourceTrigger property, as described in the What Triggers Source Updates section.

La section suivante décrit le processus de validation.The following describes the validation process. Notez que si une erreur de validation ou un autre type d’erreur se produit à tout moment au cours de ce processus, le processus est interrompu.Note that if a validation error or other type of error occurs at any time during this process, the process is halted.

  1. Le moteur de liaison vérifie s’il existe des ValidationRule objets personnalisés ValidationStep définis pour RawProposedValue lesquels a la valeur Bindingpour ce, auquel cas il appelle Validate la méthode sur ValidationRule chacune d’elles jusqu’à ce que l’une d’entre elles s’exécute dans une erreur. ou jusqu’à ce qu’elles soient toutes passées.The binding engine checks if there are any custom ValidationRule objects defined whose ValidationStep is set to RawProposedValue for that Binding, in which case it calls the Validate method on each ValidationRule until one of them runs into an error or until all of them pass.

  2. Le moteur de liaison appelle alors le convertisseur, s’il en existe un.The binding engine then calls the converter, if one exists.

  3. Si le convertisseur est correctement exécuté, le moteur de liaison vérifie s’il existe ValidationRule des objets personnalisés ValidationStep définis dont a ConvertedProposedValue la valeur Bindingpour ce, auquel cas il appelle Validate la méthode sur ValidationRule chaque qui a affectezlavaleurjusqu’àcequel’uned’elless’exécuteenerreuroujusqu’àcequ’ellessoienttoutespassées.ValidationStep ConvertedProposedValueIf the converter succeeds, the binding engine checks if there are any custom ValidationRule objects defined whose ValidationStep is set to ConvertedProposedValue for that Binding, in which case it calls the Validate method on each ValidationRule that has ValidationStep set to ConvertedProposedValue until one of them runs into an error or until all of them pass.

  4. Le moteur de liaison définit la propriété source.The binding engine sets the source property.

  5. Le moteur de liaison vérifie s’il existe des ValidationRule objets personnalisés ValidationStep définis pour lesquels a UpdatedValue la valeur Bindingpour ce, auquel cas il appelle Validate la méthode sur ValidationRule chaque dont ValidationStep a affecté la valeur UpdatedValue jusqu’à ce que l’un d’eux s’exécute dans une erreur ou jusqu’à ce qu’ils soient tous réussis.The binding engine checks if there are any custom ValidationRule objects defined whose ValidationStep is set to UpdatedValue for that Binding, in which case it calls the Validate method on each ValidationRule that has ValidationStep set to UpdatedValue until one of them runs into an error or until all of them pass. Si un DataErrorValidationRule est associé à une liaison ValidationStep et que a DataErrorValidationRule la valeur par défaut, UpdatedValue, est vérifié à ce stade.If a DataErrorValidationRule is associated with a binding and its ValidationStep is set to the default, UpdatedValue, the DataErrorValidationRule is checked at this point. C’est également le moment où les liaisons qui ont la ValidatesOnDataErrors true valeur sont vérifiées.This is also the point when bindings that have the ValidatesOnDataErrors set to true are checked.

  6. Le moteur de liaison vérifie s’il existe des ValidationRule objets personnalisés ValidationStep définis pour lesquels a CommittedValue la valeur Bindingpour ce, auquel cas il appelle Validate la méthode sur ValidationRule chaque dont ValidationStep a affecté la valeur CommittedValue jusqu’à ce que l’un d’eux s’exécute dans une erreur ou jusqu’à ce qu’ils soient tous réussis.The binding engine checks if there are any custom ValidationRule objects defined whose ValidationStep is set to CommittedValue for that Binding, in which case it calls the Validate method on each ValidationRule that has ValidationStep set to CommittedValue until one of them runs into an error or until all of them pass.

Si un ValidationRule ne passe pas à un moment donné dans le cadre de ce processus, le ValidationError moteur de liaison crée un objet Errors et l’ajoute à la collection de l’élément lié.If a ValidationRule does not pass at any time throughout this process, the binding engine creates a ValidationError object and adds it to the Errors collection of the bound element. Avant que le moteur de liaison ValidationRule n’exécute les objets à une étape donnée, ValidationError il supprime tous ceux qui Errors ont été ajoutés à la propriété jointe de l’élément lié pendant cette étape.Before the binding engine runs the ValidationRule objects at any given step, it removes any ValidationError that was added to the Errors attached property of the bound element during that step. Par exemple, si a ValidationRule ValidationStep ayant la valeur UpdatedValue failed, la prochaine fois que le processus de validation se produit, le ValidationRule moteur ValidationError de liaison supprime immédiatement celui qui a ValidationStep défini sur UpdatedValue.For example, if a ValidationRule whose ValidationStep is set to UpdatedValue failed, the next time the validation process occurs, the binding engine removes that ValidationError immediately before it calls any ValidationRule that has ValidationStep set to UpdatedValue.

Lorsque Errors n’est pas vide, HasError la propriété jointe de truel’élément a la valeur.When Errors is not empty, the HasError attached property of the element is set to true. En outre, si NotifyOnValidationError la propriété Binding du a la valeur true, le moteur de liaison déclenche l' Validation.Error événement attaché sur l’élément.Also, if the NotifyOnValidationError property of the Binding is set to true, then the binding engine raises the Validation.Error attached event on the element.

Notez également qu’un transfert de valeur valide dans l’une ou l’autre direction (cible vers source ou source vers Errors cible) efface la propriété jointe.Also note that a valid value transfer in either direction (target to source or source to target) clears the Errors attached property.

Si la liaison est associée à ExceptionValidationRule une liaison ou si la propriété a ValidatesOnExceptions la valeur true et qu’une exception est levée lorsque le moteur de liaison définit la source, le moteur de liaison vérifie s’il existe un UpdateSourceExceptionFilter.If the binding either has an ExceptionValidationRule associated with it, or had the ValidatesOnExceptions property is set to true and an exception is thrown when the binding engine sets the source, the binding engine checks to see if there is a UpdateSourceExceptionFilter. Vous avez la possibilité d’utiliser le UpdateSourceExceptionFilter rappel pour fournir un gestionnaire personnalisé pour la gestion des exceptions.You have the option to use the UpdateSourceExceptionFilter callback to provide a custom handler for handling exceptions. Si un UpdateSourceExceptionFilter n’est pas spécifié Bindingsur, le moteur de liaison crée ValidationError un avec l’exception et l’ajoute à Errors la collection de l’élément lié.If an UpdateSourceExceptionFilter is not specified on the Binding, the binding engine creates a ValidationError with the exception and adds it to the Errors collection of the bound element.

Mécanisme de débogageDebugging Mechanism

Vous pouvez définir la propriété TraceLevel jointe sur un objet lié à la liaison pour recevoir des informations sur l’état d’une liaison spécifique.You can set the attached property TraceLevel on a binding-related object to receive information about the status of a specific binding.

Voir aussiSee also