Vue d’ensemble des fenêtres WPF

2025-05-07

Les utilisateurs interagissent avec les applications WPF (Windows Presentation Foundation) via Windows. L’objectif principal d’une fenêtre est d’héberger du contenu qui visualise les données et permet aux utilisateurs d’interagir avec les données. Les applications WPF fournissent leurs propres fenêtres à l’aide de la Window classe. Cet article présente Window avant de couvrir les principes fondamentaux de la création et de la gestion de fenêtres dans les applications.

Important

Cet article utilise le code XAML généré à partir d’un projet C# . Si vous utilisez Visual Basic, le code XAML peut sembler légèrement différent. Ces différences sont généralement présentes sur les valeurs d’attribut x:Class. C# inclut l’espace de noms racine du projet alors que Visual Basic ne le fait pas.

Les modèles de projet pour C# créent un App type contenu dans le fichier app.xaml . Dans Visual Basic, le type est nommé Application et le fichier est nommé Application.xaml.

Classe Fenêtre

Dans WPF, une fenêtre est encapsulée par la Window classe que vous utilisez pour effectuer les opérations suivantes :

Afficher une fenêtre.
Configurez la taille, la position et l’apparence d’une fenêtre.
Héberger du contenu spécifique à l’application.
Gérer la durée de vie d’une fenêtre.

La figure suivante illustre les parties constituantes d’une fenêtre :

Capture d’écran montrant des parties d’une fenêtre WPF.

Une fenêtre est divisée en deux zones : la zone non cliente et la zone cliente.

La zone non cliente d’une fenêtre est implémentée par WPF et inclut les parties d’une fenêtre qui sont communes à la plupart des fenêtres, notamment les suivantes :

Barre de titre (1 à 5).
Icône (1).
Titre (2).
Boutons Réduire (3), Agrandir (4) et Fermer (5).
Menu système (6) avec des éléments de menu. S’affiche lorsque vous cliquez sur l’icône (1).
Bordure (7).

La zone cliente d’une fenêtre est la zone située dans la zone non cliente d’une fenêtre et est utilisée par les développeurs pour ajouter du contenu spécifique à l’application, comme les barres de menus, les barres d’outils et les contrôles.

Zone cliente (8).
Redimensionner la poignée (9). Il s’agit d’un contrôle ajouté à la zone Client (8).

Implémentation d’une fenêtre

L’implémentation d’une fenêtre classique inclut à la fois l’apparence et le comportement, où l’apparence définit l’apparence d’une fenêtre aux utilisateurs et le comportement définit la façon dont une fenêtre fonctionne à mesure que les utilisateurs interagissent avec elle. Dans WPF, vous pouvez implémenter l’apparence et le comportement d’une fenêtre à l’aide du code ou du balisage XAML.

En général, toutefois, l’apparence d’une fenêtre est implémentée à l’aide du balisage XAML et son comportement est implémenté à l’aide du code-behind, comme illustré dans l’exemple suivant.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

</Window>

Le code suivant est le code-behind du XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}

Public Class Window1

End Class

Pour permettre à un fichier de balisage XAML et un fichier code-behind de fonctionner ensemble, les éléments suivants sont requis :

Dans le balisage, l’élément Window doit inclure l’attribut x:Class . Lorsque l’application est générée, l’existence d’un x:Class attribut entraîne la génération d’une partial classe dérivée du Window nom spécifié par l’attribut x:Class du moteur de build Microsoft (MSBuild). Cela nécessite l’ajout d’une déclaration d’espace de noms XML pour le schéma XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). La classe générée partial implémente la InitializeComponent méthode, appelée pour inscrire les événements et définir les propriétés implémentées dans le balisage.
Dans code-behind, la classe doit être une partial classe portant le même nom que celui spécifié par l’attribut dans le x:Class balisage, et elle doit dériver de Window. Cela permet au fichier code-behind d’être associé à la partial classe générée pour le fichier de balisage lorsque l’application est générée, pour plus d’informations, consultez Compiler une application WPF.
Dans code-behind, la Window classe doit implémenter un constructeur qui appelle la InitializeComponent méthode. InitializeComponent est implémenté par la classe générée partial par le fichier de balisage pour inscrire des événements et définir des propriétés définies dans le balisage.

Remarque

Lorsque vous ajoutez un nouvel élément Window à votre projet à l’aide de Visual Studio, celui-ci Window est implémenté à l’aide à la fois du balisage et du code-behind, et inclut la configuration nécessaire pour créer l’association entre les fichiers de balisage et de code-behind, comme décrit ici.

Avec cette configuration en place, vous pouvez vous concentrer sur la définition de l’apparence de la fenêtre dans le balisage XAML et l’implémentation de son comportement dans code-behind. L’exemple suivant montre une fenêtre avec un bouton qui définit un gestionnaire d’événements pour l’événement Click . Cela est implémenté dans le code XAML et le gestionnaire est implémenté dans code-behind.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

    <Button Click="Button_Click">Click This Button</Button>

</Window>

Le code suivant est le code-behind du XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Public Class Window1

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MessageBox.Show("Button was clicked.")
    End Sub

End Class

Configuration d’une fenêtre pour MSBuild

La façon dont vous implémentez votre fenêtre détermine comment elle est configurée pour MSBuild. Pour une fenêtre définie à l’aide du balisage XAML et du code-behind :

Les fichiers de balisage XAML sont configurés en tant qu’éléments MSBuild Page .
Les fichiers code-behind sont configurés en tant qu’éléments MSBuild Compile .

Les projets du Kit de développement logiciel (SDK) .NET importent automatiquement les éléments appropriés Page et Compile vous n’avez pas besoin de les déclarer. Lorsque le projet est configuré pour WPF, les fichiers de balisage XAML sont automatiquement importés en tant qu’éléments Page , et le fichier code-behind correspondant est importé en tant que Compile.

Les projets MSBuild n’importent pas automatiquement les types et vous devez les déclarer vous-même :

<Project>
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Pour plus d’informations sur la création d’applications WPF, consultez Compiler une application WPF.

Durée de vie de la fenêtre

Comme pour n’importe quelle classe, une fenêtre a une durée de vie qui commence lorsqu’elle est instanciée pour la première fois, après laquelle elle est ouverte, activée/désactivée et finalement fermée.

Ouverture d’une fenêtre

Pour ouvrir une fenêtre, vous créez d’abord une instance de celle-ci, qui est illustrée dans l’exemple suivant :

using System.Windows;

namespace WindowsOverview
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Create the window
            Window1 window = new Window1();

            // Open the window
            window.Show();
        }
    }
}

Class Application

    Private Sub Application_Startup(sender As Object, e As StartupEventArgs)
        ' Create the window
        Dim window As New Window1

        ' Open the window
        window.Show()
    End Sub

End Class

Dans cet exemple Window1 , il est instancié au démarrage de l’application, qui se produit lorsque l’événement Startup est déclenché. Pour plus d’informations sur la fenêtre de démarrage, consultez Comment obtenir ou définir la fenêtre d’application principale.

Lorsqu’une fenêtre est instanciée, une référence à celle-ci est automatiquement ajoutée à une liste de fenêtres gérées par l’objet Application . La première fenêtre à instancier est automatiquement définie comme Application fenêtre d’application principale.

La fenêtre est enfin ouverte en appelant la Show méthode comme indiqué dans l’image suivante :

Une fenêtre ouverte en appelant Show est une fenêtre sans mode et l’application n’empêche pas les utilisateurs d’interagir avec d’autres fenêtres de l’application. L’ouverture d’une fenêtre avec ShowDialog ouvre une fenêtre en tant que modale et limite l’interaction utilisateur à la fenêtre spécifique. Pour plus d’informations, consultez Vue d’ensemble des boîtes de dialogue.

Lors de l'appel de Show, une fenêtre effectue un travail d'initialisation avant de s'afficher pour établir l'infrastructure qui lui permet de recevoir les saisies par l'utilisateur. Lorsque la fenêtre est initialisée, l’événement SourceInitialized est déclenché et la fenêtre s’affiche.

Pour plus d’informations, consultez Comment ouvrir une fenêtre ou une boîte de dialogue.

Fenêtre de démarrage

L’exemple précédent a utilisé l’événement Startup afin d'exécuter du code pour afficher la fenêtre d’application initiale. En guise de raccourci, utilisez StartupUri plutôt pour spécifier le chemin d’accès à un fichier XAML dans votre application. L’application crée et affiche automatiquement la fenêtre spécifiée par cette propriété.

<Application x:Class="WindowsOverview.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WindowsOverview"
             StartupUri="ClippedWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

Propriété de fenêtre

Une fenêtre ouverte à l’aide de la Show méthode n’a pas de relation implicite avec la fenêtre qui l’a créée. Les utilisateurs peuvent interagir avec l’une ou l’autre fenêtre indépendamment de l’autre, ce qui signifie que l’une ou l’autre fenêtre peut effectuer les opérations suivantes :

Couvrez l’autre (sauf si l’une des fenêtres a sa Topmost propriété définie sur true).
Être réduit, agrandi et restauré sans affecter l’autre.

Certaines fenêtres nécessitent une relation avec la fenêtre qui les ouvre. Par exemple, une application IDE (Integrated Development Environment) peut ouvrir des fenêtres de propriétés et des fenêtres d’outils dont le comportement typique consiste à couvrir la fenêtre qui les crée. De plus, ces fenêtres doivent toujours se fermer, se minimiser, se maximiser et se restaurer en synchronisation avec la fenêtre qui les a créées. Une telle relation peut être établie en rendant une fenêtre propriétaire une autre et est obtenue en définissant la Owner propriété de la fenêtre détenue avec une référence à la fenêtre propriétaire. Ceci est illustré dans l’exemple suivant.

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Create a window and make the current window its owner
    var ownedWindow = new ChildWindow1();
    ownedWindow.Owner = this;
    ownedWindow.Show();
}

Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Create a window and make the current window its owner
    Dim ownedWindow As New ChildWindow1
    ownedWindow.Owner = Me
    ownedWindow.Show()
End Sub

Une fois la propriété établie :

La fenêtre appartenant peut référencer sa fenêtre propriétaire en inspectant la valeur de sa Owner propriété.
La fenêtre propriétaire peut découvrir toutes les fenêtres qu’elle possède en inspectant la valeur de sa OwnedWindows propriété.

Activation de fenêtre

Lorsqu’une fenêtre est ouverte pour la première fois, elle devient la fenêtre active. La fenêtre active est la fenêtre qui capture actuellement l’entrée utilisateur, telle que les traits de touche et les clics de souris. Lorsqu’une fenêtre devient active, elle déclenche l’événement Activated .

Remarque

Lorsqu'une fenêtre est ouverte pour la première fois, les événements Loaded et ContentRendered sont déclenchés uniquement après que l'événement Activated ait été déclenché. Dans cet esprit, une fenêtre peut être considérée comme ouverte lorsque le signal ContentRendered est activé.

Une fois qu’une fenêtre est active, un utilisateur peut activer une autre fenêtre dans la même application ou activer une autre application. Lorsque cela se produit, la fenêtre active devient désactivée et déclenche l’événement Deactivated . De même, lorsque l’utilisateur sélectionne une fenêtre actuellement désactivée, la fenêtre redevient active et Activated est déclenchée.

Une des raisons courantes de gérer Activated et Deactivated est d’activer et de désactiver les fonctionnalités qui ne peuvent s’exécuter que lorsqu’une fenêtre est active. Par exemple, certaines fenêtres affichent du contenu interactif qui nécessite une entrée ou une attention constante de l’utilisateur, y compris les jeux et les lecteurs vidéo. L’exemple suivant est un lecteur vidéo simplifié qui montre comment gérer Activated et Deactivated implémenter ce comportement.

<Window x:Class="WindowsOverview.CustomMediaPlayerWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Activated="Window_Activated"
        Deactivated="Window_Deactivated"
        Title="CustomMediaPlayerWindow" Height="450" Width="800">
    <Grid>
        <MediaElement x:Name="mediaElement" Stretch="Fill"
                      LoadedBehavior="Manual" Source="numbers.mp4" />
    </Grid>
</Window>

Le code suivant est le code-behind du XAML.

using System;
using System.Windows;

namespace WindowsOverview
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow() =>
            InitializeComponent();

        private void Window_Activated(object sender, EventArgs e)
        {
            // Continue playing media if window is activated
            mediaElement.Play();
        }

        private void Window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            mediaElement.Pause();
        }
    }
}

Public Class CustomMediaPlayerWindow
    Private Sub Window_Activated(sender As Object, e As EventArgs)
        ' Continue playing media if window Is activated
        mediaElement.Play()
    End Sub

    Private Sub Window_Deactivated(sender As Object, e As EventArgs)
        ' Pause playing if media is being played and window is deactivated
        mediaElement.Pause()
    End Sub
End Class

D’autres types d’applications peuvent toujours exécuter du code en arrière-plan lorsqu’une fenêtre est désactivée. Par exemple, un client de messagerie peut continuer à interroger le serveur de messagerie pendant que l’utilisateur utilise d’autres applications. Les applications comme celles-ci fournissent souvent un comportement différent ou supplémentaire pendant la désactivation de la fenêtre principale. Pour un programme de messagerie, cela peut signifier l’ajout du nouvel élément de messagerie à la boîte de réception et l’ajout d’une icône de notification à la barre d’état système. Une icône de notification ne doit être affichée que lorsque la fenêtre de messagerie n’est pas active, qui est déterminée par l’inspection de la IsActive propriété.

Si une tâche en arrière-plan se termine, une fenêtre peut souhaiter avertir l’utilisateur plus rapidement en appelant Activate la méthode. Si l’utilisateur interagit avec une autre application activée lorsqu’elle Activate est appelée, le bouton de la barre des tâches de la fenêtre clignote. Toutefois, si un utilisateur interagit avec l’application actuelle, l’appel Activate amène la fenêtre au premier plan.

Remarque

Vous pouvez gérer l’activation de l’étendue de l’application à l’aide des événements Application.Activated et Application.Deactivated.

Prévention de l’activation de fenêtre

Il existe des scénarios où les fenêtres ne doivent pas être activées lorsqu’elles sont affichées, telles que les fenêtres de conversation d’une application de conversation ou les fenêtres de notification d’une application de messagerie.

Si votre application a une fenêtre qui ne doit pas être activée lorsqu’elle est affichée, vous pouvez définir sa ShowActivated propriété false sur avant d’appeler la Show méthode pour la première fois. Par conséquent :

La fenêtre n’est pas activée.
L'événement Activated de la fenêtre n'est pas déclenché.
La fenêtre actuellement activée reste activée.

Toutefois, la fenêtre sera activée dès que l’utilisateur l’active en cliquant sur le client ou la zone non cliente. Dans ce cas :

La fenêtre est activée.
L’événement de la Activated fenêtre est déclenché.
La fenêtre précédemment activée est désactivée.
Les événements Deactivated et Activated des fenêtres sont ensuite déclenchés comme prévu en réponse aux actions de l'utilisateur.

Fermeture d’une fenêtre

La vie d’une fenêtre commence à se terminer lorsqu’un utilisateur le ferme. Une fois qu’une fenêtre est fermée, elle ne peut pas être rouverte. Une fenêtre peut être fermée à l’aide d’éléments dans la zone non cliente, y compris les éléments suivants :

Élément Fermer du menu Système .
Appuyez sur Alt + F4.
Appuyez sur le bouton Fermer .
Appuyez sur Échap lorsqu’un bouton a la IsCancel propriété définie true sur une fenêtre modale.

Vous pouvez fournir davantage de mécanismes à la zone cliente pour fermer une fenêtre, dont le plus courant est le suivant :

Élément de sortie dans le menu Fichier , généralement pour les fenêtres d’application principales.
Élément Fermer dans le menu Fichier , généralement dans une fenêtre d’application secondaire.
Bouton Annuler , généralement dans une boîte de dialogue modale.
Bouton Fermer, généralement sur une boîte de dialogue non modale.

Pour fermer une fenêtre en réponse à l’un de ces mécanismes personnalisés, vous devez appeler la Close méthode. L’exemple suivant implémente la possibilité de fermer une fenêtre en choisissant Quitter dans un menu Fichier .

<Window x:Class="WindowsOverview.ClosingWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClosingWindow" Height="450" Width="800">
    <StackPanel>
        <Menu>
            <MenuItem Header="_File">
                <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
            </MenuItem>
        </Menu>
    </StackPanel>
</Window>

Le code suivant est le code-behind du XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class ClosingWindow : Window
    {
        public ClosingWindow() =>
            InitializeComponent();

        private void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close the current window
            this.Close();
        }
    }
}

Public Class ClosingWindow
    Private Sub fileExitMenuItem_Click(sender As Object, e As RoutedEventArgs)
        ' Close the current window
        Me.Close()
    End Sub
End Class

Remarque

Une application peut être configurée pour s’arrêter automatiquement lorsque la fenêtre principale de l’application se ferme (voir MainWindow) ou la dernière fenêtre se ferme. Pour plus d’informations, consultez ShutdownMode.

Bien qu’une fenêtre puisse être explicitement fermée par le biais de mécanismes fournis dans les zones non clientes et clientes, une fenêtre peut également être implicitement fermée suite à un comportement dans d’autres parties de l’application ou de Windows, notamment :

Un utilisateur se déconnecte ou arrête Windows.
Fermeture d’une Owner fenêtre.
La fenêtre principale de l’application est fermée et ShutdownMode est OnMainWindowClose.
Shutdown est appelée.

Important

Une fenêtre ne peut pas être rouverte après sa fermeture.

Annuler la fermeture de la fenêtre

Lorsqu’une fenêtre se ferme, elle déclenche deux événements : Closing et Closed.

Closing est déclenché avant la fermeture de la fenêtre et fournit un mécanisme par lequel la fermeture de fenêtre peut être évitée. Une des raisons courantes d’empêcher la fermeture de fenêtre est si le contenu de la fenêtre contient des données modifiées. Dans ce cas, l’événement Closing peut être géré pour déterminer si les données sont incorrectes et, le cas échéant, demander à l’utilisateur s’il faut continuer à fermer la fenêtre sans enregistrer les données ou annuler la fermeture de la fenêtre. L’exemple suivant montre les aspects clés de la gestion Closing.

<Window x:Class="WindowsOverview.DataWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataWindow" Height="450" Width="800"
        Closing="Window_Closing">
    <Grid>
        <TextBox x:Name="documentTextBox" TextChanged="documentTextBox_TextChanged" />
    </Grid>
</Window>

Le code suivant est le code-behind du XAML.

using System.Windows;
using System.Windows.Controls;

namespace WindowsOverview
{
    public partial class DataWindow : Window
    {
        private bool _isDataDirty;

        public DataWindow() =>
            InitializeComponent();

        private void documentTextBox_TextChanged(object sender, TextChangedEventArgs e) =>
            _isDataDirty = true;

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // If data is dirty, prompt user and ask for a response
            if (_isDataDirty)
            {
                var result = MessageBox.Show("Document has changed. Close without saving?",
                                             "Question",
                                             MessageBoxButton.YesNo);

                // User doesn't want to close, cancel closure
                if (result == MessageBoxResult.No)
                    e.Cancel = true;
            }
        }
    }
}

Public Class DataWindow

    Private _isDataDirty As Boolean

    Private Sub documentTextBox_TextChanged(sender As Object, e As TextChangedEventArgs)
        _isDataDirty = True
    End Sub

    Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs)

        ' If data is dirty, prompt user and ask for a response
        If _isDataDirty Then
            Dim result = MessageBox.Show("Document has changed. Close without saving?",
                                         "Question",
                                         MessageBoxButton.YesNo)

            ' User doesn't want to close, cancel closure
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End If

    End Sub
End Class

Le gestionnaire d’événements Closing reçoit un CancelEventArgs, qui implémente la propriété Cancel que vous définissez à true pour empêcher la fermeture d’une fenêtre.

Si Closing n’est pas géré, ou s’il est géré mais non annulé, la fenêtre se fermera. Juste avant qu’une fenêtre se ferme, l'événement Closed est déclenché. À ce stade, une fenêtre ne peut pas être empêchée de fermer.

Événements de durée de vie des fenêtres

L’illustration suivante montre la séquence des événements principaux dans la durée de vie d’une fenêtre :

Diagramme montrant les événements dans la durée de vie d’une fenêtre.

L’illustration suivante montre la séquence des événements principaux dans la durée de vie d’une fenêtre qui est affichée sans activation (ShowActivated est définie false avant que la fenêtre ne soit affichée) :

Diagramme montrant les événements dans la durée de vie d’une fenêtre sans activation.

Emplacement de la fenêtre

Lorsqu’une fenêtre est ouverte, elle a un emplacement dans les dimensions x et y par rapport au bureau. Cet emplacement peut être déterminé en inspectant les propriétés Left et Top respectivement. Définissez ces propriétés pour modifier l’emplacement de la fenêtre.

Vous pouvez également spécifier l'emplacement initial du Window au moment de sa première apparition en définissant la propriété WindowStartupLocation avec l'une des valeurs d'énumération suivantes : WindowStartupLocation

CenterOwner (valeur par défaut)
CenterScreen
Manual

Si l’emplacement de démarrage est spécifié en tant que Manual, et que les propriétés Left et Top n'ont pas été définies, Window demandera au système d’exploitation de trouver un emplacement où apparaître.

Les fenêtres les plus élevées et ordre de superposition

En plus d’avoir un emplacement x et y, une fenêtre a également un emplacement dans la dimension z, qui détermine sa position verticale par rapport à d’autres fenêtres. Il s’agit de l’ordre z de la fenêtre, et il existe deux types : l’ordre z normal et l’ordre z le plus élevé . L’emplacement d’une fenêtre dans l’ordre z normal est déterminé par s’il est actuellement actif ou non. Par défaut, une fenêtre se trouve dans l’ordre z normal. L’emplacement d’une fenêtre dans l’ordre de z le plus haut est également déterminé par le fait qu’elle est actuellement active ou non. En outre, les fenêtres dans l’ordre de z le plus haut sont toujours situées au-dessus des fenêtres dans l’ordre de z normal. Une fenêtre se trouve dans l’ordre de z le plus haut en définissant sa Topmost propriété truesur .

Dans chaque type z-order, la fenêtre active apparaît au-dessus de toutes les autres fenêtres dans le même ordre de z.

Taille de la fenêtre

En plus d’avoir un emplacement de bureau, une fenêtre a une taille déterminée par plusieurs propriétés, y compris les différentes propriétés de largeur et de hauteur et SizeToContent.

MinWidth, Widthet MaxWidth sont utilisés pour gérer la plage de largeurs qu’une fenêtre peut avoir pendant sa durée de vie.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">
</Window>

La hauteur de la fenêtre est gérée par MinHeight, Heightet MaxHeight.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">
</Window>

Étant donné que les différentes valeurs de largeur et de hauteur spécifient chacune une plage, il est possible que la largeur et la hauteur d’une fenêtre redimensionnable se trouvent n’importe où dans la plage spécifiée pour la dimension correspondante. Pour détecter respectivement sa largeur et sa hauteur actuelles, inspectez ActualWidth et ActualHeight, respectivement.

Si vous souhaitez que la largeur et la hauteur de votre fenêtre aient une taille qui correspond à la taille du contenu de la fenêtre, vous pouvez utiliser la SizeToContent propriété, qui a les valeurs suivantes :

SizeToContent.Manual
Aucun effet (valeur par défaut).
SizeToContent.Width
Ajuster à la largeur du contenu, ce qui a le même effet que de régler à la fois MinWidth et MaxWidth à la largeur du contenu.
SizeToContent.Height
Ajuster à la hauteur du contenu, ce qui a le même effet que MinHeight la définition et MaxHeight la hauteur du contenu.
SizeToContent.WidthAndHeight
Ajuster à la largeur et à la hauteur du contenu, ce qui équivaut à définir à la fois MinHeight et MaxHeight à la hauteur du contenu, et à définir à la fois MinWidth et MaxWidth à la largeur du contenu.

L’exemple suivant montre une fenêtre qui s’adapte automatiquement à son contenu, verticalement et horizontalement, lorsqu’elle s’affiche pour la première fois.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    SizeToContent="WidthAndHeight">
</Window>

L’exemple suivant montre comment définir la propriété dans le SizeToContent code pour spécifier comment une fenêtre est redimensionnée pour ajuster son contenu.

// Manually alter window height and width
this.SizeToContent = SizeToContent.Manual;

// Automatically resize width relative to content
this.SizeToContent = SizeToContent.Width;

// Automatically resize height relative to content
this.SizeToContent = SizeToContent.Height;

// Automatically resize height and width relative to content
this.SizeToContent = SizeToContent.WidthAndHeight;

' Manually alter window height and width
Me.SizeToContent = SizeToContent.Manual

' Automatically resize width relative to content
Me.SizeToContent = SizeToContent.Width

' Automatically resize height relative to content
Me.SizeToContent = SizeToContent.Height

' Automatically resize height and width relative to content
Me.SizeToContent = SizeToContent.WidthAndHeight

Ordre de priorité pour les propriétés de dimensionnement

Essentiellement, les différentes propriétés de taille d’une fenêtre se combinent pour définir la plage de largeur et de hauteur d’une fenêtre redimensionnable. Pour vous assurer qu’une plage valide est conservée, Window évalue les valeurs des propriétés de taille à l’aide des ordres de priorité suivants.

Pour les propriétés de hauteur :

Pour les propriétés de largeur :

L’ordre de priorité peut également déterminer la taille d’une fenêtre lorsqu’elle est agrandie, qui est gérée avec la WindowState propriété.

État de la fenêtre

Pendant la durée de vie d’une fenêtre redimensionnable, il peut avoir trois états : normal, réduit et agrandi. Une fenêtre avec un état normal est l’état par défaut d’une fenêtre. Une fenêtre avec cet état permet à un utilisateur de le déplacer et de le redimensionner à l’aide d’une poignée de redimensionnement ou de la bordure, s’il est redimensionnable.

Une fenêtre avec un état réduit se réduit à son bouton de barre des tâches si ShowInTaskbar est défini sur true ; sinon, elle se réduit à la plus petite taille possible et se place dans le coin inférieur gauche du bureau. Aucun type de fenêtre réduite ne peut être redimensionné à l’aide d’une bordure ou d’une poignée de redimensionnement, bien qu’une fenêtre réduite qui n’est pas affichée dans la barre des tâches puisse être déplacée autour du bureau.

Une fenêtre avec un état agrandi s’étend à la taille maximale qu’elle peut être, ce qui ne sera que aussi grand que son MaxWidth, MaxHeightet SizeToContent les propriétés dictent. Comme une fenêtre réduite, une fenêtre agrandie ne peut pas être redimensionnée à l’aide d’une poignée de redimensionnement ou en faisant glisser la bordure.

Remarque

Les valeurs des propriétés Top, Left, Width et Height d'une fenêtre représentent toujours les valeurs de l'état normal, même lorsque la fenêtre est actuellement agrandie ou réduite.

L’état d’une fenêtre peut être configuré en définissant sa WindowState propriété, qui peut avoir l’une des valeurs d’énumération suivantes WindowState :

Normal (valeur par défaut)
Maximized
Minimized

L’exemple suivant montre comment créer une fenêtre affichée comme agrandie lorsqu’elle s’ouvre.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowState="Maximized">
</Window>

En général, vous devez définir WindowState pour configurer l’état initial d’une fenêtre. Une fois qu’une fenêtre redimensionnable est affichée, les utilisateurs peuvent appuyer sur les boutons réduire, agrandir et restaurer sur la barre de titre de la fenêtre pour modifier l’état de la fenêtre.

Apparence de la fenêtre

Vous modifiez l’apparence de la zone cliente d’une fenêtre en y ajoutant du contenu spécifique à la fenêtre, tel que des boutons, des étiquettes et des zones de texte. Pour configurer la zone non cliente, Window fournit plusieurs propriétés, notamment Icon pour définir l’icône d’une fenêtre et Title définir son titre.

Vous pouvez également modifier l’apparence et le comportement de la bordure de zone non cliente en configurant le mode de redimensionnement d’une fenêtre, le style de fenêtre et s’il apparaît sous la forme d’un bouton dans la barre des tâches de bureau.

Mode redimensionnement

Selon la WindowStyle propriété, vous pouvez contrôler si et comment les utilisateurs redimensionnent la fenêtre. Le style de fenêtre affecte les éléments suivants :

Autoriser ou interdire le redimensionnement en faisant glisser la bordure de la fenêtre avec la souris.
Indique si les boutons Réduire, Agrandir et Fermer apparaissent dans la zone non cliente.
Indique si les boutons Réduire, Agrandir et Fermer sont activés.

Vous pouvez configurer la façon dont une fenêtre est redimensionnée en définissant sa ResizeMode propriété, qui peut être l’une des valeurs d’énumération suivantes ResizeMode :

Comme avec WindowStyle, le mode de redimensionnement d’une fenêtre est peu susceptible de changer pendant sa durée de vie, ce qui signifie que vous allez probablement le définir à partir du balisage XAML.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ResizeMode="CanResizeWithGrip">
</Window>

Notez que vous pouvez détecter si une fenêtre est agrandie, réduite ou restaurée en inspectant la WindowState propriété.

Style de fenêtre

La bordure exposée à partir de la zone non cliente d’une fenêtre convient à la plupart des applications. Toutefois, il existe des circonstances où différents types de bordures sont nécessaires ou qu’aucune bordure n’est nécessaire, selon le type de fenêtre.

Pour contrôler le type de bordure d’une fenêtre, vous définissez sa WindowStyle propriété avec l’une des valeurs suivantes de l’énumération WindowStyle :

L’effet de l’application d’un style de fenêtre est illustré dans l’image suivante :

Capture d’écran montrant comment WindowStyle affecte une fenêtre dans WPF.

Notez que l’image ci-dessus n’affiche aucune différence notable entre SingleBorderWindow et ThreeDBorderWindow. De retour dans Windows XP, ThreeDBorderWindow a affecté la façon dont la fenêtre a été dessinée, en ajoutant une bordure 3D à la zone cliente. À compter de Windows 7, les différences entre les deux styles sont minimales.

Vous pouvez définir WindowStyle à l’aide du balisage XAML ou du code. Étant donné qu’il est peu probable qu’elle change pendant la durée de vie d’une fenêtre, vous la configurerez probablement à l’aide du balisage XAML.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="ToolWindow">
</Window>

Style de fenêtre non rectangulaire

Il existe également des situations où les styles de bordure qui WindowStyle vous permettent d’avoir ne sont pas suffisants. Par exemple, vous pouvez créer une application avec une bordure non rectangulaire, comme le lecteur Microsoft Windows Media.

Par exemple, considérez la fenêtre de bulles vocales affichée dans l’image suivante :

Capture d’écran d’une fenêtre WPF avec une zone clippée et une forme personnalisée.

Ce type de fenêtre peut être créé en réglant la propriété WindowStyle à None, et en utilisant le support spécial que Window offre pour la transparence.

<Window x:Class="WindowsOverview.ClippedWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClippedWindow" SizeToContent="WidthAndHeight"
        WindowStyle="None" AllowsTransparency="True" Background="Transparent">
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>

        <Rectangle Stroke="#FF000000" RadiusX="10" RadiusY="10"/>
        <Path Fill="White" Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="15,-5.597,0,-0.003" Width="30" Grid.Row="1" Data="M22.166642,154.45381 L29.999666,187.66699 40.791059,154.54395"/>
        <Rectangle Fill="White" RadiusX="10" RadiusY="10" Margin="1"/>
        
        <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" FontSize="25" Text="Greetings!" TextWrapping="Wrap" Margin="5,5,50,5"/>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Background="Transparent" BorderBrush="{x:Null}" Foreground="Red" Content="❌" FontSize="15" />

        <Grid.Effect>
            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Color="LightBlue"/>
        </Grid.Effect>
    </Grid>
</Window>

Cette combinaison de valeurs indique à la fenêtre de rendre transparent. Dans cet état, les boutons d’ornement de la zone non cliente de la fenêtre ne peuvent pas être utilisés et vous devez fournir vos propres boutons.

Présence de la barre des tâches

L’apparence par défaut d’une fenêtre inclut un bouton de barre des tâches. Certains types de fenêtres n’ont pas de bouton de barre des tâches, tels que les boîtes de message, les boîtes de dialogue ou les fenêtres avec la WindowStyle propriété définie sur ToolWindow. Vous pouvez contrôler si le bouton de barre des tâches d’une fenêtre s’affiche en définissant la ShowInTaskbar propriété, qui est true par défaut.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ShowInTaskbar="False">
</Window>

Autres types de fenêtres

NavigationWindow est une fenêtre conçue pour héberger du contenu navigable.

Les boîtes de dialogue sont des fenêtres qui sont souvent utilisées pour collecter des informations d’un utilisateur pour terminer une fonction. Par exemple, lorsqu’un utilisateur souhaite ouvrir un fichier, la boîte de dialogue Ouvrir un fichier s’affiche par une application pour obtenir le nom de fichier de l’utilisateur. Pour plus d’informations, consultez Vue d’ensemble des boîtes de dialogue.

Partager via

Vue d’ensemble des fenêtres WPF

Classe Fenêtre

Implémentation d’une fenêtre

Configuration d’une fenêtre pour MSBuild

Durée de vie de la fenêtre

Ouverture d’une fenêtre

Fenêtre de démarrage

Propriété de fenêtre

Activation de fenêtre

Prévention de l’activation de fenêtre

Fermeture d’une fenêtre

Annuler la fermeture de la fenêtre

Événements de durée de vie des fenêtres

Emplacement de la fenêtre

Les fenêtres les plus élevées et ordre de superposition

Taille de la fenêtre

Ordre de priorité pour les propriétés de dimensionnement

État de la fenêtre

Apparence de la fenêtre

Mode redimensionnement

Style de fenêtre

Style de fenêtre non rectangulaire

Présence de la barre des tâches

Autres types de fenêtres

Voir aussi

Commentaires

Ressources supplémentaires