Vue d’ensemble de Windows Presentation Foundation

Bienvenue dans le Guide de bureau pour Windows Presentation Foundation (WPF), une infrastructure d’interface utilisateur indépendante de la résolution et qui utilise un moteur de rendu basé sur des vecteurs, conçue pour tirer parti du matériel graphique moderne. WPF fournit un ensemble complet de fonctionnalités de développement d’applications qui incluent le langage XAML (Extensible Application Markup Language), les contrôles, la liaison de données, la disposition, les graphiques 2D et 3D, l’animation, les styles, les modèles, les documents, les supports, le texte et la typographie. WPF fait partie de .NET : vous pouvez donc créer des applications qui incorporent d’autres éléments de l’API .NET.

Il existe deux implémentations de WPF :

1. Version .NET (ce guide) :

   Implémentation open source de WPF hébergée sur GitHub, qui s’exécute sur .NET. Le concepteur XAML nécessite, au minimum, Visual Studio 2019 version 16.8. Toutefois, selon votre version de .NET, vous devrez peut-être utiliser une version plus récente de Visual Studio.

   Même si .NET est une technologie multiplateforme, WPF s’exécute uniquement sur Windows.

2. Version de .NET Framework 4 :

   Implémentation de .NET Framework de WPF prise en charge par Visual Studio 2019 et Visual Studio 2017.

   .NET Framework 4 est une version Windows uniquement de .NET et est considéré comme un composant du système d’exploitation Windows. Cette version de WPF est distribuée avec .NET Framework.

Cette vue d’ensemble est destinée aux nouveaux arrivants et couvre les principales fonctionnalités et concepts de WPF. Pour savoir comment créer une application WPF, consultez Tutoriel : Créer une application WPF.

Pourquoi mettre à niveau à partir de .NET Framework

Lorsque vous mettez à niveau votre application de .NET Framework vers .NET, vous bénéficiez des avantages suivants :

• Meilleures performances
• Nouvelles API .NET
• Dernières améliorations du langage
• Amélioration de l’accessibilité et de la fiabilité
• Outils mis à jour et bien plus encore

Pour savoir comment mettre à niveau votre application, consultez Comment mettre à niveau une application de bureau WPF vers .NET.

Programme avec WPF

WPF existe en tant que sous-ensemble de types .NET principalement situés dans l'espace de noms System.Windows. Si vous avez déjà créé des applications avec .NET à l'aide de frameworks tels que ASP.NET et Windows Forms, l'expérience fondamentale de programmation avec WPF vous sera familière.

• Instancier des classes
• Définir des propriétés
• Méthodes d’appel
• Gérer les événements

WPF inclut des constructions de programmation supplémentaires qui améliorent les propriétés et les événements : propriétés de dépendance et événements routés.

Balisage et code-behind

WPF vous permet de développer une application en utilisant à la fois le balisage et le code associé, une expérience avec laquelle les développeurs ASP.NET devraient être familiers. Vous utilisez généralement le balisage XAML pour implémenter l’apparence d’une application lors de l’utilisation de langages de programmation managés (code-behind) pour implémenter son comportement. Cette séparation de l’apparence et du comportement présente les avantages suivants :

• Les coûts de développement et de maintenance sont réduits, car le balisage spécifique à l’apparence n’est pas étroitement couplé au code spécifique au comportement.

• Le développement est plus efficace, car les concepteurs peuvent implémenter l’apparence d’une application simultanément avec les développeurs qui implémentent le comportement de l’application.

• La globalisation et la localisation pour les applications WPF sont simplifiées.

balisage

XAML est un langage de balisage XML qui implémente l’apparence d’une application de manière déclarative. Vous l’utilisez généralement pour définir des fenêtres, des boîtes de dialogue, des pages et des contrôles utilisateur, et pour les remplir avec des contrôles, des formes et des graphiques.

L’exemple suivant utilise XAML pour implémenter l’apparence d’une fenêtre qui contient un seul bouton :

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button">Click Me!</Button>

</Window>

Plus précisément, ce code XAML définit une fenêtre et un bouton à l'aide des éléments Window et Button. Chaque élément est configuré avec des attributs, tels que l’attribut Title de l’élément Window pour spécifier le texte de la barre de titre de la fenêtre. Au moment de l’exécution, WPF convertit les éléments et les attributs définis dans le balisage en instances de classes WPF. Par exemple, l’élément Window est converti en instance de la classe dont Title la Window propriété est la valeur de l’attributTitle.

La figure suivante montre l’interface utilisateur définie par le code XAML dans l’exemple précédent :

Étant donné que XAML est basé sur XML, l’interface utilisateur avec laquelle vous composez est assemblée dans une hiérarchie d’éléments imbriqués appelé arborescence d’éléments. L’arborescence d’éléments offre un moyen logique et intuitif de créer et de gérer des interfaces utilisateur.

Code-behind

Le comportement principal d’une application consiste à implémenter les fonctionnalités qui répondent aux interactions utilisateur. Par exemple, en cliquant sur un menu ou un bouton, et en appelant la logique métier et la logique d’accès aux données en réponse. Dans WPF, ce comportement est implémenté dans le code associé au balisage. Ce type de code est appelé code-behind. L’exemple suivant montre le balisage mis à jour de l’exemple précédent et le code-behind :

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.AWindow"
    Title="Window with button"
    Width="250" Height="100">

  <!-- Add button to window -->
  <Button Name="button" Click="button_Click">Click Me!</Button>

</Window>

Le balisage mis à jour définit l'espace de noms xmlns:x et l'associe au schéma qui ajoute la prise en charge des types de code associé. L’attribut x:Class est utilisé pour associer une classe code-behind à ce balisage XAML spécifique. Étant donné que cet attribut est déclaré sur l’élément <Window> , la classe code-behind doit hériter de la Window classe.

using System.Windows;

namespace SDKSample
{
    public partial class AWindow : Window
    {
        public AWindow()
        {
            // InitializeComponent call is required to merge the UI
            // that is defined in markup with this class, including  
            // setting properties and registering event handlers
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            // Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!");
        }
    }
}

Namespace SDKSample

    Partial Public Class AWindow
        Inherits System.Windows.Window

        Public Sub New()

            ' InitializeComponent call is required to merge the UI
            ' that is defined in markup with this class, including  
            ' setting properties and registering event handlers
            InitializeComponent()

        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)

            ' Show message box when button is clicked.
            MessageBox.Show("Hello, Windows Presentation Foundation!")

        End Sub

    End Class

End Namespace

InitializeComponent est appelé à partir du constructeur de la classe code-behind pour fusionner l’interface utilisateur définie dans le balisage avec la classe code-behind. (InitializeComponent est généré pour vous lorsque votre application est générée, c’est pourquoi vous n’avez pas besoin de l’implémenter manuellement.) La combinaison de x:Class et InitializeComponent assurent que votre implémentation est correctement initialisée chaque fois qu’elle est créée.

Notez que dans le balisage, l’élément <Button> a défini une valeur de button_Click l’attribut Click . Avec le balisage et le code-behind initialisés et fonctionnant ensemble, l’événement Click du bouton est automatiquement mappé à la button_Click méthode. Lorsque le bouton est cliqué, le gestionnaire d’événements est appelé et une boîte de message s’affiche en appelant la System.Windows.MessageBox.Show méthode.

La figure suivante montre le résultat lorsque le bouton est cliqué :

Entrées et commandes

Les contrôles détectent et répondent le plus souvent aux entrées utilisateur. Le système d’entrée WPF utilise des événements directs et routés pour prendre en charge l’entrée de texte, la gestion du focus et le positionnement de la souris.

Les applications ont souvent des exigences d’entrée complexes. WPF fournit un système de commandes qui sépare les actions d’entrée utilisateur du code qui répond à ces actions. Le système de commandes permet à plusieurs sources d’appeler la même logique de commande. Par exemple, prenez les opérations courantes d’édition utilisées par différentes applications : Copier, Couper et Coller. Ces opérations peuvent être appelées à l’aide de différentes actions utilisateur si elles sont implémentées à l’aide de commandes.

Contrôles

Les expériences utilisateur fournies par le modèle d’application sont des contrôles construits. Dans WPF, le contrôle est un terme parapluie qui s’applique à une catégorie de classes WPF qui ont les caractéristiques suivantes :

• Hébergé dans une fenêtre ou une page.
• Avoir une interface utilisateur.
• Implémentez un comportement.

Pour plus d’informations, consultez Contrôles.

Contrôles WPF par fonction

Les contrôles WPF intégrés sont répertoriés ici :

• Boutons : Button et RepeatButton.

• Affichage des données : DataGrid, ListViewet TreeView.

• Affichage et sélection de la date : Calendar et DatePicker.

• Boîtes de dialogue : OpenFileDialog, PrintDialoget SaveFileDialog.

• Encre numérique : InkCanvas et InkPresenter.

• Documents : DocumentViewer, FlowDocumentPageViewer, FlowDocumentReader, FlowDocumentScrollViewer, et StickyNoteControl.

• Entrée : TextBox, RichTextBoxet PasswordBox.

• Disposition : Border, BulletDecorator, Canvas, DockPanel, Expander, Grid, GridView, GridSplitter, GroupBox, Panel, ResizeGrip, Separator, ScrollBar, ScrollViewer, StackPanel, Thumb, Viewbox, VirtualizingStackPanel, Window et WrapPanel.

• Média : Image, MediaElementet SoundPlayerAction.

• Menus : ContextMenu, Menuet ToolBar.

• Navigation : Frame, , Hyperlink, NavigationWindowPage, et TabControl.

• Sélection : CheckBox, , ComboBox, RadioButtonListBox, et Slider.

• Informations utilisateur : AccessText, , PopupLabel, ProgressBar, StatusBar, TextBlocket ToolTip.

Mise en page

Lorsque vous créez une interface utilisateur, vous organisez vos contrôles par emplacement et par taille pour former une disposition. Une condition essentielle de toute disposition consiste à s’adapter aux modifications apportées à la taille de la fenêtre et aux paramètres d’affichage. Plutôt que de vous forcer à écrire le code pour adapter une disposition dans ces circonstances, WPF fournit un système de disposition extensible de première classe pour vous.

La pierre angulaire du système de disposition est le positionnement relatif, ce qui augmente la capacité à s’adapter à la modification des conditions de fenêtre et d’affichage. Le système de disposition gère également la négociation entre les contrôles pour déterminer la disposition. La négociation est un processus en deux étapes : tout d’abord, un contrôle indique à son parent l’emplacement et la taille dont il a besoin. Deuxièmement, le parent indique au contrôle l’espace qu’il peut avoir.

Le système de disposition est exposé aux contrôles enfants par le biais de classes WPF de base. Pour les dispositions courantes telles que les grilles, l’empilement et l’ancrage, WPF inclut plusieurs contrôles de disposition :

• Canvas: Les éléments enfants fournissent leur propre mise en page.

• DockPanel: Les contrôles enfant sont alignés sur les bords du panneau.

• Grid: Les contrôles enfants sont positionnés par des lignes et des colonnes.

• StackPanel: Les contrôles enfants sont disposés soit verticalement, soit horizontalement.

• VirtualizingStackPanel: les contrôles des enfants sont virtualisés et alignés sur une seule ligne, soit horizontalement, soit verticalement.

• WrapPanel: les contrôles enfants sont positionnés dans l’ordre de gauche à droite et encapsulés à la ligne suivante lorsqu’il n’y a pas suffisamment d’espace sur la ligne actuelle.

L’exemple suivant utilise un DockPanel pour disposer plusieurs TextBox contrôles :

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.LayoutWindow"
    Title="Layout with the DockPanel" Height="143" Width="319">

  <!--DockPanel to layout four text boxes-->
  <DockPanel>
    <TextBox DockPanel.Dock="Top">Dock = "Top"</TextBox>
    <TextBox DockPanel.Dock="Bottom">Dock = "Bottom"</TextBox>
    <TextBox DockPanel.Dock="Left">Dock = "Left"</TextBox>
    <TextBox Background="White">This TextBox "fills" the remaining space.</TextBox>
  </DockPanel>

</Window>

Le DockPanel permet aux contrôles enfants TextBox de préciser comment ils doivent être organisés. Pour ce faire, le DockPanel implémente une propriété jointe Dock qui est exposée aux contrôles enfants pour leur permettre de spécifier un style d’ancrage.

Remarque

Une propriété implémentée par un contrôle parent à utiliser par les contrôles enfants est une construction WPF appelée propriété jointe.

La figure suivante montre le résultat du balisage XAML dans l’exemple précédent :

Liaison de données

La plupart des applications sont créées pour fournir aux utilisateurs les moyens d’afficher et de modifier les données. Pour les applications WPF, le travail de stockage et d’accès aux données est déjà fourni par de nombreuses bibliothèques d’accès aux données .NET différentes telles que SQL et Entity Framework Core. Une fois les données accessibles et chargées dans les objets managés d’une application, le travail dur pour les applications WPF commence. Essentiellement, cela implique deux choses :

1. Copie des données à partir des objets managés dans des contrôles, où les données peuvent être affichées et modifiées.

2. S’assurer que les modifications apportées aux données à l’aide de contrôles sont copiées vers les objets managés.

Pour simplifier le développement d’applications, WPF fournit un puissant moteur de liaison de données pour gérer automatiquement ces étapes. L’unité principale du moteur de liaison de données est la classe, dont le Binding travail consiste à lier un contrôle (la cible de liaison) à un objet de données (la source de liaison). Cette relation est illustrée par la figure suivante :

WPF prend en charge la déclaration de liaisons directement dans le balisage XAML. Par exemple, le code XAML suivant lie la Text propriété de l’objet TextBox à la Name propriété d’un objet à l’aide de la syntaxe XAML «{Binding ... } ». Il est supposé qu'un objet de données est affecté à la propriété DataContext de l'objet Window, lequel possède une propriété Name.

<Window
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:Class="SDKSample.DataBindingWindow">

   <!-- Bind the TextBox to the data source (TextBox.Text to Person.Name) -->
   <TextBox Name="personNameTextBox" Text="{Binding Path=Name}" />

</Window>

Le moteur de liaison de données WPF fournit plus que simplement la liaison, il fournit la validation, le tri, le filtrage et le regroupement. En outre, la liaison de données prend en charge l’utilisation de modèles de données pour créer une interface utilisateur personnalisée pour les données liées.

Pour plus d’informations, consultez vue d’ensemble de la liaison de données.

Graphiques &animation

WPF offre un ensemble complet et flexible de fonctionnalités graphiques qui présentent les avantages suivants :

• Graphiques indépendants de la résolution et indépendants de l’appareil. L’unité de mesure de base dans le système graphique WPF est le pixel indépendant de l’appareil, qui est de 1/96e de pouce et fournit la base du rendu indépendant de la résolution et de l’appareil. Chaque pixel indépendant de l’appareil est automatiquement mis à l’échelle pour correspondre au paramètre points par pouce (ppp) du système sur lequel il s’affiche.

• Précision améliorée. Le système de coordonnées WPF est mesuré avec des nombres à virgule flottante double précision plutôt qu'avec une précision simple. Les transformations et les valeurs d’opacité sont également exprimées sous forme de double précision. WPF prend également en charge un large éventail de couleurs (scRGB) et fournit une prise en charge intégrée de la gestion des entrées à partir de différents espaces de couleurs.

• Prise en charge avancée des graphismes et des animations. WPF simplifie la programmation graphique en gérant les scènes d’animation pour vous ; Il n’est pas nécessaire de vous soucier du traitement des scènes, des boucles de rendu et de l’interpolation biligne. En outre, WPF fournit une prise en charge des tests de positionnement et une prise en charge complète de la composition alpha.

• Accélération matérielle. Le système graphique WPF tire parti du matériel graphique pour réduire l’utilisation du processeur.

Graphisme 2D

WPF fournit une bibliothèque de formes 2D courantes, telles que les rectangles et les ellipses. Les formes ne sont pas uniquement destinées à l’affichage ; Les formes implémentent de nombreuses fonctionnalités attendues par les contrôles, notamment l’entrée du clavier et de la souris.

Les formes 2D fournies par WPF couvrent l’ensemble standard de formes de base. Toutefois, vous devrez peut-être créer des formes personnalisées pour faciliter la conception d’une interface utilisateur personnalisée. WPF fournit des géométries pour créer une forme personnalisée qui peut être dessinée directement, utilisée comme pinceau ou utilisée pour découper d’autres formes et contrôles.

Pour plus d’informations, consultez vue d’ensemble de Geometry.

Un sous-ensemble de fonctionnalités WPF 2D comprend des effets visuels, tels que les dégradés, les bitmaps, les dessins, l'application de vidéos, la rotation, la mise à l'échelle et l'inclinaison. Ces effets sont tous obtenus avec des pinceaux. La figure suivante présente quelques exemples :

Pour plus d’informations, consultez vue d’ensemble des pinceaux WPF.

Rendu 3D

WPF inclut également des fonctionnalités de rendu 3D qui s’intègrent à des graphiques 2D pour permettre la création d’interfaces utilisateur plus excitantes et intéressantes. Par exemple, la figure suivante montre les images 2D rendues sur des formes 3D :

Pour plus d’informations, consultez la vue d’ensemble des graphiques 3D.

Animation

La prise en charge des animations WPF vous permet de faire croître, secouer, tourner et s'estomper des contrôles pour créer des transitions de page intéressantes. Vous pouvez animer la plupart des classes WPF, même des classes personnalisées. La figure suivante montre une animation simple en action :

Pour plus d’informations, consultez Vue d’ensemble de l’animation.

Texte et typographie

Pour fournir un rendu de texte de haute qualité, WPF offre les fonctionnalités suivantes :

• Prise en charge des polices OpenType.
• Améliorations de ClearType.
• Hautes performances qui tirent parti de l’accélération matérielle.
• Intégration de texte avec des médias, des graphiques et des animations.
• Prise en charge des polices internationales et mécanismes de repli.

Comme démonstration de l’intégration de texte avec des graphiques, la figure suivante montre l’application de décorations de texte :

Pour plus d’informations, consultez Typographie dans Windows Presentation Foundation.

Personnaliser des applications WPF

Jusqu’à ce stade, vous avez vu les blocs de construction WPF principaux pour le développement d’applications :

• Vous utilisez le modèle d’application pour héberger et fournir du contenu d’application, qui se compose principalement de contrôles.
• Pour simplifier la disposition des contrôles dans une interface utilisateur, vous utilisez le système de disposition WPF.
• Vous utilisez la liaison de données pour réduire le travail d’intégration de votre interface utilisateur avec des données.
• Pour améliorer l’apparence visuelle de votre application, vous utilisez la gamme complète de graphismes, d’animations et de support multimédia fournis par WPF.

Souvent, cependant, les principes de base ne sont pas suffisants pour créer et gérer une expérience utilisateur vraiment distincte et visuellement étonnante. Les contrôles WPF standard peuvent ne pas s’intégrer à l’apparence souhaitée de votre application. Les données peuvent ne pas être affichées de la manière la plus efficace. L’expérience utilisateur globale de votre application peut ne pas être adaptée à l’apparence par défaut des thèmes Windows.

Pour cette raison, WPF fournit différents mécanismes pour créer des expériences utilisateur uniques.

Modèle de contenu

L’objectif principal de la plupart des contrôles WPF est d’afficher du contenu. Dans WPF, le type et le nombre d’éléments qui peuvent constituer le contenu d’un contrôle est appelé modèle de contenu du contrôle. Certains contrôles peuvent contenir un seul élément et un type de contenu. Par exemple, le contenu d’une TextBox chaîne est une valeur de chaîne affectée à la Text propriété.

Toutefois, d’autres contrôles peuvent contenir plusieurs éléments de différents types de contenu ; le contenu d’un Buttonélément spécifié par la Content propriété peut contenir différents éléments, notamment les contrôles de disposition, le texte, les images et les formes.

Pour plus d’informations sur les types de contenu pris en charge par différents contrôles, consultez le modèle de contenu WPF.

Déclencheurs

Bien que l’objectif principal du balisage XAML soit d’implémenter l’apparence d’une application, vous pouvez également utiliser XAML pour implémenter certains aspects du comportement d’une application. L’un des exemples est l’utilisation de déclencheurs pour modifier l’apparence d’une application en fonction des interactions utilisateur. Pour plus d’informations, consultez Styles et modèles.

Modèles

Les interfaces utilisateur par défaut pour les contrôles WPF sont généralement construites à partir d’autres contrôles et formes. Par exemple, un Button est composé à la fois de contrôles ButtonChrome et de contrôles ContentPresenter. Le ButtonChrome fournit l'apparence standard du bouton, tandis que le ContentPresenter affiche le contenu du bouton, comme spécifié par la propriété Content.

Parfois, l’apparence par défaut d’un contrôle peut entrer en conflit avec l’apparence globale d’une application. Dans ce cas, vous pouvez utiliser un ControlTemplate pour modifier l’apparence de l’interface utilisateur du contrôle sans modifier son contenu et son comportement.

Par exemple, un Button déclenche l'événement Click lorsque vous cliquez dessus. En modifiant le modèle d’un bouton pour afficher une Ellipse forme, le visuel de l’aspect du contrôle a changé, mais la fonctionnalité n’a pas changé. Vous pouvez toujours cliquer sur l’aspect visuel du contrôle et l’événement Click est déclenché comme prévu.

Modèles de données

Alors qu’un modèle de contrôle vous permet de spécifier l’apparence d’un contrôle, un modèle de données vous permet de spécifier l’apparence du contenu d’un contrôle. Les modèles de données sont fréquemment utilisés pour améliorer l’affichage des données liées. La figure suivante montre l’apparence par défaut d’un ListBox objet lié à une collection d’objets Task , où chaque tâche a un nom, une description et une priorité :

L’apparence par défaut est ce que vous attendez d’un ListBox. Toutefois, l’apparence par défaut de chaque tâche contient uniquement le nom de la tâche. Pour afficher le nom, la description et la priorité de la ListBox tâche, l’apparence par défaut des éléments de liste liés du contrôle doit être modifiée à l’aide d’un DataTemplate. Voici un exemple d’application d’un modèle de données créé pour l’objet Task .

ListBox conserve son comportement ainsi que son apparence générale ; seule l’apparence du contenu affiché par la boîte de liste a changé.

Pour plus d’informations, consultez vue d’ensemble des modèles de données.

Styles

Les styles permettent aux développeurs et aux concepteurs de normaliser une apparence particulière pour leur produit. WPF fournit un modèle de style fort, dont la base est l’élément Style . Les styles peuvent appliquer des valeurs de propriété aux types. Elles peuvent être appliquées automatiquement à tout en fonction du type ou des objets individuels lorsqu’ils sont référencés. Chaque élément Button de la fenêtre aura sa couleur d’arrière-plan définie à Orange selon le style créé par l’exemple suivant.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.StyleWindow"
    Title="Styles">

    <Window.Resources>
        <!-- Style that will be applied to all buttons for this window -->
        <Style TargetType="{x:Type Button}">
            <Setter Property="Background" Value="Orange" />
            <Setter Property="BorderBrush" Value="Crimson" />
            <Setter Property="FontSize" Value="20" />
            <Setter Property="FontWeight" Value="Bold" />
            <Setter Property="Margin" Value="5" />
        </Style>
    </Window.Resources>
    <StackPanel>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>

        <!-- This label will not have the style applied to it -->
        <Label>Don't Click Me!</Label>

        <!-- This button will have the style applied to it -->
        <Button>Click Me!</Button>

    </StackPanel>
</Window>

Étant donné que ce style cible tous les Button contrôles, le style est automatiquement appliqué à tous les boutons de la fenêtre, comme illustré dans la figure suivante :

Pour plus d’informations, consultez Styles et modèles.

Ressources

Les contrôles d'une application doivent partager la même apparence, ce qui peut inclure tout, depuis les polices et les couleurs d'arrière-plan jusqu'aux modèles de contrôles, modèles de données et styles. Vous pouvez utiliser la prise en charge de WPF pour les ressources d’interface utilisateur afin d’encapsuler ces ressources dans un emplacement unique pour la réutilisation.

L’exemple suivant définit une couleur d’arrière-plan commune partagée par un Button et un Label.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.ResourcesWindow"
    Title="Resources Window">

  <!-- Define window-scoped background color resource -->
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>

  <!-- Button background is defined by window-scoped resource -->
  <Button Background="{StaticResource defaultBackground}">One Button</Button>

  <!-- Label background is defined by window-scoped resource -->
  <Label Background="{StaticResource defaultBackground}">One Label</Label>
</Window>

Pour plus d’informations, consultez Comment définir et référencer une ressource WPF.

Contrôles personnalisés

Bien que WPF fournit une foule de prise en charge de la personnalisation, vous pouvez rencontrer des situations où les contrôles WPF existants ne répondent pas aux besoins de votre application ou de ses utilisateurs. Cela peut se produire lorsque :

• L’interface utilisateur dont vous avez besoin ne peut pas être créée en personnalisant l’apparence des implémentations WPF existantes.
• Le comportement dont vous avez besoin n’est pas pris en charge (ou pas facilement pris en charge) par les implémentations WPF existantes.

À ce stade, toutefois, vous pouvez tirer parti de l’un des trois modèles WPF pour créer un contrôle. Chaque modèle cible un scénario spécifique et nécessite que votre contrôle personnalisé dérive d’une classe de base WPF particulière. Les trois modèles sont répertoriés ici :

• Modèle de contrôle utilisateur
  Un contrôle personnalisé dérive de UserControl et est composé d’un ou de plusieurs autres contrôles.

• Modèle de contrôle Un contrôle personnalisé dérive de Control, et est utilisé pour créer des implémentations qui séparent leur comportement de leur apparence à l'aide de gabarits, tout comme la plupart des contrôles WPF. La dérivation de Control vous offre plus de liberté pour créer une interface utilisateur personnalisée qu'avec des contrôles utilisateurs, mais cela peut nécessiter plus d'efforts.

• Modèle d’élément Framework.
  Un contrôle personnalisé dérive de FrameworkElement lorsque son apparence est définie par une logique de rendu personnalisée (plutôt que par des modèles).

Pour plus d’informations sur les contrôles personnalisés, consultez vue d’ensemble de la création de contrôles.

Voir aussi

• Tutoriel : Créer une application WPF
• Migrer une application WPF vers .NET
• Vue d’ensemble des fenêtres WPF
• Vue d’ensemble de la liaison de données
• Vue d’ensemble XAML