Übersicht über WPF-FensterWPF Windows Overview

Benutzer interagieren über Fenster mit eigenständigen Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF)-Anwendungen.Users interact with Windows Presentation Foundation (WPF)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. Eigenständige WPFWPF Anwendungen ihre eigenen Windows bereitstellen, indem Sie mit der Window Klasse.Standalone WPFWPF applications provide their own windows by using the Window class. Dieses Thema enthält Window vor die Grundlagen zum Erstellen und Verwalten von Windows in eigenständigen Anwendungen abdecken.This topic introduces Window before covering the fundamentals of creating and managing windows in standalone applications.

Hinweis

Im Browser gehostete WPFWPF Anwendungen, einschließlich XAML-Browseranwendungen (XAML browser applications; XBAPs)XAML browser applications (XBAPs) und Netzkabel ordnungsgemäß angeschlossen sind Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) Seiten, nicht ihre eigenen Windows bereitgestellt.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 gebotenen gehostet Windows Internet ExplorerWindows Internet Explorer.Instead, they are hosted in windows provided by Windows Internet ExplorerWindows Internet Explorer. Finden Sie unter Übersicht über WPF-XAML-Browseranwendungen.See WPF XAML Browser Applications Overview.

Die FensterklasseThe Window Class

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

FensterelementeWindow elements

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.

Die nicht-Clientbereichs eines Fensters wird dadurch implementiert, WPFWPF und enthält die Teile eines Fensters, die für die meisten Fenster, einschließlich der folgenden gelten: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.

Die Clientbereich eines Fensters wird der nicht-Clientbereich eines Fensters und wird von Entwicklern verwendet, um anwendungsspezifische Inhalte wie Menüs, Symbolleisten und Steuerelemente hinzufü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 WPFWPF, ein Fenster gekapselt, durch die Window -Klasse, die Sie verwenden, um die folgenden Aktionen ausführen: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, in denen Darstellung definiert, wie ein Fenster Benutzern aussieht und Verhalten bestimmt, wie ein Fenster zu Funktionen, wie Benutzer interagieren mit ihm.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 WPFWPF, können Sie implementieren, die Darstellung und Verhalten eines Fensters entweder mit code oder XAMLXAML Markup.In WPFWPF, you can implement the appearance and behavior of a window using either code or XAMLXAML markup.

Im Allgemeinen jedoch die Darstellung eines Fensters wird mithilfe von implementiert XAMLXAML Markup und sein Verhalten ist implementiert mit Code-Behind, 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

So aktivieren Sie eine XAMLXAML Markup und CodeBehind-Datei zusammenarbeiten sind Folgendes erforderlich:To enable a XAMLXAML markup file and code-behind file to work together, the following are required:

  • Im Markup der Window -Element muss enthalten die x:Class Attribut.In markup, the Window element must include the x:Class attribute. Als die Anwendung erstellt wird, wird das Vorhandensein des x:Class im Markup Datei bewirkt, dass Microsoft-Buildmodul (MSBuild)Microsoft build engine (MSBuild) zum Erstellen einer partial von abgeleitete Klasse Window und hat den Namen, die von angegeben wird die x:Class Attribut.When the application is built, the existence of x:Class in the markup file causes Microsoft-Buildmodul (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 Namespacedeklaration für das XAMLXAML 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 die InitializeComponent -Methode, die aufgerufen wird, um die Ereignisse zu registrieren, und legen Sie die Eigenschaften, 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.

  • In der CodeBehind-Klasse muss eine partial Klasse mit dem gleichen Namen, die von angegeben wird die x:Class Attribut in Markup aus, und leiten sich aus Window.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 wird der Code-Behind-Datei zugeordnet werden die partial -Klasse, die für die Markupdatei generiert wird, wenn die Anwendung erstellt wurde (finden Sie unter 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 die Window Klasse muss einen Konstruktor, der Aufrufe implementieren die InitializeComponent Methode.In code-behind, the Window class must implement a constructor that calls the InitializeComponent method. InitializeComponentwird implementiert von Markup generierte partial Klasse, um Ereignisse zu registrieren, und legen Sie Eigenschaften, die im Markup definiert sind.InitializeComponent is implemented by the markup file's generated partial class to register events and set properties that are defined in markup.

Hinweis

Beim Hinzufügen einer neuen Window zu Ihrem Projekt mithilfe von Microsoft Visual StudioMicrosoft Visual Studio, die Window wird mithilfe von Markup und CodeBehind implementiert sind, sowie die erforderliche Konfiguration zum Erstellen der Zuordnung zwischen dem Markup und Code-Behind-Dateien als Die hier beschriebenen.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.

Mit dieser Konfiguration vorhanden, Sie können den Fokus auf definieren die Darstellung des Fensters in XAMLXAML Markup und dessen Verhalten zu implementieren, im Code-Behind.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, implementiert XAMLXAML Markup und einen Ereignishandler für der Schaltfläche Click Ereignis im Code-Behind implementiert.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

Bestimmt, wie Sie das Fenster implementieren Konfiguration für MSBuildMSBuild.How you implement your window determines how it is configured for MSBuildMSBuild. Für ein Fenster, das definiert ist, verwenden beide XAMLXAML Markup und CodeBehind:For a window that is defined using both XAMLXAML markup and code-behind:

  • XAMLXAML Markupdateien werden als konfiguriert MSBuildMSBuild Page Elemente.markup files are configured as MSBuildMSBuildPage items.

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

Dies wird im folgenden gezeigt MSBuildMSBuild Projektdatei.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>  

Informationen zum Erstellen von WPFWPF -Anwendungen finden Sie unter Erstellen einer WPF-Anwendung.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 die MarkupAndCodeBehindWindow wird instanziiert, wenn die Anwendung gestartet wird, Dies tritt ein, wenn die Startup Ereignis wird ausgelöst.In this example, the MarkupAndCodeBehindWindow is instantiated when the application starts, which occurs when the Startup event is raised.

Bei der Instanziierung ein Fensters verwendet wird, wird ein Verweis darauf automatisch eine Liste von Fenstern, die von verwalteten hinzugefügt der Application Objekt (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). Darüber hinaus wird das erste Fenster instanziiert werden standardmäßig durch festgelegt Application als das Hauptanwendungsfenster (siehe Application.MainWindow).Additionally, the first window to be instantiated is, by default, set by Application as the main application window (see Application.MainWindow).

Öffnen des Fensters schließlich durch Aufrufen der Show Methode wird das Ergebnis 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 Show geöffnetes FensterA Window Opened by Calling Window.Show

Ein Fenster, das durch Aufrufen von Show ist ein nicht modales Fenster, was bedeutet, dass die Anwendung in einem Modus ausgeführt, die Benutzern ermöglicht wird, die 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 Windows, z. B. Dialogfelder modal zu öffnen.ShowDialog is called to open windows such as dialog boxes modally. Finden Sie unter Dialog Boxes Overview für Weitere Informationen.See Dialog Boxes Overview for more information.

Wenn Show ist führt Initialisierungsarbeit aufgerufen wird, ein Fenster werden, bevor es angezeigt wird, um die Infrastruktur festzulegen, die eine Benutzereingabe empfangen kann.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, die SourceInitialized Ereignis wird ausgelöst, und das Fenster wird angezeigt.When the window is initialized, the SourceInitialized event is raised and the window is shown.

Als Tastenkombination können StartupUri kann festgelegt werden, an das erste Fenster, die automatisch geöffnet wird, wenn eine Anwendung gestartet 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" />

Beim Starten der Anwendung, durch den Wert des angegebenen Fensters StartupUri geöffnet wird nicht modalen Modus; intern Öffnen des Fensters durch Aufrufen seiner Show Methode.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 geöffnet wurde die Show Methode verfügt nicht über eine implizite Beziehung zu dem Fenster, das sie erstellt; Benutzerinteraktion mit den beiden Fenstern unabhängig voneinander, d. h. entweder Fenster die folgenden Aktionen ausführen kann: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:

  • Abdecken, die andere (es sei denn, eines der Fenster seine Topmost -Eigenschaftensatz auf true).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. Angenommen, ein Integrierte Entwicklungsumgebung (Integrated Development Environment; IDE)Integrated Development Environment (IDE) Anwendung möglicherweise öffnen, Eigenschaft und Toolfenster, deren typische Verhalten besteht darin, das Fenster zu behandeln, die sie erstellt.For example, an Integrierte Entwicklungsumgebung (Integrated Development Environment; IDE)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 hergestellt werden kann, indem Sie die Verfügbarkeit von einem Fenster eigenen einer anderen, und erreicht, indem die Owner Eigenschaft von der Fenster gehören mit einem Verweis auf die Besitzer Fenster.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 zugehörige Fenster kann Besitzerfensters durch überprüfen den Wert der verweisen die Owner Eigenschaft.The owned window can reference its owner window by inspecting the value of its Owner property.

  • Das besitzende Fenster erkennen alle Fenster, die er besitzt, durch den Wert der Überprüfen seiner OwnedWindows Eigenschaft.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 Sie z. B. Konversation Windows über eine internetanwendung der Messenger-Format oder Benachrichtigungsfenster einer e-Mail-Anwendung angezeigt.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 ein Fenster verfügt, die nicht aktiviert werden sollte, wenn Sie angezeigt wird, legen Sie seine ShowActivated Eigenschaft, um false vor dem Aufruf der Show Methode zum ersten Mal.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.

  • Des Fensters Activated Ereignis 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.

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

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

  • Des Fensters Deactivated und Activated Ereignisse werden anschließend als Reaktion auf Benutzeraktionen wie erwartet 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 erstmalig geöffnet wird, wird das aktive Fenster (es sei denn, dies mit dargestellt ist ShowActivated festgelegt false).When a window is first opened, it becomes the active window (unless it is shown with ShowActivated set to false). Die aktive Fenster ist das Fenster, das derzeit von Benutzereingaben, z. B. Tastenanschläge und Mausklicks erfasst.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 die Activated Ereignis.When a window becomes active, it raises the Activated event.

Hinweis

Wenn ein Fenster erstmalig geöffnet wird, die Loaded und ContentRendered Ereignisse werden erst ausgelöst, nachdem die Activated Ereignis wird ausgelöst.When a window is first opened, the Loaded and ContentRendered events are raised only after the Activated event is raised. In diesem Sinn, ein Fenster als tatsächlich geöffnet, 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. In diesem Fall wird das derzeit aktive Fenster deaktiviert und löst die Deactivated Ereignis.When that happens, the currently active window becomes deactivated and raises the Deactivated event. Ebenso, wenn der Benutzer ein derzeit deaktiviertes Fenster auswählt, das Fenster wird wieder aktiv und Activated ausgelöst wird.Likewise, when the user selects a currently deactivated window, the window becomes active again and Activated is raised.

Ein häufiger Grund zum Behandeln Activated und Deactivated ist das Aktivieren und Deaktivieren von Funktionen, die nur ausgeführt werden kann, 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 eine vereinfachte Videoplayer, die zeigt, wie behandelt Activated und Deactivated dieses Verhalten zu implementieren.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, wenn das e-Mail-Fenster nicht aktiv ist, der durch Überprüfung bestimmt werden kann die IsActive Eigenschaft.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 Hintergrundtask abgeschlossen ist, ein Fenster sollten mehr dringend Benachrichtigung des Benutzers durch Aufrufen Activate Methode.If a background task completes, a window may want to notify the user more urgently by calling Activate method. Wenn es sich bei der Interaktion des Benutzers mit einer anderen Anwendung aktiviert, wenn Activate aufgerufen wird, wird die Schaltfläche auf der Taskleiste das Fenster blinkt.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, Aufrufen von Activate wird das Fenster in den Vordergrund bringen.If a user is interacting with the current application, calling Activate will bring the window to the foreground.

Hinweis

Können Sie behandeln, Anwendungsbereich Aktivierung mit der Application.Activated und Application.Deactivated Ereignisse.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:

  • Die schließen Elements von der System Menü.The Close item of the System menu.

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

  • Drücken Sie die schließen Schaltfläche.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 beenden Element in der Datei Menü, in der Regel für die Hauptassembly der Anwendung Windows.An Exit item in the File menu, typically for main application windows.

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

  • Ein "Abbrechen" Schaltfläche in der Regel auf ein modales Dialogfeld.A Cancel button, typically on a modal dialog box.

  • Ein schließen Schaltfläche in der Regel auf ein nicht modales Dialogfeld.A Close button, typically on a modeless dialog box.

Um ein Fenster als Antwort auf eine der benutzerdefinierten Mechanismen zu schließen, müssen Sie zum Aufrufen der Close Methode.To close a window in response to one of these custom mechanisms, you need to call the Close method. Das folgende Beispiel implementiert die Möglichkeit, ein Fenster zu schließen, indem Sie auswählen der beenden auf die Datei Menü.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 wird, und geschlossen es werden zwei Ereignisse ausgelöst: Closing und Closed.When a window closes, it raises two events: Closing and Closed.

Closingwird ausgelöst, bevor das Fenster wird geschlossen, und bietet einen Mechanismus, durch welches, den Fenster Closure 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 diesem Fall die Closing -Ereignis behandelt werden, um zu bestimmen, ob Daten geändert wurden, und wenn Ja, auf der Benutzer gefragt, ob Sie entweder weiterhin das Fenster schließen, ohne die Daten zu speichern oder Schließen des Fensters "Abbrechen".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 bei der Behandlung Closing.The following example shows the key aspects of handling Closing.

//<SnippetWindowClosingCODEBEHIND1>
using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;
        //</SnippetWindowClosingCODEBEHIND1>
        public DataWindow()
        {
            InitializeComponent();
        }

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

        //<SnippetWindowClosingCODEBEHIND2>
        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;
                }
            }
        }
    }
}
//</SnippetWindowClosingCODEBEHIND2>
'<SnippetWindowClosingCODEBEHIND1>

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
        '</SnippetWindowClosingCODEBEHIND1>
        Public Sub New()
            InitializeComponent()
        End Sub

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

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

Die Closing übergebene Ereignishandler eine CancelEventArgs, implementiert die Boolean Cancel -Eigenschaft, die Sie, um festlegen true zum Schließen ein Fensters zu verhindern.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 behandelt, aber nicht abgebrochen wird, wird das Fenster zu schließen.If Closing is not handled, or it is handled but not canceled, the window will close. Kurz bevor tatsächlich ein Fenster wird, und geschlossen Closed ausgelöst wird.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 heruntergefahren, wenn entweder das Hauptanwendungsfenster automatisch schließt (finden Sie unter MainWindow) oder den letzten 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 Fensters über Mechanismen, die in den Bereichen clientfremden und Client explizit geschlossen werden kann, ein Fenster kann implizit geschlossen werden als Ergebnis Verhalten in anderen Teilen der Anwendung oder WindowsWindows, u. a. folgende: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:

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

In der folgenden Darstellung wird die Abfolge der wichtigsten Ereignisse in der Lebensdauer eines Fensters gezeigt.The following illustration shows the sequence of the principal events in the lifetime of a window.

FensterlebensdauerWindow Lifetime

Die folgende Abbildung veranschaulicht die Abfolge der wichtigsten Ereignisse in der Lebensdauer eines Fensters, das ohne Aktivierung angezeigt wird (ShowActivated festgelegt ist, um false , 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).

Fensterlebensdauer (Window.ShowActivated = False)Window Lifetime (Window.ShowActivated = False)

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 bestimmt werden, durch Überprüfen der Left und Top Eigenschaften bzw.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 angeben, die ursprüngliche Position des eine Window bei seinem ersten Auftreten durch Festlegen der WindowStartupLocation Eigenschaft mit einem der folgenden WindowStartupLocation Enumerationswerte: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 die Startposition, als angegeben wird Manual, und die Left und Top Eigenschaften wurden nicht festgelegt wurde, Window fragt WindowsWindows für einen Standort in angezeigt werden.If the startup location is specified as Manual, and the Left and Top properties have not been set, Window will ask WindowsWindows 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 den normalen Z-Reihenfolge richtet sich nach, ob es derzeit aktiv ist.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. Die Position eines Fensters in den oberste Z-Reihenfolge richtet sich zudem nach, ob es derzeit aktiv ist.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 im obersten Z-Reihenfolge durch Festlegen seiner Topmost Eigenschaft true.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

Abgesehen von einer Position auf dem desktop ein Fenster hat eine Größe, die durch mehrere Eigenschaften, einschließlich der verschiedenen Eigenschaften der Breite und Höhe bestimmt ist und SizeToContent.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, und MaxWidth dienen zum Verwalten des Bereichs von Breiten verwendet, ein Fensters während seiner Lebensdauer haben kann konfiguriert werden, 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>

Fensterhöhe erfolgt durch MinHeight, Height, und MaxHeight, und konfiguriert sind, wie im folgenden Beispiel gezeigt.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, untersuchen Sie ActualWidth und ActualHeightzugeordnet.To detect its current width and height, inspect ActualWidth and ActualHeight, respectively.

Wenn Sie die Breite und Höhe des Fensters möchten den Inhalt eine Größe aufweisen, die auf die Größe des Fensters entspricht, können Sie mithilfe der SizeToContent -Eigenschaft, die den folgenden Werten: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:

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

  • WidthWidth. An Inhalt Breite dieselbe Wirkung hat wie das Festlegen von sowohl anpassen MinWidth und MaxWidth auf die 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 Inhalt Höhe dieselbe Wirkung hat wie das Festlegen von sowohl anpassen MinHeight und MaxHeight an 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 Inhalt Breite und Höhe dieselbe Wirkung hat wie das Festlegen von sowohl anpassen MinHeight und MaxHeight die Höhe der Inhalte und Einstellung beide MinWidth und MaxWidth 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 folgende Beispiel wird gezeigt, wie zum Festlegen der SizeToContent -Eigenschaft im Code angeben, wie die Fenstergröße an ihren Inhalt.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 beibehalten wird, Window die Werte der Größeneigenschaften anhand der folgenden Rangfolge ausgewertet.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

Rangfolge kann bestimmen die Größe eines Fensters auch zu, wenn dieses die maximiert mit verwaltet wird, die WindowState Eigenschaft.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 minimiert Status wird auf seine Taskleistenschaltfläche reduziert, wenn ShowInTaskbar festgelegt ist, um trueist, andernfalls wird reduziert, um die kleinstmögliche Größe es kann sein, und verschiebt selbst in der unteren linken Ecke des Desktops.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 maximiert Zustand wird erweitert, um die maximale Größe möglich, die nur so groß wie dessen MaxWidth, MaxHeight, und SizeToContent Eigenschaften vorgeben.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 Top, Left, Width, und Height Eigenschaften eines Fensters stellen immer die Werte für den Zustand "normal", selbst wenn das Fenster derzeit maximiert oder minimiert wird.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 Status eines Fensters kann konfiguriert werden, durch Festlegen seiner WindowState -Eigenschaft, die einen der folgenden verfügen, können WindowState Enumerationswerte: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>

Sie sollten im Allgemeinen festlegen WindowState an den Ausgangszustand 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. So konfigurieren Sie den nicht-Clientbereich Window enthält verschiedene Eigenschaften, darunter Icon Symbol für ein Fenster festlegen und Title seinen Titel festlegen.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

Je nach den WindowStyle -Eigenschaft, können Sie steuern, wie (und ob) Benutzer können die Größe des Fensters.Depending on the WindowStyle property, you can control how (and if) users can resize the window. Die Auswahl des Fensterstil auswirkt, ob ein Benutzer die Größe des Editorfensters kann durch Ziehen eine Rahmenlinie mit der Maus, ob die Minimieren, Maximieren, und Größe Schaltflächen auf den nicht-Clientbereich angezeigt werden und, falls sie angezeigt, ob sie aktiviert sind.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 eine Fenstergröße durch Festlegen seiner ResizeMode -Eigenschaft, die in der folgenden Werte sind möglich ResizeMode Enumerationswerte:You can configure how a window resizes by setting its ResizeMode property, which can be one of the following ResizeMode enumeration values:

Wie bei WindowStyle, der Größenänderungsmodus eines Fensters ist es unwahrscheinlich, dass während seiner Lebensdauer zu ändern, was bedeutet, dass sie über sehr wahrscheinlich festgelegt werden XAMLXAML Markup.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, die Sie erkennen, ob ein Fenster maximiert ist, minimiert oder wiederhergestellt, indem Sie überprüfen die WindowState Eigenschaft.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.

Steuern, welche Art des Rahmens ein Fensters, legen Sie seine WindowStyle Eigenschaft mit einem der folgenden Werte für die WindowStyle Enumeration: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 Auswirkung dieser Fensterstile wird in der folgenden Abbildung veranschaulicht.The effect of these window styles are illustrated in the following figure.

FensterstileWindow styles

Sie können festlegen, WindowStyle entweder XAMLXAML Markup oder-Code; da es unwahrscheinlich ist, während der Lebensdauer eines Fensters zu ändern, wahrscheinlich konfigurieren Sie ihn mit XAMLXAML Markup.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 dem der Rahmen Formatvorlagen, WindowStyle ermöglicht es Ihnen, sind nicht ausreichend.There are also situations where the border styles that WindowStyle allows you to have are not sufficient. Sie möchten beispielsweise erstellen Sie eine Anwendung mit einem viereckig Rahmen wie Microsoft Windows Media PlayerMicrosoft Windows Media Player verwendet.For example, you may want to create an application with a non-rectangular border, like Microsoft Windows Media PlayerMicrosoft Windows Media Player uses.

Betrachten Sie beispielsweise das Sprechblasenfenster in der folgenden Abbildung.For example, consider the speech bubble window shown in the following figure.

Nicht rechteckiges FensterNonrectangular window

Diese Art von Fenster erstellt werden, indem Sie die Einstellung der WindowStyle Eigenschaft None, und mit besonderen unterstützen, die Window wurde für die 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 Taskleistenschaltfläche wie in der folgenden Abbildung.The default appearance of a window includes a task bar button, like the one shown in the following figure.

Fenster mit einer TaskleistenschaltflächeWindow with a task bar button

Bei einigen Typen von Windows keine Taskleistenschaltfläche wie Meldungsfelder und Dialogfelder sind (finden Sie unter Dialog Boxes Overview).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 Taskleistenschaltfläche für ein Fenster, durch Festlegen angezeigt wird der ShowInTaskbar Eigenschaft (true 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 Sicherheitsberechtigung instanziiert 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.

Allerdings Dies liegt außerhalb des Satzes von Berechtigungen für Anwendungen, die aus dem Internet oder lokales Intranet-Zone mit gestartet werden ClickOnceClickOnce.However, this falls outside the set of permissions granted to applications that are launched from the Internet or Local intranet zone using ClickOnceClickOnce. Folglich erhalten Benutzer eine ClickOnceClickOnce sicherheitswarnung, und müssen den Berechtigungssatz für die Anwendung auf volle Vertrauenswürdigkeit zu erhöhen.Consequently, users will receive a ClickOnceClickOnce security warning and will need to elevate the permission set for the application to full trust.

Darüber hinaus XBAPsXBAPs kann nicht in der Standardeinstellung Windows- oder Dialogfeldern angezeigt.Additionally, XBAPsXBAPs cannot show windows or dialog boxes by default. Ausführliche Informationen zu sicherheitsüberlegungen für eigenständige Anwendung, 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, die zum Hosten von navigierbaren Inhalt vorgesehen ist.NavigationWindow is a window that is designed to host navigable content. Weitere Informationen finden Sie unter Navigation Overview).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. Z. B. wenn ein Benutzer möchte zum Öffnen einer Datei, die Datei öffnen Dialogfeld wird in der Regel von einer Anwendung zum Abrufen des Dateinamens aus dem Benutzer angezeigt.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

Window
MessageBox
NavigationWindow
Application
Übersicht über DialogfelderDialog Boxes Overview
Erstellen einer WPF-AnwendungBuilding a WPF Application