Freigeben über

Übersicht über WPF-Fenster

Benutzer interagieren mit Windows Presentation Foundation (WPF)-Anwendungen über Fenster. Der Hauptzweck eines Fensters ist das Hosten von Inhalten, die Daten visualisieren und Benutzern die Interaktion mit Daten ermöglichen. WPF-Anwendungen stellen ihre eigenen Fenster mithilfe der Window Klasse bereit. In diesem Artikel wird Window eingeführt, bevor die Grundlagen des Erstellens und Verwaltens von Fenstern in Anwendungen behandelt werden.

Von Bedeutung

In diesem Artikel wird XAML verwendet, das aus einem C# -Projekt generiert wurde. Wenn Sie Visual Basic verwenden, sieht der XAML-Code möglicherweise etwas anders aus. Diese Unterschiede sind in der Regel für x:Class Attributwerte vorhanden. C# enthält den Stammnamespace für das Projekt, während Visual Basic nicht.

Die Projektvorlagen für C# erstellen einen App Typ, der in der Datei "app.xaml " enthalten ist. In Visual Basic wird der Typ benannt Application , und die Datei wird benannt Application.xaml.

Die Window-Klasse

In WPF wird ein Fenster von der Window-Klasse gekapselt, die Sie für folgende Aufgaben verwenden:

  • Anzeigen eines Fensters
  • Konfigurieren Sie die Größe, Position und Darstellung eines Fensters.
  • Hosten von anwendungsspezifischem Inhalt
  • Verwalten der Lebensdauer eines Fensters

Die folgende Abbildung veranschaulicht die Bestandteile eines Fensters:

Screenshot, der Teile eines WPF-Fensters zeigt.

Ein Fenster wird in zwei Bereiche geteilt: der Nicht-Clientbereich und der Clientbereich.

Der Nicht-Clientbereich eines Fensters wird mit WPF implementiert und enthält die Teile eines Fenster, die den meisten Fenstern gemeinsam sind, einschließlich:

  • Eine Titelleiste (1-5).
  • Ein Symbol (1).
  • Titel (2)
  • Minimieren (3), Maximieren (4) und Schließen (5) Schaltflächen.
  • Systemmenü (6) mit Menüelementen. Wird angezeigt, wenn Sie auf das Symbol (1) klicken.
  • Rahmen (7).

Der Clientbereich eines Fensters ist der Bereich innerhalb des Nicht-Clientbereichs eines Fensters und wird von Entwicklern verwendet, um anwendungsspezifische Inhalte wie Menüleisten, Symbolleisten und Steuerelemente hinzuzufügen.

  • Kundenbereich (8).
  • Ändern Sie die Größe des Griffs (9). Dies ist ein Steuerelement, das dem Clientbereich (8) hinzugefügt wird.

Implementieren eines Fensters

Die Implementierung eines typischen Fensters umfasst sowohl das Erscheinungsbild als auch das Verhalten, wobei das Erscheinungsbild definiert, wie ein Fenster für Benutzer aussieht, und das Verhalten bestimmt, wie ein Fenster funktioniert, während Benutzer damit interagieren. In WPF können Sie das Erscheinungsbild und Verhalten eines Fensters mithilfe von Code oder XAML-Markup implementieren.

Im Allgemeinen wird die Darstellung eines Fenster jedoch mit XAML-Markup und dessen Verhalten mit Code-Behind implementiert, wie im folgenden Beispiel gezeigt.

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

Der folgende Code ist das Code-Behind für das XAML-Dokument.

using System.Windows;

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

Public Class Window1

End Class

Folgende Voraussetzungen müssen erfüllt sein, damit die XAML-Markupdatei und die Code-Behind-Datei zusammenarbeiten:

  • Im Markup muss das Window-Element das attribut x:Class enthalten. Wenn die Anwendung erstellt wird, bewirkt das Vorhandensein des x:Class Attributs, dass die Microsoft-Build-Engine (MSBuild) eine partial Klasse generiert, die von Window abgeleitet ist und den Namen trägt, der durch das x:Class Attribut angegeben wird. Dies erfordert das Hinzufügen einer XML-Namespacedeklaration für das XAML-Schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). Die generierte partial Klasse implementiert die InitializeComponent-Methode, die aufgerufen wird, um die Ereignisse zu registrieren und die Eigenschaften festzulegen, die im Markup implementiert werden.

  • Bei CodeBehind muss die Klasse eine partial-Klasse mit demselben Namen sein, der im Markup durch das x:Class-Attribut angegeben ist, und sie muss von Window abgeleitet sein. Dadurch kann die CodeBehind-Datei der partial Klasse zugeordnet werden, die beim Erstellen der Anwendung für die Markupdatei generiert wird, weitere Informationen finden Sie unter Kompilieren einer WPF-Anwendung.

  • Bei Code-Behind muss die Window-Klasse einen Konstruktor implementieren, der die InitializeComponent-Methode aufruft. InitializeComponent wird durch die generierte partial-Klasse der Markupdatei implementiert, um Ereignisse zu registrieren und im Markup definierte Eigenschaften festzulegen.

Hinweis

Wenn Sie Ihrem Projekt ein neues Window mithilfe von Visual Studio hinzufügen, wird Window unter Verwendung von Markup und Code-Behind implementiert. Außerdem wird eine Konfiguration eingefügt, die zum Erstellen der Verknüpfung zwischen Markup- und Code-Behind-Dateien, wie hier beschrieben, benötigt wird.

Mit dieser Konfiguration können Sie den Fokus auf das Definieren der Fensterdarstellung in XAML-Markup richten und das Fensterverhalten in Code-Behind implementieren. Das folgende Beispiel zeigt ein Fenster mit einer Schaltfläche, die einen Ereignishandler für das Click Ereignis definiert. Dies wird im XAML-Code implementiert, und der Handler wird in CodeBehind implementiert.

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

Der folgende Code ist das Code-Behind für das XAML-Dokument.

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

Konfigurieren eines Fensters für MSBuild

Wie Sie Das Fenster implementieren, bestimmt, wie es für MSBuild konfiguriert ist. Für ein Fenster, das sowohl mit XAML-Markup als auch mit Code-Behind definiert ist:

  • XAML-Markup-Dateien werden als MSBuild Page Elemente konfiguriert.
  • Code-Behind-Dateien werden als MSBuild Compile-Elemente konfiguriert.

.NET SDK-Projekte importieren automatisch die richtigen Page Und Compile Elemente für Sie, und Sie müssen diese nicht deklarieren. Wenn das Projekt für WPF konfiguriert ist, werden die XAML-Markupdateien automatisch als Page-Elemente importiert, und die entsprechende Code-behind-Datei wird als Compile importiert.

MSBuild-Projekte importieren die Typen nicht automatisch, und Sie müssen sie selbst deklarieren:

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

Informationen zum Erstellen von WPF-Anwendungen finden Sie unter Kompilieren einer WPF-Anwendung.

Fensterlebensdauer

Wie bei jeder Klasse verfügt ein Fenster über eine Lebensdauer, die beim ersten Instanziieren beginnt, nach dem es geöffnet, aktiviert/deaktiviert und schließlich geschlossen wird.

Öffnen eines Fensters

Zum Öffnen eines Fensters erstellen Sie zunächst eine Instanz davon, die im folgenden Beispiel veranschaulicht wird:

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

In diesem Beispiel Window1 wird instanziiert, wenn die Anwendung gestartet wird, was auftritt, wenn das Startup Ereignis ausgelöst wird. Weitere Informationen zum Startfenster finden Sie unter Abrufen oder Festlegen des Hauptanwendungsfensters.

Wenn ein Fenster instanziiert wird, wird automatisch ein Verweis darauf einer Liste von Fenstern hinzugefügt, die Application vom Objekt verwaltet werden. Das erste zu instanziierende Fenster wird automatisch als Hauptanwendungsfenster festgelegtApplication.

Das Fenster wird schließlich geöffnet, indem die Show Methode aufgerufen wird, wie in der folgenden Abbildung dargestellt:

WPF-Fenster mit einer einzelnen Schaltfläche im Text

Ein Fenster, das durch Aufrufen Show geöffnet wird, ist ein modusloses Fenster, und die Anwendung verhindert nicht, dass Benutzer mit anderen Fenstern in der Anwendung interagieren. Das Öffnen eines Fensters mit ShowDialog zeigt das Fenster als modal an und beschränkt die Benutzerinteraktion auf dieses spezifische Fenster. Weitere Informationen finden Sie unter Übersicht über Dialogfelder.

Wenn Show aufgerufen wird, führt ein Fenster zunächst Initialisierungsarbeiten durch, bevor es angezeigt wird, um die Infrastruktur zu schaffen, die es ermöglicht, Benutzereingaben zu empfangen. Wenn das Fenster initialisiert wird, wird das SourceInitialized-Ereignis hervorgerufen und das Fenster wird angezeigt.

Weitere Informationen finden Sie unter Öffnen eines Fensters oder Dialogfelds.

Startfenster

Im vorherigen Beispiel wurde das Startup Ereignis verwendet, um Code auszuführen, der das anfängliche Anwendungsfenster anzeigte. Verwenden Sie stattdessen StartupUri als Verknüpfung, um den Pfad zu einer XAML-Datei in Ihrer Anwendung anzugeben. Die Anwendung erstellt automatisch das durch diese Eigenschaft angegebene Fenster und zeigt es an.

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

Fensterbesitz

Ein Fenster, das mithilfe der Show Methode geöffnet wird, verfügt nicht über eine implizite Beziehung mit dem Fenster, das es erstellt hat. Benutzer können unabhängig vom anderen Fenster mit beiden Fenstern interagieren, was bedeutet, dass beide Fenster die folgenden Aktionen ausführen können:

  • Verdecken Sie das andere (es sei denn, die Topmost-Eigenschaft eines der Fenster ist auf true eingestellt).
  • Es wird minimiert, maximiert und wiederhergestellt, ohne das andere zu beeinflussen.

Bei einigen Fenstern ist eine Beziehung zu dem Fenster erforderlich, durch das es geöffnet wird. Beispielsweise kann eine IDE-Anwendung (Integrated Development Environment) Eigenschaftsfenster und Toolfenster öffnen, deren typisches Verhalten darin besteht, das Fenster zu überdecken, in dem sie erstellt werden. Darüber hinaus sollten solche Fenster stets mit den Fenstern geschlossen, minimiert, maximiert und wiederhergestellt werden, durch die sie erstellt wurden. Eine solche Beziehung lässt sich herstellen, indem festgelegt wird, dass ein Fenster das andere besitzt. Dazu legen Sie dieOwner-Eigenschaft von zum Besitzer gehöriges Fenster mit einem Verweis auf Besitzerfenster fest. Dies wird im folgenden Beispiel gezeigt.

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

Nachdem das Eigentum etabliert ist:

  • Das zum Besitzer gehörige Fenster kann auf sein Besitzerfenster verweisen, indem der Wert der Owner-Eigenschaft überprüft wird.
  • Das Besitzerfenster kann alle ihm gehörenden Fenster durch Überprüfen des Wertes der OwnedWindows-Eigenschaft ermitteln.

Fensteraktivierung

Wenn ein Fenster zum ersten Mal geöffnet wird, wird es zum aktiven Fenster. Das aktive Fenster ist das Fenster, das derzeit Benutzereingaben erfasst, z. B. Tastenanschläge und Mausklicks. Wenn ein Fenster aktiv wird, löst es das Activated-Ereignis aus.

Hinweis

Wenn ein Fenster zum ersten Mal geöffnet wird, werden die ereignisse Loaded und ContentRendered erst ausgelöst, nachdem das ereignis Activated ausgelöst wurde. Vor diesem Hintergrund gilt ein Fenster als tatsächlich geöffnet, nachdem ContentRendered ausgelöst wurde.

Nachdem ein Fenster aktiv wurde, kann ein Benutzer ein anderes Fenster in derselben Anwendung aktivieren oder eine andere Anwendung aktivieren. In diesem Fall wird das derzeit aktive Fenster deaktiviert, und es löst das Deactivated-Ereignis aus. Wenn der Benutzer ein derzeit deaktiviertes Fenster auswählt, wird das Fenster entsprechend neu aktiviert, und Activated wird ausgelöst.

Ein häufiger Grund für die Behandlung von Activated und Deactivated ist das Aktivieren und Deaktivieren von Funktionen, die nur ausgeführt werden können, wenn ein Fenster aktiv ist. Beispielsweise zeigen einige Fenster interaktive Inhalte an, die eine konstante Benutzereingabe oder -aufmerksamkeit erfordern, einschließlich Spielen und Videoplayern. Das folgende Beispiel ist ein vereinfachter Videoplayer, der zeigt, wie man Activated und Deactivated behandelt, um dieses Verhalten zu implementieren.

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

Der folgende Code ist der Code-Behind für das 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

Andere Anwendungstypen können weiterhin Code im Hintergrund ausführen, wenn ein Fenster deaktiviert wird. Beispielsweise kann ein E-Mail-Client weiterhin den E-Mail-Server abfragen, während der Benutzer andere Anwendungen verwendet. Anwendungen wie diese bieten häufig ein anderes oder zusätzliches Verhalten, während das Hauptfenster deaktiviert wird. Bei einem E-Mail-Programm kann dies sowohl das Hinzufügen des neuen E-Mail-Elements zum Posteingang als auch das Hinzufügen eines Benachrichtigungssymbols zur Taskleiste bedeuten. Ein Benachrichtigungssymbol muss nur angezeigt werden, wenn das E-Mail-Fenster nicht aktiv ist, das durch prüfen der IsActive Eigenschaft bestimmt wird.

Nach Ausführen einer Hintergrundtask benachrichtigt ein Fenster den Benutzer etwas dringlicher, indem die Activate-Methode aufgerufen wird. Wenn der Benutzer mit einer anderen Anwendung interagiert, die aktiviert wird, wenn Activate aufgerufen wird, blinkt die Taskleistenschaltfläche des Fensters. Wenn ein Benutzer jedoch mit der aktuellen Anwendung interagiert, bringt der Aufruf Activate das Fenster in den Vordergrund.

Hinweis

Sie können die Aktivierung des Anwendungsbereichs mit den Application.Activated- und Application.Deactivated-Ereignissen behandeln.

Verhindern der Fensteraktivierung

Es gibt Szenarien, in denen Fenster nicht aktiviert werden sollten, wenn sie angezeigt werden, z. B. Unterhaltungsfenster einer Chatanwendung oder Benachrichtigungsfenster einer E-Mail-Anwendung.

Wenn Ihre Anwendung über ein Fenster verfügt, das bei der Anzeige nicht aktiviert werden soll, können Sie die ShowActivated Eigenschaft auf false festlegen, bevor Sie die Show Methode zum ersten Mal aufrufen. Dies hat zur Folge:

  • Das Fenster ist nicht aktiviert.
  • Das Fensterereignis Activated wird nicht ausgelöst.
  • Das aktuell aktivierte Fenster bleibt aktiviert.

Das Fenster wird jedoch aktiviert, sobald der Benutzer es aktiviert, indem er entweder auf den Client- oder nicht-Client-Bereich klickt. In diesem Fall:

  • Das Fenster wird aktiviert.
  • Das Activated-Ereignis des Fensters wird ausgelöst.
  • Das zuvor aktivierte Fenster wird deaktiviert.
  • Die Ereignisse Deactivated und Activated des Fensters werden dann wie erwartet als Reaktion auf Benutzeraktionen ausgelöst.

Schließen eines Fensters

Die Lebensdauer eines Fensters beginnt am Ende, wenn ein Benutzer es schließt. Sobald ein Fenster geschlossen wurde, kann es nicht erneut geöffnet werden. Ein Fenster kann mithilfe der Elemente im Nicht-Clientbereich geschlossen werden, z. B. mit den folgenden:

  • Das Element Schließen im Menü System.
  • Drücken von ALT+F4.
  • Klicken auf die Schaltfläche Schließen.
  • Drücken von ESC, wenn eine Schaltfläche in einem modalen Fenster die IsCancel-Eigenschaft auf true gesetzt hat.

Sie können dem Clientbereich weitere Mechanismen bereitstellen, um ein Fenster zu schließen, die häufiger folgendes umfassen:

  • Das Element Beenden im Menü Datei, i. d. R. für Hauptanwendungsfenster.
  • Das Element Schließen im Menü Datei, i. d. R. in einem sekundären Anwendungsfenster.
  • Das Element Abbrechen, i. d. R. in einem modalen Dialogfeld.
  • Das Element Schließen, i. d. R. in einem nicht modalen Dialogfeld.

Um ein Fenster als Reaktion auf einen dieser benutzerdefinierten Mechanismen zu schließen, müssen Sie die Close-Methode aufrufen. Im folgenden Beispiel wird die Möglichkeit implementiert, ein Fenster zu schließen, indem "Beenden" aus einem Datei-Menü ausgewählt wird.

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

Der folgende Code ist der Code-Behind für das 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

Hinweis

Eine Anwendung kann so konfiguriert werden, dass sie automatisch heruntergefahren wird, wenn entweder das Hauptanwendungsfenster geschlossen wird (siehe MainWindow) oder das letzte Fenster geschlossen wird. Weitere Informationen finden Sie unter ShutdownMode.

Während ein Fenster über die im Nicht-Clientbereich und im Clientbereich bereitgestellten Mechanismen explizit geschlossen werden kann, ist es auch möglich, dass es infolge des Verhaltens in anderen Bereichen der Anwendung oder des Fensters implizit geschlossen wird, z. B.:

Von Bedeutung

Ein Fenster kann nach dem Schließen nicht erneut geöffnet werden.

Fensterschließung abbrechen

Wenn ein Fenster geschlossen wird, löst es zwei Ereignisse aus: Closing und Closed.

Closing wird vor dem Schließen des Fensters ausgelöst und bietet einen Mechanismus, mit dem das Schließen des Fensters verhindert werden kann. Ein häufiger Grund zum Verhindern des Schließens von Fenstern ist, wenn Der Fensterinhalt geänderte Daten enthält. In diesem Fall kann das Closing-Ereignis behandelt werden, um zu bestimmen, ob Daten schmutzig sind, und wenn ja, den Benutzer zu fragen, ob das Schließen des Fensters fortgesetzt werden soll, ohne die Daten zu speichern oder das Schließen des Fensters abzubrechen. Das folgende Beispiel zeigt die Schlüsselaspekte der Handhabung von 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>

Der folgende Code ist das Code-Behind für das XAML-Dokument.

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

Der Closing Ereignishandler wird ein CancelEventArgs übergeben, das die Cancel Eigenschaft implementiert, die Sie auf true festlegen, um zu verhindern, dass ein Fenster geschlossen wird.

Wenn Closing nicht behandelt wird oder behandelt wird, aber nicht storniert, wird das Fenster geschlossen. Kurz bevor ein Fenster tatsächlich geschlossen wird, wird Closed erhoben. An diesem Punkt kann ein Fenster nicht am Schließen gehindert werden.

Fensterlebenszyklus-Ereignisse

Die folgende Abbildung zeigt die Abfolge der Prinzipalereignisse in der Lebensdauer eines Fensters:

Diagramm, das Ereignisse in der Lebensdauer eines Fensters zeigt.

Die folgende Abbildung zeigt die Abfolge der Prinzipalereignisse in der Lebensdauer eines Fensters, das ohne Aktivierung angezeigt wird (ShowActivated wird auf false festgelegt, bevor das Fenster angezeigt wird):

Diagramm, das Ereignisse in der Lebensdauer eines Fensters ohne Aktivierung anzeigt.

Fensterspeicherort

Während ein Fenster geöffnet ist, hat es eine Position in den x- und y-Dimensionen relativ zum Desktop. Diese Position kann durch Prüfung der Left- bzw. Top-Eigenschaften ermittelt werden. Legen Sie diese Eigenschaften fest, um die Position des Fensters zu ändern.

Sie können auch den Anfangsspeicherort eines Window wenn es zum ersten Mal auftritt, indem Sie die WindowStartupLocation-Eigenschaft mit einer der folgenden WindowStartupLocation-Enumerationwrte einstellen:

Wenn der Startspeicherort als Manual angegeben ist und die Eigenschaften Left und Top nicht gesetzt wurden, wird Window das Betriebssystem um einen Speicherort bitten, in dem es erscheinen kann.

Oberste Fenster und Z-Reihenfolge

Neben einer x- und y-Position verfügt ein Fenster auch über eine Position in der Z-Dimension, die seine vertikale Position in Bezug auf andere Fenster bestimmt. Dies wird als Z-Reihenfolge des Fensters bezeichnet, und es gibt zwei Typen: normale Z-Reihenfolge und oberste z-Reihenfolge. Die Position eines Fensters in der normalen Z-Reihenfolge wird bestimmt, ob es aktuell aktiv ist oder nicht. Standardmäßig befindet sich ein Fenster in der normalen Z-Reihenfolge. Die Position eines Fensters in der obersten Z-Reihenfolge wird auch bestimmt, ob es aktuell aktiv ist oder nicht. Darüber hinaus befinden sich Fenster in der obersten Z-Reihenfolge immer über Fenstern in der normalen Z-Reihenfolge. Ein Fenster befindet sich in der obersten Z-Reihenfolge, indem seine Topmost-Eigenschaft auf true festgelegt wird.

Innerhalb jedes Z-Reihenfolge-Typs wird das aktuell aktive Fenster oberhalb aller anderen Fenster in derselben Z-Reihenfolge angezeigt.

Fenstergröße

Abgesehen von der Position auf dem Desktop verfügt ein Fenster über eine Größe, die durch mehrere Eigenschaften bestimmt wird, beispielsweise die Eigenschaften für Breite, Höhe und SizeToContent.

MinWidth, Widthund MaxWidth werden verwendet, um den Bereich der Breiten zu verwalten, die ein Fenster während seiner Lebensdauer haben kann.

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

Die Fensterhöhe wird von MinHeight, Height und MaxHeight verwaltet.

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

Da die verschiedenen Breitenwerte und Höhenwerte jeweils einen Bereich angeben, ist es möglich, dass die Breite und Höhe eines verkleinerbaren Fensters an einer beliebigen Stelle innerhalb des angegebenen Bereichs für die jeweilige Dimension liegen. Um seine aktuelle Breite und Höhe zu ermitteln, prüfen Sie jeweils ActualWidth und ActualHeight.

Wenn die Breite und Höhe des Fensters eine Größe aufweisen sollen, die zur Größe des Fensterinhalts passt, können Sie die Eigenschaft SizeToContent verwenden, die die folgenden Werte aufweist:

Im folgenden Beispiel wird ein Fenster dass die Größe automatisch an seinen Inhalt vertikal und horizontal an, wenn es zuerst angezeigt wird.

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

Das folgende Beispiel zeigt, wie die SizeToContent-Eigenschaft im Code festgelegt wird, um anzugeben, wie die Größe eines Fensters an den Inhalt angepasst wird.

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

Reihenfolge der Größenanpassungseigenschaften

Im Wesentlichen werden die verschiedenen Größeneigenschaften eines Fensters kombiniert, um den Bereich der Breite und Höhe für ein verkleinerbares Fenster zu definieren. Um sicherzustellen, dass ein gültiger Bereich beibehalten wird, wertet Window die Werte der Größeneigenschaften mithilfe der folgenden Rangfolgen aus.

Für Höheneigenschaften:

  1. FrameworkElement.MinHeight
  2. FrameworkElement.MaxHeight
  3. SizeToContent.Height / SizeToContent.WidthAndHeight
  4. FrameworkElement.Height

Für Breiteneigenschaften:

  1. FrameworkElement.MinWidth
  2. FrameworkElement.MaxWidth
  3. SizeToContent.Width / SizeToContent.WidthAndHeight
  4. FrameworkElement.Width

Die Prioritätsreihenfolge kann auch die Größe eines Fensters bestimmen, wenn das Fenster maximiert ist, was mit der Eigenschaft WindowState verwaltet wird.

Fensterstatus

Während der Lebensdauer eines anpassbaren Fensters kann es sich in drei Zuständen befinden: normal, minimiert und maximiert. Ein Fenster mit einem normalen Zustand ist der Standardzustand eines Fensters. Ein Fenster mit diesem Zustand erlaubt dem Benutzer, es durch einen Größenänderungsgriff oder den Rahmen zu verschieben und die Größe zu ändern, wenn es in der Größe veränderbar ist.

Ein Fenster mit einem minimierten Zustand wird auf die Schaltfläche der Taskleiste reduziert, wenn ShowInTaskbar auf true gesetzt ist; andernfalls wird es auf die kleinste mögliche Größe zusammengeklappt und in die untere linke Ecke des Desktops verschoben. Keiner der minimierten Fenstertypen kann mithilfe des Ziehpunkts zur Größenreduzierung oder mit dem Rahmen in der Größe verändert werden. Allerdings kann ein minimiertes Fenster, das nicht in der Taskleiste angezeigt wird, auf dem Desktop hin und her verschoben werden.

Ein Fenster mit einem maximiertenZustand wird auf die maximal mögliche Größe erweitert, die nur so groß ist, wie es seineMaxWidth, MaxHeight, und SizeToContent-Eigenschaften vorgeben. Wie bei einem minimierten Fenster kann die Größe eines maximierten Fensters nicht mithilfe eines Größenänderungsgriffs oder durch Ziehen des Rahmens geändert werden.

Hinweis

Die Werte der Top, Left, Widthund Height Eigenschaften eines Fensters stellen immer die Werte für den normalen Zustand dar, auch wenn das Fenster aktuell maximiert oder minimiert ist.

Der Zustand eines Fensters kann durch Festlegen der WindowState-Eigenschaft konfiguriert werden, die einen der folgenden WindowState Enumerationswerte haben kann:

Das folgende Beispiel zeigt, wie Sie ein Fenster erstellen, das beim Öffnen als maximiert angezeigt wird.

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

Im Allgemeinen sollten Sie WindowState festlegen, um den Anfangszustand eines Fensters zu konfigurieren. Sobald ein verkleinerbares Fenster angezeigt wird, können Benutzer die Schaltflächen "Minimieren", "Maximieren" und "Wiederherstellen" auf der Titelleiste des Fensters drücken, um den Fensterzustand zu ändern.

Fensterdarstellung

Sie ändern die Darstellung des Clientbereichs eines Fensters, indem Sie ihr fensterspezifische Inhalte hinzufügen, z. B. Schaltflächen, Beschriftungen und Textfelder. Um den Nicht-Clientbereich zu konfigurieren, stellt Window mehrere Eigenschaften bereit, die Icon enthalten, um das Symbol eines Fensters festzulegen, und Title, um den Titel festzulegen.

Sie können auch das Erscheinungsbild und das Verhalten des Rahmens eines Nicht-Client-Bereichs ändern, indem Sie den Größenänderungsmodus, den Fensterstil und ob es als Schaltfläche in der Desktop-Taskleiste erscheint, konfigurieren.

Größenänderungsmodus

WindowStyle Je nach Eigenschaft können Sie steuern, ob und wie Benutzer die Größe des Fensters ändern. Der Fensterstil wirkt sich auf Folgendes aus:

  • Zulassen oder verbieten Sie die Größenänderung, indem Sie den Fensterrahmen mit der Maus ziehen.
  • Gibt an, ob die Schaltflächen " Minimieren", " Maximieren" und " Schließen " im Nicht-Client-Bereich angezeigt werden.
  • Gibt an, ob die Schaltflächen "Minimieren", " Maximieren" und " Schließen " aktiviert sind.

Sie können konfigurieren, wie die Größe eines Fensters geändert wird, indem Sie dessen ResizeMode-Eigenschaft festlegen. Dies kann einer der folgenden ResizeMode Enumerationswerte sein:

Wie bei WindowStyleist es unwahrscheinlich, dass sich der Größenänderungsmodus eines Fensters während seiner Lebensdauer ändert. Dies bedeutet, dass Sie es wahrscheinlich aus XAML-Markup festlegen werden.

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

Beachten Sie, dass Sie erkennen können, ob ein Fenster maximiert, minimiert oder wiederhergestellt wird, indem Sie die eigenschaft WindowState überprüfen.

Fensterformat

Der Rahmen, der vom Nicht-Clientbereich eines Fensters verfügbar gemacht wird, eignet sich für die meisten Anwendungen. Es gibt jedoch Situationen, in denen unterschiedliche Rahmentypen erforderlich sind oder überhaupt keine Rahmen erforderlich sind, je nach Fenstertyp.

Um zu steuern, welche Art von Rahmen ein Fenster erhält, legen Sie dessen WindowStyle-Eigenschaft mit einem der folgenden Werte der WindowStyle-Enumeration fest:

Der Effekt der Anwendung einer Fensterformatvorlage wird in der folgenden Abbildung veranschaulicht:

Screenshot, der zeigt, wie Sich WindowStyle auf ein Fenster in WPF auswirkt.

Beachten Sie, dass das obige Bild keinen deutlichen Unterschied zwischen SingleBorderWindow und ThreeDBorderWindow zeigt. Bereits bei Windows XP beeinflusste ThreeDBorderWindow die Darstellung des Fensters und fügte dem Client-Bereich einen 3D-Rahmen hinzu. Ab Windows 7 sind die Unterschiede zwischen den beiden Stilen minimal.

Sie können WindowStyle entweder mit XAML-Markup oder Code festlegen. Weil sich ein Fenster während seiner Lebensdauer wahrscheinlich kaum ändern wird, werden Sie es höchstwahrscheinlich mit XAML-Markup konfigurieren.

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

Nicht-rechteckiger Fensterstil

Es gibt auch Situationen, in denen die Rahmenarten, die WindowStyle Ihnen erlaubt, nicht ausreichend sind. Sie können zum Beispiel eine Anwendung mit einem nicht rechteckigen Rahmen erstellen, wie der Microsoft Windows Media Player verwendet.

Betrachten Sie z. B. das Sprachblasenfenster in der folgenden Abbildung:

Screenshot eines WPF-Fensters mit einem beschnittenen Bereich und einer benutzerdefinierten Form.

Dieser Fenstertyp kann, indem man den Parameter derWindowStyle-Eigenschaft aufNone einstellt, und durch die Verwendung einer speziellen Unterstützung, die Window für Transparenz hat.

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

Diese Kombination von Werten weist das Fenster an, transparent zu rendern. In diesem Zustand können die Nicht-Client-Bereichs-Schaltflächen des Fensters nicht verwendet werden, und Sie müssen eigene bereitstellen.

Anwesenheit der Taskleiste

Die Standarddarstellung eines Fensters enthält eine Taskleistenschaltfläche. Einige Fenstertypen verfügen nicht über eine Taskleistenschaltfläche, z. B. Meldungsfelder, Dialogfelder oder Fenster, deren WindowStyle Eigenschaft auf ToolWindow festgelegt ist. Sie können steuern, ob die Taskleistenschaltfläche für ein Fenster angezeigt wird, indem Sie die Eigenschaft ShowInTaskbar festlegen, die standardmäßig true ist.

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

Andere Fenstertypen

NavigationWindow ist ein Fenster, das zum Hosten von navigierbaren Inhalten konzipiert ist.

Dialogfelder sind Fenster, die häufig verwendet werden, um Informationen von einem Benutzer zu sammeln, um eine Funktion abzuschließen. Wenn ein Benutzer beispielsweise eine Datei öffnen möchte, wird das Dialogfeld "Datei öffnen " von einer Anwendung angezeigt, um den Dateinamen vom Benutzer abzurufen. Weitere Informationen finden Sie unter Übersicht über Dialogfelder.

Siehe auch