Übersicht über WPF-FensterWPF Windows Overview

Benutzer interagieren über Windows Windows Presentation Foundation mit eigenständigen WPF-Anwendungen (WPF).Users interact with Windows Presentation Foundation (WPF) standalone applications through windows. Die Hauptaufgabe eines Fensters besteht darin, Inhalt zu hosten, der Daten visuell darstellen kann und Benutzern die Interaktion mit Daten ermöglicht.The primary purpose of a window is to host content that visualizes data and enables users to interact with data. Eigen WPFWPF ständige Anwendungen stellen ihre eigenen Fenster mithilfe der Window -Klasse bereit.Standalone WPFWPF applications provide their own windows by using the Window class. In diesem Thema Window wird erläutert, bevor die Grundlagen der Erstellung und Verwaltung von Fenstern in eigenständigen Anwendungen behandelt werden.This topic introduces Window before covering the fundamentals of creating and managing windows in standalone applications.

Hinweis

Im Browser gehostete WPFWPF Anwendungen, XAML-Browseranwendungen (XAML browser applications; XBAPs)XAML browser applications (XBAPs) einschließlich und Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) loser Seiten, stellen keine eigenen Fenster bereit.Browser-hosted WPFWPF applications, including XAML-Browseranwendungen (XAML browser applications; XBAPs)XAML browser applications (XBAPs) and loose Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) pages, don't provide their own windows. Stattdessen werden Sie in Windows von Windows Internet Explorer bereitgestellt.Instead, they are hosted in windows provided by Windows Internet Explorer. Siehe Übersicht über WPF-XAML-Browser Anwendungen.See WPF XAML Browser Applications Overview.

Die FensterklasseThe Window Class

In der folgenden Abbildung werden die Bestandteile eines Fensters veranschaulicht:The following figure illustrates the constituent parts of a window:

Screenshot, der Fensterelemente zeigt.

Ein Fenster wird in zwei Bereiche geteilt: der Nicht-Clientbereich und der Clientbereich.A window is divided into two areas: the non-client area and client area.

Der nicht-Client Bereich eines Fensters wird von WPFWPF implementiert und enthält die Teile eines Fensters, die für die meisten Fenster gelten, einschließlich der folgenden:The non-client area of a window is implemented by WPFWPF and includes the parts of a window that are common to most windows, including the following:

  • RahmenA border.

  • TitelleisteA title bar.

  • SymbolAn icon.

  • Schaltflächen zum Minimieren, Maximieren und WiederherstellenMinimize, Maximize, and Restore buttons.

  • Schaltfläche SchließenA Close button.

  • Ein Systemmenü mit Menüelementen, mit denen Benutzer ein Fenster minimieren, maximieren, wiederherstellen, verschieben, schließen und dessen Größe ändern können.A System menu with menu items that allow users to minimize, maximize, restore, move, resize, and close a window.

Der Client Bereich eines Fensters ist der Bereich im nicht-Client Bereich eines Fensters und wird von Entwicklern verwendet, um anwendungsspezifische Inhalte wie Menüleisten, Symbolleisten und Steuerelemente hinzuzufügen.The client area of a window is the area within a window's non-client area and is used by developers to add application-specific content, such as menu bars, tool bars, and controls.

In WPFWPFwird ein Fenster von der Window -Klasse gekapselt, die Sie für folgende Aufgaben verwenden:In WPFWPF, a window is encapsulated by the Window class that you use to do the following:

  • Anzeigen eines FenstersDisplay a window.

  • Konfigurieren der Größe, Position und Darstellung eines FenstersConfigure the size, position, and appearance of a window.

  • Hosten von anwendungsspezifischem InhaltHost application-specific content.

  • Verwalten der Lebensdauer eines FenstersManage the lifetime of a window.

Implementieren eines FenstersImplementing a Window

Die Implementierung eines typischen Fensters umfasst Darstellung und Verhalten, wobei Darstellung definiert , wie ein Fenster für Benutzer und Verhalten aussieht, wie ein Fenster funktioniert, wenn Benutzer damit interagieren.The implementation of a typical window comprises both appearance and behavior, where appearance defines how a window looks to users and behavior defines the way a window functions as users interact with it. In WPFWPFkönnen Sie die Darstellung und das Verhalten eines Fensters mithilfe von Code oder XAMLXAML Markup implementieren.In WPFWPF, you can implement the appearance and behavior of a window using either code or XAMLXAML markup.

Im Allgemeinen wird jedoch das Aussehen eines Fensters mithilfe XAMLXAML von Markup implementiert, und das Verhalten wird mithilfe von Code Behind implementiert, wie im folgenden Beispiel gezeigt.In general, however, the appearance of a window is implemented using XAMLXAML markup, and its behavior is implemented using code-behind, as shown in the following example.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  
  <!-- Client area (for content) -->
  
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Damit eine Markup XAMLXAML Datei und eine Code-Behind-Datei zusammenarbeiten können, ist Folgendes erforderlich:To enable a XAMLXAML markup file and code-behind file to work together, the following are required:

  • Im Markup muss das Window -Element das x:Class -Attribut enthalten.In markup, the Window element must include the x:Class attribute. Wenn die Anwendung erstellt wird x:Class , bewirkt Microsoft-Build-Engine (MSBuild)Microsoft build engine (MSBuild) das vorhanden sein von in der Markup Datei, dass partial eine Klasse erstellt, Window die von abgeleitet wird und den Namen hat, x:Class der vom-Attribut angegeben wird.When the application is built, the existence of x:Class in the markup file causes Microsoft-Build-Engine (MSBuild)Microsoft build engine (MSBuild) to create a partial class that derives from Window and has the name that is specified by the x:Class attribute. Dies erfordert das Hinzufügen einer XMLXML Namespace Deklaration für XAMLXAML das Schema xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ().This requires the addition of an XMLXML namespace declaration for the XAMLXAML schema ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Die generierte partial -Klasse implementiert InitializeComponent die-Methode, die aufgerufen wird, um die Ereignisse zu registrieren und die Eigenschaften festzulegen, die im Markup implementiert werden.The generated partial class implements the InitializeComponent method, which is called to register the events and set the properties that are implemented in markup.

  • Bei Code-Behind muss die Klasse eine partial Klasse mit dem gleichen Namen sein, der im Markup durch das x:Class -Attribut angegeben ist, und Sie muss von Windowabgeleitet werden.In code-behind, the class must be a partial class with the same name that is specified by the x:Class attribute in markup, and it must derive from Window. Dadurch kann die Code-Behind-Datei mit der partial -Klasse verknüpft werden, die beim Erstellen der Anwendung für die Markup Datei generiert wird (siehe Erstellen einer WPF-Anwendung).This allows the code-behind file to be associated with the partial class that is generated for the markup file when the application is built (see Building a WPF Application).

  • Im Code-Behind muss die Window Klasse einen Konstruktor implementieren, der die InitializeComponent -Methode aufruft.In code-behind, the Window class must implement a constructor that calls the InitializeComponent method. InitializeComponentwird durch die generierte partial -Klasse der Markup Datei implementiert, um Ereignisse zu registrieren und im Markup definierte Eigenschaften festzulegen.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Hinweis

Wenn Sie dem Projekt mithilfe Window Microsoft Visual StudioMicrosoft Visual Studiovon ein neues hinzufügen, wird Window der mithilfe von Markup und Code Behind implementiert und umfasst die erforderliche Konfiguration zum Erstellen der Zuordnung zwischen dem Markup und den Code-Behind-Dateien als. hier beschrieben.When you add a new Window to your project by using Microsoft Visual StudioMicrosoft Visual Studio, the Window is implemented using both markup and code-behind, and includes the necessary configuration to create the association between the markup and code-behind files as described here.

Wenn diese Konfiguration vorhanden ist, können Sie sich darauf konzentrieren, das Aussehen des Fensters im XAMLXAML Markup zu definieren und dessen Verhalten in Code Behind zu implementieren.With this configuration in place, you can focus on defining the appearance of the window in XAMLXAML markup and implementing its behavior in code-behind. Das folgende Beispiel zeigt ein Fenster mit einer Schaltfläche, die XAMLXAML im Markup implementiert ist, und einen Ereignishandler für Click das-Ereignis der Schaltfläche, die in Code Behind implementiert ist.The following example shows a window with a button, implemented in XAMLXAML markup, and an event handler for the button's Click event, implemented in code-behind.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  <!-- Client area (for content) -->
  <Button Click="button_Click">Click This Button</Button>
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Button was clicked.")
        End Sub
    End Class
End Namespace

Konfigurieren einer Fensterdefinition für MSBuildConfiguring a Window Definition for MSBuild

Die Art und Weise, wie Sie Ihr Fenster implementieren, MSBuildMSBuildlegt fest, wie die Konfiguration fürHow you implement your window determines how it is configured for MSBuildMSBuild. Für ein Fenster, das sowohl XAMLXAML mit Markup als auch mit Code-Behind definiert wird:For a window that is defined using both XAMLXAML markup and code-behind:

  • XAMLXAMLMarkup Dateien werden als MSBuildMSBuild Page -Elemente konfiguriert.markup files are configured as MSBuildMSBuildPage items.

  • Code Behind-Dateien werden als MSBuildMSBuild Compile -Elemente konfiguriert.Code-behind files are configured as MSBuildMSBuildCompile items.

Dies wird in der folgenden MSBuildMSBuild Projektdatei gezeigt.This is shown in the following MSBuildMSBuild project file.

<Project ...  
                xmlns="http://schemas.microsoft.com/developer/msbuild/2003">  
    ...  
    <Page Include="MarkupAndCodeBehindWindow.xaml" />  
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />  
    ...  
</Project>  

Weitere Informationen zum entwickeln WPFWPF von Anwendungen finden Sie unter Building a WPF Application.For information about building WPFWPF applications, see Building a WPF Application.

FensterlebensdauerWindow Lifetime

Wie alle Klassen hat auch ein Fenster eine Lebensdauer, die mit dem erstmaligen Instanziieren beginnt. Anschließend wird es geöffnet, aktiviert, deaktiviert und schließlich geschlossen.As with any class, a window has a lifetime that begins when it is first instantiated, after which it is opened, activated and deactivated, and eventually closed.

Öffnen eines FenstersOpening a Window

Wenn Sie ein Fenster öffnen möchten, müssen Sie zuerst eine Instanz davon erstellen. Dies wird im folgenden Beispiel veranschaulicht.To open a window, you first create an instance of it, which is demonstrated in the following example.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    Startup="app_Startup">
</Application>
using System.Windows;
namespace SDKSample
{
    public partial class App : Application
    {
        void app_Startup(object sender, StartupEventArgs e)
        {
            // Create a window
            MarkupAndCodeBehindWindow window = new MarkupAndCodeBehindWindow();

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

In diesem Beispiel wird das MarkupAndCodeBehindWindow instanziiert, wenn die Anwendung gestartet wird. Dies tritt ein Startup , wenn das-Ereignis ausgelöst wird.In this example, the MarkupAndCodeBehindWindow is instantiated when the application starts, which occurs when the Startup event is raised.

Wenn ein Fenster instanziiert wird, wird automatisch ein Verweis darauf zu einer Liste von Fenstern hinzugefügt, die vom Application -Objekt verwaltet wird (siehe Application.Windows).When a window is instantiated, a reference to it is automatically added to a list of windows that is managed by the Application object (see Application.Windows). Außerdem wird das erste zu instanziierte Fenster standardmäßig Application als Hauptanwendungsfenster festgelegt (siehe Application.MainWindow).Additionally, the first window to be instantiated is, by default, set by Application as the main application window (see Application.MainWindow).

Das Fenster wird schließlich durch Aufrufen der Show -Methode geöffnet. das Ergebnis wird in der folgenden Abbildung dargestellt.The window is finally opened by calling the Show method; the result is shown in the following figure.

Ein durch Aufrufen von Window. Show geöffnetes Fenster

Ein Fenster, das durch Aufrufen Show von geöffnet wird, ist ein nicht modalem Fenster, was bedeutet, dass die Anwendung in einem Modus ausgeführt wird, der es Benutzern ermöglicht, andere Fenster in derselben Anwendung zu aktivieren.A window that is opened by calling Show is a modeless window, which means that the application operates in a mode that allows users to activate other windows in the same application.

Hinweis

ShowDialogwird aufgerufen, um Fenster (z. b. Dialogfelder Modal) zu öffnen.ShowDialog is called to open windows such as dialog boxes modally. Weitere Informationen finden Sie unter Übersicht über Dialog Felder .See Dialog Boxes Overview for more information.

Wenn Show aufgerufen wird, führt ein Fenster Initialisierungs Aufgaben aus, bevor es angezeigt wird, um die Infrastruktur zu erstellen, die es ermöglicht, Benutzereingaben zu empfangen.When Show is called, a window performs initialization work before it is shown to establish infrastructure that allows it to receive user input. Wenn das Fenster initialisiert wird, wird SourceInitialized das-Ereignis ausgelöst, und das Fenster wird angezeigt.When the window is initialized, the SourceInitialized event is raised and the window is shown.

Als Verknüpfung kann fest StartupUri gelegt werden, um das erste Fenster anzugeben, das beim Start einer Anwendung automatisch geöffnet wird.As a shortcut, StartupUri can be set to specify the first window that is opened automatically when an application starts.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="PlainWindow.xaml" />

Wenn die Anwendung gestartet wird, wird das Fenster, das durch StartupUri den Wert von angegeben wird, modelblily geöffnet. intern wird das Fenster Show durch Aufrufen der zugehörigen-Methode geöffnet.When the application starts, the window specified by the value of StartupUri is opened modelessly; internally, the window is opened by calling its Show method.

Besitz von FensternWindow Ownership

Ein Fenster, das mit der Show -Methode geöffnet wird, verfügt nicht über eine implizite Beziehung zu dem Fenster, das es erstellt hat. Benutzer können mit einem der beiden Fenster interagieren, was bedeutet, dass beide Fenster folgende Aktionen ausführen können:A window that is opened by using the Show method does not have an implicit relationship with the window that created it; users can interact with either window independently of the other, which means that either window can do the following:

  • Deckt die andere ab (es sei denn, für eines Topmost der Fenster ist truedie-Eigenschaft auf festgelegt).Cover the other (unless one of the windows has its Topmost property set to true).

  • Es wird minimiert, maximiert und wiederhergestellt, ohne das andere zu beeinflussen.Be minimized, maximized, and restored without affecting the other.

Bei einigen Fenstern ist eine Beziehung zu dem Fenster erforderlich, durch das es geöffnet wird.Some windows require a relationship with the window that opens them. Beispielsweise kann eine integrierte Entwicklungsumgebung (IDE) Eigenschaften Fenster und Tool Fenster öffnen, deren typisches Verhalten darin besteht, das Fenster abzudecken, in dem Sie erstellt werden.For example, an Integrated Development Environment (IDE) application may open property windows and tool windows whose typical behavior is to cover the window that creates them. Darüber hinaus sollten solche Fenster stets mit den Fenstern geschlossen, minimiert, maximiert und wiederhergestellt werden, durch die sie erstellt wurden.Furthermore, such windows should always close, minimize, maximize, and restore in concert with the window that created them. Eine solche Beziehung kann hergestellt werden, indem ein Fenster in einem anderen Fenster erstellt wird. Dies wird Owner erreicht, indem die-Eigenschaft des Fensters im Besitz mit einem Verweis auf das Besitzer Fensterfestgelegt wird.Such a relationship can be established by making one window own another, and is achieved by setting the Owner property of the owned window with a reference to the owner window. Dies wird im folgenden Beispiel gezeigt.This is shown in the following example.

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();
' Create a window and make this window its owner
Dim ownedWindow As New Window()
ownedWindow.Owner = Me
ownedWindow.Show()

Nach Einrichten des Besitzes:After ownership is established:

  • Das im Besitz befindliche Fenster kann auf das Besitzer Fenster verweisen, indem der Wert Owner der zugehörigen-Eigenschaft überprüft wird.The owned window can reference its owner window by inspecting the value of its Owner property.

  • Das Besitzer Fenster kann alle Windows-Besitzer ermitteln, indem er den Wert seiner OwnedWindows -Eigenschaft prüft.The owner window can discover all the windows it owns by inspecting the value of its OwnedWindows property.

Verhindern der FensteraktivierungPreventing Window Activation

Es gibt Szenarien, in denen Windows nicht aktiviert werden soll, wenn es angezeigt wird, z. b. Konversationsfenster einer Internet Messenger-Anwendung oder Benachrichtigungsfenster einer e-Mail-Anwendung.There are scenarios where windows should not be activated when shown, such as conversation windows of an Internet messenger-style application or notification windows of an email application.

Wenn die Anwendung über ein Fenster verfügt, das nicht aktiviert werden soll, wenn Sie angezeigt ShowActivated wird, false können Sie die Show -Eigenschaft auf festlegen, bevor Sie die-Methode zum ersten Mal aufrufen.If your application has a window that shouldn't be activated when shown, you can set its ShowActivated property to false before calling the Show method for the first time. Daraus folgt:As a consequence:

  • Das Fenster wird nicht aktiviert.The window is not activated.

  • Das- Activated Ereignis des Fensters wird nicht ausgelöst.The window's Activated event is not raised.

  • Das momentan aktivierte Fenster bleibt aktiviert.The currently activated window remains activated.

Das Fenster wird jedoch aktiviert, sobald der Benutzer es durch Klicken auf den Client- oder Nicht-Clientbereich aktiviert.The window will become activated, however, as soon as the user activates it by clicking either the client or non-client area. In diesem Fall gilt Folgendes:In this case:

  • Das Fenster wird aktiviert.The window is activated.

  • Das- Activated Ereignis des Fensters wird ausgelöst.The window's Activated event is raised.

  • Das zuvor aktivierte Fenster wird deaktiviert.The previously activated window is deactivated.

  • Die-und Deactivated Activated -Ereignisse des Fensters werden dann wie erwartet als Reaktion auf Benutzeraktionen ausgelöst.The window's Deactivated and Activated events are subsequently raised as expected in response to user actions.

Aktivieren von FensternWindow Activation

Wenn ein Fenster zum ersten Mal geöffnet wird, wird es zum aktiven Fenster (es sei denn ShowActivated , es falsewird angezeigt, wenn auf festgelegt ist).When a window is first opened, it becomes the active window (unless it is shown with ShowActivated set to false). Das aktive Fenster ist das Fenster, das zurzeit Benutzereingaben erfasst, z. b. Tastenanschläge und Mausklicks.The active window is the window that is currently capturing user input, such as key strokes and mouse clicks. Wenn ein Fenster aktiv wird, löst es das Activated -Ereignis aus.When a window becomes active, it raises the Activated event.

Hinweis

Wenn ein Fenster zum ersten Mal geöffnet wird Loaded , ContentRendered werden das-Ereignis und das Activated -Ereignis erst ausgelöst, nachdem das-Ereignis ausgelöst wurde.When a window is first opened, the Loaded and ContentRendered events are raised only after the Activated event is raised. Vor diesem Hintergrund kann ein Fenster als geöffnet angesehen werden, wenn ContentRendered ausgelöst wird.With this in mind, a window can effectively be considered opened when ContentRendered is raised.

Nachdem ein Fenster aktiv geworden ist, kann ein Benutzer ein weiteres Fenster in derselben Anwendung oder eine andere Anwendung aktivieren.After a window becomes active, a user can activate another window in the same application, or activate another application. Wenn dies der Fall ist, wird das derzeit aktive Fenster deaktiviert und Deactivated löst das-Ereignis aus.When that happens, the currently active window becomes deactivated and raises the Deactivated event. Ebenso wird, wenn der Benutzer ein momentan deaktiviertes Fenster auswählt, das Fenster Activated erneut aktiviert und ausgelöst.Likewise, when the user selects a currently deactivated window, the window becomes active again and Activated is raised.

Ein häufiger Grund für die Activated Handhabung Deactivated von und ist das Aktivieren und Deaktivieren von Funktionen, die nur ausgeführt werden können, wenn ein Fenster aktiv ist.One common reason to handle Activated and Deactivated is to enable and disable functionality that can only run when a window is active. In einigen Fenstern wird beispielsweise interaktiver Inhalt angezeigt, der andauernde Benutzereingaben oder Aufmerksamkeit erfordert, wie beispielsweise Spiele und Videoplayer.For example, some windows display interactive content that requires constant user input or attention, including games and video players. Das folgende Beispiel ist ein vereinfachter Video Player, der veranschaulicht, Activated wie Deactivated und dieses Verhalten implementiert werden.The following example is a simplified video player that demonstrates how to handle Activated and Deactivated to implement this behavior.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CustomMediaPlayerWindow"
    Activated="window_Activated"
    Deactivated="window_Deactivated">

    <!-- Media Player -->
    <MediaElement 
      Name="mediaElement" 
      Stretch="Fill" 
      LoadedBehavior="Manual" 
      Source="numbers.wmv" />

</Window>
using System;
using System.Windows;

namespace SDKSample
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow()
        {
            InitializeComponent();
        }

        void window_Activated(object sender, EventArgs e)
        {
            // Recommence playing media if window is activated
            this.mediaElement.Play();
        }

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

Imports System
Imports System.Windows

Namespace SDKSample
    Partial Public Class CustomMediaPlayerWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub window_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Recommence playing media if window is activated
            Me.mediaElement.Play()
        End Sub

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

Andere Anwendungstypen führen im Hintergrund möglicherweise weiterhin Code aus, nachdem ein Fenster deaktiviert wurde.Other types of applications may still run code in the background when a window is deactivated. Ein E-Mail-Client kann z. B. weiterhin den E-Mail-Server abrufen, während der Benutzer andere Anwendungen verwendet.For example, a mail client may continue polling the mail server while the user is using other applications. Während das Hauptfenster deaktiviert ist, stellen derartige Anwendungen häufig zusätzliches oder anderes Verhalten zur Verfügung.Applications like these often provide different or additional behavior while the main window is deactivated. Im Hinblick auf das E-Mail-Programm kann das sowohl das Hinzufügen des neuen E-Mail-Elements zum Posteingang als auch eines Benachrichtigungssymbol in die Taskleiste bedeuten.With respect to the mail program, this may mean both adding the new mail item to the inbox and adding a notification icon to the system tray. Ein Benachrichtigungssymbol muss nur angezeigt werden, wenn das Mail Fenster nicht aktiv ist. Dies kann durch Überprüfen IsActive der-Eigenschaft bestimmt werden.A notification icon need only be displayed when the mail window isn't active, which can be determined by inspecting the IsActive property.

Wenn eine Hintergrundaufgabe abgeschlossen ist, kann es sein, dass ein Fenster den Benutzer durch Aufrufen Activate der-Methode dringender benachrichtigen soll.If a background task completes, a window may want to notify the user more urgently by calling Activate method. Wenn der Benutzer mit einer anderen Anwendung interagiert, Activate die beim Aufrufen von aktiviert ist, blinkt die Task leisten Schaltfläche des Fensters.If the user is interacting with another application activated when Activate is called, the window's taskbar button flashes. Wenn ein Benutzer mit der aktuellen Anwendung interagiert, wird Activate durch den Aufruf von das Fenster in den Vordergrund gebracht.If a user is interacting with the current application, calling Activate will bring the window to the foreground.

Hinweis

Sie können die Aktivierung des Anwendungsbereichs mithilfe der Application.Activated Ereignisse Application.Deactivated und behandeln.You can handle application-scope activation using the Application.Activated and Application.Deactivated events.

Schließen eines FenstersClosing a Window

Die Lebensdauer eines Fensters endet, wenn der Benutzer das Fenster schließt.The life of a window starts coming to an end when a user closes it. Ein Fenster kann mithilfe der Elemente im Nicht-Clientbereich geschlossen werden, z. B. mit den folgenden:A window can be closed by using elements in the non-client area, including the following:

  • Das Schließ Ende Element im System Menü.The Close item of the System menu.

  • Drücken von ALT+F4.Pressing ALT+F4.

  • Drücken der Schaltfläche Schließen .Pressing the Close button.

Zum Schließen eines Fensters können Sie dem Clientbereich weitere Mechanismen hinzufügen. Zu den gebräuchlichsten zählen:You can provide additional mechanisms to the client area to close a window, the more common of which include the following:

  • Ein Beendigungs Element im Menü Datei (in der Regel für Hauptanwendungsfenster).An Exit item in the File menu, typically for main application windows.

  • Ein Schließ Ende Element im Menü Datei , in der Regel in einem sekundären Anwendungsfenster.A Close item in the File menu, typically on a secondary application window.

  • Eine Schaltfläche Abbrechen (in der Regel in einem modalen Dialogfeld).A Cancel button, typically on a modal dialog box.

  • Eine Schaltfläche Schließen (in der Regel in einem nicht modalem Dialogfeld).A Close button, typically on a modeless dialog box.

Um ein Fenster als Reaktion auf einen dieser benutzerdefinierten Mechanismen zu schließen, müssen Sie die Close -Methode aufzurufen.To close a window in response to one of these custom mechanisms, you need to call the Close method. Im folgenden Beispiel wird die Fähigkeit zum Schließen eines Fensters implementiert, indem im Menü Datei die Option Beenden ausgewählt wird.The following example implements the ability to close a window by choosing the Exit on the File menu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.WindowWithFileExit">
  
  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>
  
</Window>
using System.Windows;

namespace SDKSample
{
    public partial class WindowWithFileExit : System.Windows.Window
    {
        public WindowWithFileExit()
        {
            InitializeComponent();
        }

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class WindowWithFileExit
        Inherits System.Windows.Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub fileExitMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Close this window
            Me.Close()
        End Sub
    End Class
End Namespace

Wenn ein Fenster geschlossen wird, werden zwei Ereignisse ausgelöst Closing : Closedund.When a window closes, it raises two events: Closing and Closed.

Closingwird ausgelöst, bevor das Fenster geschlossen wird, und stellt einen Mechanismus bereit, mit dem die Fenster Schließung verhindert werden kann.Closing is raised before the window closes, and it provides a mechanism by which window closure can be prevented. Der häufigste Grund, um das Schließen eines Fensters zu verhindern, liegt darin, dass Fensterinhalt geänderte Daten enthält.One common reason to prevent window closure is if window content contains modified data. In dieser Situation kann das Closing Ereignis behandelt werden, um zu bestimmen, ob Daten geändert werden, und wenn dies der Fall ist, um den Benutzer zu Fragen, ob das Schließen des Fensters fortgesetzt werden soll, ohne die Daten zu speichern oder die Fenster Schließung abzubrechen.In this situation, the Closing event can be handled to determine whether data is dirty and, if so, to ask the user whether to either continue closing the window without saving the data or to cancel window closure. Das folgende Beispiel zeigt die wichtigsten Aspekte der Behandlung Closingvon.The following example shows the key aspects of handling Closing.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;

        public DataWindow()
        {
            InitializeComponent();
        }

        void documentTextBox_TextChanged(object sender, EventArgs e)
        {
            this.isDataDirty = true;
        }

        void DataWindow_Closing(object sender, CancelEventArgs e)
        {
            MessageBox.Show("Closing called");

            // If data is dirty, notify user and ask for a response
            if (this.isDataDirty)
            {
                string msg = "Data is dirty. Close without saving?";
                MessageBoxResult result = 
                  MessageBox.Show(
                    msg, 
                    "Data App", 
                    MessageBoxButton.YesNo, 
                    MessageBoxImage.Warning);
                if (result == MessageBoxResult.No)
                {
                    // If user doesn't want to close, cancel closure
                    e.Cancel = true;
                }
            }
        }
    }
}
Imports System ' EventArgs
Imports System.ComponentModel ' CancelEventArgs
Imports System.Windows ' window

Namespace VisualBasic
    Partial Public Class DataWindow
        Inherits Window
        ' Is data dirty
        Private isDataDirty As Boolean = False

        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub documentTextBox_TextChanged(ByVal sender As Object, ByVal e As EventArgs)
            Me.isDataDirty = True
        End Sub

        Private Sub DataWindow_Closing(ByVal sender As Object, ByVal e As CancelEventArgs)
            MessageBox.Show("Closing called")

            ' If data is dirty, notify user and ask for a response
            If Me.isDataDirty Then
                Dim msg As String = "Data is dirty. Close without saving?"
                Dim result As MessageBoxResult = MessageBox.Show(msg, "Data App", MessageBoxButton.YesNo, MessageBoxImage.Warning)
                If result = MessageBoxResult.No Then
                    ' If user doesn't want to close, cancel closure
                    e.Cancel = True
                End If
            End If
        End Sub
    End Class
End Namespace

An Closing den Ereignishandler wird ein CancelEventArgsübermittelt, der Boolean die Cancel Eigenschaft implementiert, die true Sie auf festlegen, um zu verhindern, dass ein Fenster geschlossen wird.The Closing event handler is passed a CancelEventArgs, which implements the BooleanCancel property that you set to true to prevent a window from closing.

Wenn Closing nicht behandelt wird oder wenn es behandelt, aber nicht abgebrochen wird, wird das Fenster geschlossen.If Closing is not handled, or it is handled but not canceled, the window will close. Unmittelbar bevor ein Fenster geschlossen wird, Closed wird ausgelöst.Just before a window actually closes, Closed is raised. An dieser Stelle kann das Schließen des Fensters nicht verhindert werden.At this point, a window cannot be prevented from closing.

Hinweis

Eine Anwendung kann so konfiguriert werden, dass Sie automatisch heruntergefahren wird, wenn das Haupt Anwendungs MainWindowFenster geschlossen wird (siehe) oder das letzte Fenster geschlossen wird.An application can be configured to shut down automatically when either the main application window closes (see MainWindow) or the last window closes. Ausführliche Informationen finden Sie unter ShutdownMode.For details, see ShutdownMode.

Während ein Fenster durch Mechanismen, die in den nicht-Client-und Client Bereichen bereitgestellt werden, explizit geschlossen werden kann, kann ein Fenster aufgrund des Verhaltens in anderen Teilen der Anwendung oder WindowsWindows, einschließlich der folgenden, implizit geschlossen werden:While a window can be explicitly closed through mechanisms provided in the non-client and client areas, a window can also be implicitly closed as a result of behavior in other parts of the application or WindowsWindows, including the following:

  • Ein Benutzer meldet sich ab oder fährt Windows herunter.A user logs off or shuts down Windows.

  • Der Besitzer eines Fensters wird geschlossen ( OwnerWeitere Informationen finden Sie unter).A window's owner closes (see Owner).

  • Das Hauptanwendungsfenster ist geschlossen, ShutdownMode und OnMainWindowCloseist.The main application window is closed and ShutdownMode is OnMainWindowClose.

  • Shutdown wird aufgerufen.Shutdown is called.

Hinweis

Ein Fenster kann nicht erneut geöffnet werden, nachdem es geschlossen wurde.A window cannot be reopened after it is closed.

Ereignisse in der Lebensdauer eines FenstersWindow Lifetime Events

Die folgende Abbildung zeigt die Reihenfolge der Prinzipal Ereignisse in der Lebensdauer eines Fensters:The following illustration shows the sequence of the principal events in the lifetime of a window:

Diagramm, in dem Ereignisse in der Lebensdauer eines Fensters angezeigt werden.

Die folgende Abbildung zeigt die Reihenfolge der Prinzipal Ereignisse in der Lebensdauer eines Fensters, das ohne Aktivierung angezeigtShowActivated wird (wird false auf festgelegt, bevor das Fenster angezeigt wird):The following illustration shows the sequence of the principal events in the lifetime of a window that is shown without activation (ShowActivated is set to false before the window is shown):

Diagramm, in dem Ereignisse in der Lebensdauer eines Fensters ohne Aktivierung angezeigt werden.

FensterpositionWindow Location

Solange ein Fenster geöffnet ist, befindet sich dessen Position in der x- und y-Dimension relativ zum Desktop.While a window is open, it has a location in the x and y dimensions relative to the desktop. Dieser Speicherort kann ermittelt werden, indem die Left - Top Eigenschaft bzw. die-Eigenschaft überprüft wird.This location can be determined by inspecting the Left and Top properties, respectively. Sie können diese Eigenschaften festlegen, um die Position des Fensters zu ändern.You can set these properties to change the location of the window.

Sie können auch den ursprünglichen Speicherort Window eines angeben, wenn er zum ersten Mal angezeigt wird, indem Sie die WindowStartupLocation - WindowStartupLocation Eigenschaft mit einem der folgenden Enumerationswerte festlegen:You can also specify the initial location of a Window when it first appears by setting the WindowStartupLocation property with one of the following WindowStartupLocation enumeration values:

Wenn der Start ManualSpeicherort als angegeben wird und die-Eigenschaft und die- Top Eigenschaft nicht Window festgelegt wurden, fragt Windows nach einem Speicherort, der Left in angezeigt wird.If the startup location is specified as Manual, and the Left and Top properties have not been set, Window will ask Windows for a location to appear in.

Oberstes Fenster und Z-ReihenfolgeTopmost Windows and Z-Order

Neben der X- und Y-Position verfügt das Fenster auch über eine Position in der Z-Dimension, die dessen vertikale Position im Verhältnis zu anderen Fenstern bestimmt.Besides having an x and y location, a window also has a location in the z dimension, which determines its vertical position with respect to other windows. Dies wird als Z-Reihenfolge des Fensters bezeichnet. Davon gibt es zwei Typen: die normale Z-Reihenfolge und die oberste Z-Reihenfolge.This is known as the window's z-order, and there are two types: normal z-order and topmost z-order. Die Position eines Fensters in der normalen z-Reihenfolge hängt davon ab, ob es zurzeit aktiv ist oder nicht.The location of a window in the normal z-order is determined by whether it is currently active or not. Standardmäßig befindet sich ein Fenster in der normalen Z-Reihenfolge.By default, a window is located in the normal z-order. Der Speicherort eines Fensters in der obersten z-Reihenfolge hängt auch davon ab, ob er derzeit aktiv ist oder nicht.The location of a window in the topmost z-order is also determined by whether it is currently active or not. Darüber hinaus befinden sich Fenster in der obersten Z-Reihenfolge stets über den Fenstern in der normalen Z-Reihenfolge.Furthermore, windows in the topmost z-order are always located above windows in the normal z-order. Ein Fenster befindet sich in der obersten z-Reihenfolge, indem die Topmost zugehörige true-Eigenschaft auf festgelegt wird.A window is located in the topmost z-order by setting its Topmost property to true.

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

Innerhalb jeder Z-Reihenfolge wird das aktuell aktive Fenster über allen anderen Fenstern derselben Z-Reihenfolge angezeigt.Within each z-order, the currently active window appears above all other windows in the same z-order.

FenstergrößeWindow Size

Neben einem Desktop Speicherort hat ein Fenster eine Größe, die von mehreren Eigenschaften bestimmt wird, einschließlich der verschiedenen Eigenschaften für Breite und Höhe SizeToContentund.Besides having a desktop location, a window has a size that is determined by several properties, including the various width and height properties and SizeToContent.

MinWidth, Width undMaxWidth werden verwendet, um den breiten Bereich zu verwalten, den ein Fenster während seiner Lebensdauer aufweisen kann, und wie im folgenden Beispiel gezeigt.MinWidth, Width, and MaxWidth are used to manage the range of widths that a window can have during its lifetime, and are configured as shown in the following example.

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

Die Fensterhöhe wird von MinHeight, Heightund MaxHeightverwaltet und wie im folgenden Beispiel gezeigt konfiguriert.Window height is managed by MinHeight, Height, and MaxHeight, and are configured as shown in the following example.

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

Da die verschiedenen Werte für die Breite und für die Höhe jeweils einen Bereich angeben, kann die Breite und Höhe eines in der Größe veränderbaren Fensters irgendwo innerhalb des angegebenen Bereichs für die entsprechende Dimension liegen.Because the various width values and height values each specify a range, it is possible for the width and height of a resizable window to be anywhere within the specified range for the respective dimension. Um die aktuelle Breite und Höhe zu ermitteln, ActualWidth über ActualHeightprüfen Sie bzw.To detect its current width and height, inspect ActualWidth and ActualHeight, respectively.

Wenn Sie möchten, dass die Breite und Höhe des Fensters auf die Größe des Fenster Inhalts zugeschnitten ist, können Sie die SizeToContent -Eigenschaft mit den folgenden Werten verwenden:If you'd like the width and height of your window to have a size that fits to the size of the window's content, you can use the SizeToContent property, which has the following values:

  • Manual.Manual. Keine Auswirkung (Standard).No effect (default).

  • WidthWidth. An Inhalts Breite anpassen, was die gleiche Wirkung hat wie das Festlegen MinWidth von MaxWidth sowohl als auch der Breite des Inhalts.Fit to content width, which has the same effect as setting both MinWidth and MaxWidth to the width of the content.

  • HeightHeight. An die Höhe des Inhalts anpassen. Dies hat die gleiche Wirkung wie MinHeight das MaxHeight Festlegen von und auf die Höhe des Inhalts.Fit to content height, which has the same effect as setting both MinHeight and MaxHeight to the height of the content.

  • WidthAndHeightWidthAndHeight. An Inhalts Breite und-Höhe anpassen, was die gleiche Wirkung hat wie das MinHeight festlegen MaxHeight von und auf die Höhe des MinWidth Inhalts und das Festlegen von MaxWidth und auf die Breite des Inhalts.Fit to content width and height, which has the same effect as setting both MinHeight and MaxHeight to the height of the content, and setting both MinWidth and MaxWidth to the width of the content.

Im folgenden Beispiel wird ein Fenster dass die Größe automatisch an seinen Inhalt vertikal und horizontal an, wenn es zuerst angezeigt wird.The following example shows a window that automatically sizes to fit its content, both vertically and horizontally, when first shown.

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

Im folgenden Beispiel wird gezeigt, wie die SizeToContent -Eigenschaft im Code festgelegt wird, um anzugeben, wie die Größe eines Fensters an seinen Inhalt angepasst wird.The following example shows how to set the SizeToContent property in code to specify how a window resizes to fit its content .


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

Rangfolge der GrößeneigenschaftenOrder of Precedence for Sizing Properties

Im Wesentlichen werden die verschiedenen Größeneigenschaften eines Fensters kombiniert, um den Bereich der Breite und der Höhe für ein in der Größe veränderbares Fenster zu definieren.Essentially, the various sizes properties of a window combine to define the range of width and height for a resizable window. Um sicherzustellen, dass ein gültiger Bereich Window beibehalten wird, wertet die Werte der Size-Eigenschaften anhand der folgenden Rangfolge aus.To ensure a valid range is maintained, Window evaluates the values of the size properties using the following orders of precedence.

Für Höheneigenschaften:For Height Properties:

  1. FrameworkElement.MinHeight

  2. FrameworkElement.MaxHeight

  3. SizeToContent.Height/SizeToContent.WidthAndHeight

  4. FrameworkElement.Height

Für Breiteneigenschaften:For Width Properties:

  1. FrameworkElement.MinWidth

  2. FrameworkElement.MaxWidth

  3. SizeToContent.Width/SizeToContent.WidthAndHeight

  4. FrameworkElement.Width

Die Rangfolge kann auch die Größe eines Fensters bestimmen, wenn es maximiert ist, das mit der WindowState -Eigenschaft verwaltet wird.The order of precedence can also determine the size of a window when it is maximized, which is managed with the WindowState property.

FensterzustandWindow State

Während der Lebensdauer eines in der Größe veränderbaren Fenster kann dieses über drei Zustände verfügen: normal, minimiert und maximiert.During the lifetime of a resizable window, it can have three states: normal, minimized, and maximized. Ein Fenster mit einem normalen Zustand ist der Standardzustand eines Fensters.A window with a normal state is the default state of a window. Ein Benutzer kann ein Fenster mit diesem Zustand verschieben und dessen Größe ändern, indem er den Ziehpunkt zur Größenänderung oder den Rahmen verwendet, sofern er in der Größe veränderbar ist.A window with this state allows a user to move and resize it by using a resize grip or the border, if it is resizable.

Ein Fenster mit einem minimierten Zustand wird auf die Task leisten Schaltfläche reduziert true, wenn ShowInTaskbar auf festgelegt ist. andernfalls wird es auf die kleinste mögliche Größe reduziert, und es kann sich in der linken unteren Ecke des Desktops wiederholen.A window with a minimized state collapses to its task bar button if ShowInTaskbar is set to true; otherwise, it collapses to the smallest possible size it can be and relocates itself to the bottom-left corner of the desktop. 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.Neither type of minimized window can be resized using a border or resize grip, although a minimized window that isn't shown in the task bar can be dragged around the desktop.

Ein Fenster mit einem maximierten Zustand wird auf die maximal zulässige Größe erweitert. Dies ist nur so groß wie MaxWidthdie Eigenschaften, MaxHeightund SizeToContent .A window with a maximized state expands to the maximum size it can be, which will only be as large as its MaxWidth, MaxHeight, and SizeToContent properties dictate. Wie ein minimiertes Fenster kann auch ein maximiertes Fenster nicht mithilfe des Ziehpunkts zur Größenänderung oder durch Ziehen des Rahmens in seiner Größe verändert werden.Like a minimized window, a maximized window cannot be resized by using a resize grip or by dragging the border.

Hinweis

Die Werte der TopEigenschaften, Left, Widthund Height eines Fensters stellen immer die Werte für den normalen Zustand dar, auch wenn das Fenster derzeit maximiert oder minimiert ist.The values of the Top, Left, Width, and Height properties of a window always represent the values for the normal state, even when the window is currently maximized or minimized.

Der Zustand eines Fensters kann durch Festlegen der WindowState -Eigenschaft konfiguriert werden, die einen der folgenden WindowState Enumerationswerte aufweisen kann:The state of a window can be configured by setting its WindowState property, which can have one of the following WindowState enumeration values:

Im folgenden Beispiel wird veranschaulicht, wie Sie ein Fenster erstellen, das beim Öffnen als maximiert angezeigt wird.The following example shows how to create a window that is shown as maximized when it opens.

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

Im Allgemeinen sollten Sie festlegen WindowState , um den ursprünglichen Zustand eines Fensters zu konfigurieren.In general, you should set WindowState to configure the initial state of a window. Wenn ein in der Größe veränderbares Fenster angezeigt wird, können die Benutzer die Schaltflächen zum Minimieren, Maximieren oder Wiederherstellen auf der Titelleiste des Fensters aktivieren, um den Fensterzustand zu ändern.Once a resizable window is shown, users can press the minimize, maximize, and restore buttons on the window's title bar to change the window state.

FensterdarstellungWindow Appearance

Sie ändern die Darstellung des Clientbereichs eines Fensters, indem Sie fensterspezifischen Inhalt hinzufügen, z. B. Schaltflächen, Bezeichnungen und Textfelder.You change the appearance of the client area of a window by adding window-specific content to it, such as buttons, labels, and text boxes. Um den nicht-Client Bereich zu konfigurieren Window , stellt verschiedene Eigenschaften bereit. Icon dazu gehören das Festlegen des Symbol eines Title Fensters und das Festlegen seines Titels.To configure the non-client area, Window provides several properties, which include Icon to set a window's icon and Title to set its title.

Außerdem können Sie die Darstellung und das Verhalten des Rahmens im Nicht-Clientbereich ändern, indem Sie den Größenänderungsmodus, den Fensterstil und die Tatsache konfigurieren, ob es als Schaltfläche in der Desktoptaskleiste angezeigt wird.You can also change the appearance and behavior of non-client area border by configuring a window's resize mode, window style, and whether it appears as a button in the desktop task bar.

GrößenänderungsmodusResize Mode

Abhängig von der WindowStyle Eigenschaft können Sie steuern, wie (und ob) Benutzer die Größe des Fensters ändern können.Depending on the WindowStyle property, you can control how (and if) users can resize the window. Die Auswahl des Fenster Stils wirkt sich darauf aus, ob ein Benutzer die Größe des Fensters ändern kann, indem er seinen Rahmen mit der Maus zieht, ob die Schaltflächen minimieren, maximierenund Größe ändern im nicht-Client Bereich angezeigt werden, und ob Sie angezeigt werden, wenn Sie angezeigt werden. wodurch.The choice of window style affects whether a user can resize the window by dragging its border with the mouse, whether the Minimize, Maximize, and Resize buttons appear on the non-client area, and, if they do appear, whether they are enabled.

Sie können konfigurieren, wie die Größe eines Fensters geändert wird ResizeMode , indem Sie die zugehörige-Eigenschaft festlegen ResizeMode , die einen der folgenden Enumerationswerte aufweisen kann:You can configure how a window resizes by setting its ResizeMode property, which can be one of the following ResizeMode enumeration values:

Wie bei WindowStyleist es unwahrscheinlich, dass sich der Größen Änderungs Modus eines Fensters während seiner Lebensdauer ändert. Dies bedeutet, dass Sie ihn wahrscheinlich von XAMLXAML Markup festlegen.As with WindowStyle, the resize mode of a window is unlikely to change during its lifetime, which means that you'll most likely set it from XAMLXAML markup.

<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 wieder hergestellt wird, indem WindowState Sie die-Eigenschaft überprüfen.Note that you can detect whether a window is maximized, minimized, or restored by inspecting the WindowState property.

FensterstilWindow Style

Der Rahmen, der vom Nicht-Clientbereich eines Fensters verfügbar gemacht wird, eignet sich für die meisten Anwendungen.The border that is exposed from the non-client area of a window is suitable for most applications. Unter bestimmten Umständen werden je nach Fenstertyp dennoch andere Rahmentypen oder überhaupt keine Rahmen benötigt.However, there are circumstances where different types of borders are needed, or no borders are needed at all, depending on the type of window.

Um zu steuern, welche Art von Rahmen ein Fenster erhält, legen WindowStyle Sie dessen-Eigenschaft mit einem der folgenden Werte WindowStyle der-Enumeration fest:To control what type of border a window gets, you set its WindowStyle property with one of the following values of the WindowStyle enumeration:

Die Auswirkungen dieser Fenster Stile sind in der folgenden Abbildung dargestellt:The effect of these window styles are illustrated in the following figure:

Abbildung der Fensterrahmen Stile.

Sie können entweder WindowStyle XAMLXAML mithilfe von Markup oder Code festlegen, da es unwahrscheinlich ist, dass es sich während der Lebensdauer eines Fensters ändert, wird es wahrscheinlich XAMLXAML mit Markup konfiguriert.You can set WindowStyle using either XAMLXAML markup or code; because it is unlikely to change during the lifetime of a window, you will most likely configure it using XAMLXAML markup.

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

Nicht rechteckiger FensterstilNon-Rectangular Window Style

Es gibt auch Situationen, in denen die Rahmen WindowStyle Stile, die Ihnen die Möglichkeit bieten, nicht ausreichen.There are also situations where the border styles that WindowStyle allows you to have are not sufficient. Beispielsweise können Sie eine Anwendung mit einem nicht rechteckigen Rahmen erstellen, wie Microsoft Windows Media PlayerMicrosoft Windows Media Player z. b. verwendet.For example, you may want to create an application with a non-rectangular border, like Microsoft Windows Media PlayerMicrosoft Windows Media Player uses.

Sehen Sie sich beispielsweise das in der folgenden Abbildung gezeigte Sprechblasen Fenster an:For example, consider the speech bubble window shown in the following figure:

Ein Sprechblasen Fenster mit dem Text Drag Me.

Diese Art von Fenster kann erstellt werden, indem die WindowStyle -Eigenschaft Noneauf festgelegt wird, und mit Window spezieller Unterstützung für Transparenz.This type of window can be created by setting the WindowStyle property to None, and by using special support that Window has for transparency.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="None"
    AllowsTransparency="True"
    Background="Transparent">
</Window>

Durch diese Kombination von Werten wird das Fenster angewiesen, ein vollkommen transparentes Rendering zu übernehmen.This combination of values instructs the window to render completely transparent. In diesem Zustand können die Zusatzelemente des Nicht-Clientbereichs des Fensters (das Menü „Schließen“, die Schaltflächen „Minimieren“, „Maximieren“ und „Wiederherstellen“ usw.) nicht verwendet werden.In this state, the window's non-client area adornments (the Close menu, Minimize, Maximize, and Restore buttons, and so on) cannot be used. Folglich müssen Sie Ihre eigenen bereitstellen.Consequently, you need to provide your own.

Vorhandensein der TaskleisteTask Bar Presence

Die Standarddarstellung eines Fensters umfasst eine Task leisten Schaltfläche, wie in der folgenden Abbildung dargestellt:The default appearance of a window includes a taskbar button, like the one shown in the following figure:

Screenshot, der ein Fenster mit einer Task leisten Schaltfläche anzeigt.

Einige Windows-Typen verfügen nicht über eine Task leisten Schaltfläche, z. b. Meldungs Felder und Dialogfelder (siehe Übersicht über Dialogfelder).Some types of windows don't have a task bar button, such as message boxes and dialog boxes (see Dialog Boxes Overview). Sie können steuern, ob die Task leisten Schaltfläche für ein Fenster angezeigt wird ShowInTaskbar , indemtrue Sie die-Eigenschaft festlegen (standardmäßig).You can control whether the task bar button for a window is shown by setting the ShowInTaskbar property (true by default).

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

SicherheitsüberlegungenSecurity Considerations

Windowerfordert UnmanagedCode die-Sicherheits Berechtigung, um instanziiert zu werden.Window requires UnmanagedCode security permission to be instantiated. Bei Anwendungen, die auf dem lokalen Computer installiert und gestartet werden, wird dies durch die Berechtigungen abgedeckt, die der Anwendung gewährt werden.For applications installed on and launched from the local machine, this falls within the set of permissions that are granted to the application.

Dies liegt jedoch außerhalb der Berechtigungs Sätze, die Anwendungen gewährt werden, die über die Internet-oder lokale Intranetzone mithilfe von ClickOnce gestartet werden.However, this falls outside the set of permissions granted to applications that are launched from the Internet or Local intranet zone using ClickOnce. Folglich erhalten Benutzer eine ClickOnce-Sicherheitswarnung und müssen den Berechtigungs Satz für die Anwendung auf Full Trust erhöhen.Consequently, users will receive a ClickOnce security warning and will need to elevate the permission set for the application to full trust.

Darüber hinaus XBAPsXBAPs können Fenster oder Dialogfelder nicht standardmäßig angezeigt werden.Additionally, XBAPsXBAPs cannot show windows or dialog boxes by default. Eine Erläuterung zu den Sicherheitsüberlegungen für eigenständige Anwendungen finden Sie unter WPF-Sicherheitsstrategie-Plattformsicherheit.For a discussion on standalone application security considerations, see WPF Security Strategy - Platform Security.

Andere FenstertypenOther Types of Windows

NavigationWindowist ein Fenster, das zum Hosten von Navigier barem Inhalt entworfen wurde.NavigationWindow is a window that is designed to host navigable content. Weitere Informationen finden Sie unter Übersicht über die Navigation.For more information, see Navigation Overview).

Dialogfelder sind Fenster, die häufig zum Erfassen von Benutzerinformationen verwendet werden, um eine Funktion ausführen.Dialog boxes are windows that are often used to gather information from a user to complete a function. Wenn ein Benutzer beispielsweise eine Datei öffnen möchte, wird das Dialogfeld Datei öffnen normalerweise von einer Anwendung angezeigt, um den Dateinamen vom Benutzer zu erhalten.For example, when a user wants to open a file, the Open File dialog box is usually displayed by an application to get the file name from the user. Weitere Informationen finden Sie unter Übersicht über Dialogfelder.For more information, see Dialog Boxes Overview.

Siehe auchSee also