Общие сведения об окнах WPF

  • Статья

Пользователи взаимодействуют с автономными приложениями Windows Presentation Foundation (WPF) с помощью окон. Основная цель окна — разместить содержимое, которое визуализирует данные и позволяет пользователям взаимодействовать с ними. Автономные приложения WPF предоставляют собственные окна с помощью класса Window. В этом разделе рассматривается Window, а затем освещаются основы создания и управления окнами в автономных приложениях.

Примечание.

Размещенные в браузере приложения WPF, включая приложения браузера XAML (XBAP) и свободные страницы XAML, не предоставляют собственные окна. Вместо этого они размещаются в окнах, предоставляемых Windows Internet Explorer. См. Общие сведения о приложениях браузера XAML в WPF.

Класс окна

На следующем рисунке показаны составные части окна.

Screenshot that shows window elements.

Окно разделено на две области: неклиентскую и клиентскую.

Неклиентская область окна реализуется WPF и включает части окна, которые являются общими для большинства окон, в том числе следующие:

  • Граница.

  • Заголовок окна.

  • Значок.

  • Кнопки Свернуть, Развернуть и Восстановить.

  • Кнопка "Закрыть".

  • Системное меню с элементами, которые позволяют пользователям свернуть, развернуть, восстановить, перемещать, изменять размеры и закрыть окно.

Клиентская область окна находится внутри неклиентской области и используется разработчиками для добавления содержимого конкретного приложения, такого как строки меню, панели инструментов и элементы управления.

В WPF окно инкапсулируется классом Window, который позволяет выполнять следующие задачи.

  • Отобразить окно.

  • Настроить размер, положение и внешний вид окна.

  • Разместить содержимое конкретного приложения.

  • Управлять временем существования окна.

Реализация окна

Реализация типичного окна включает внешний вид и поведение. Внешний вид определяет, как окно отображается для пользователей, а поведение — функционирование окна при взаимодействии пользователей с ним. В WPF внешний вид и поведение окна можно реализовать с помощью кода или разметки XAML.

Однако обычно внешний вид окна реализуется с помощью разметки XAML, а его поведение — с помощью кода программной части, как показано в следующем примере.

<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

Чтобы разрешить совместную работу файла разметки XAML и файла кода программной части, необходимо следующее:

  • В разметке элемент Window должен включать атрибут x:Class. При построении приложения существование x:Class в файле разметки вызывает Microsoft Build Engine (MSBuild) для создания класса partial, который является производным от Window и имеет имя, указанное в атрибуте x:Class. Для этого требуется добавить объявление пространства имен XAML в схему XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"). Созданный класс partial реализует метод InitializeComponent, который вызывается для регистрации событий и установки свойств, реализованных в разметке.

  • В коде программной части класс должен быть классом partial с тем же именем, которое определено атрибутом x:Class в разметке. Кроме того, он должен быть производным от Window. Это позволяет связать файл кода программной части с классом partial, созданным для файла разметки при построении приложения (см. раздел Построение приложения WPF).

  • В коде программной части класс Window должен реализовывать конструктор, который вызывает метод InitializeComponent. Метод InitializeComponent реализуется классом partial, созданным файлом разметки, для регистрации событий и задания свойств, определенных в разметке.

Примечание.

При создании нового класса Window для проекта с помощью Visual Studio классWindow реализуется с использованием разметки и кода программной части, а также включает в себя необходимую конфигурацию для создания связи между файлами разметки и кода программной части, как описано здесь.

При такой конфигурации можно сосредоточиться на определении внешнего вида окна в разметке XAML и реализации его поведения в коде программной части. В следующем примере показано окно с кнопкой, реализованной в разметке XAML, и обработчик события для события Click кнопки, реализованного в коде программной части.

<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

Настройка определения окна для MSBuild

Реализация окна определяет его конфигурацию для MSBuild. Для окна, которое определяется с помощью разметки XAML и кода программной части:

  • Файлы разметки XAML настраиваются как элементы Page MSBuild.

  • Файлы кода программной части настраиваются как элементы CompileMSBuild.

Это показано в следующем файле проекта MSBuild.

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

Сведения о построении приложений WPF см. в разделе Построение приложения WPF.

Время существования окна

Как и любой класс, окно имеет время существования, которое начинается с момента создания его экземпляра, после чего оно открывается, активируется, деактивируется и, в конечном счете, закрывается.

Открытие окна

Чтобы открыть окно, сначала создайте его экземпляр, как показано в следующем примере.

<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();
        }
    }
}

В этом примере экземпляр MarkupAndCodeBehindWindow создается при запуске приложения, когда возникает событие Startup.

При создании экземпляра окна ссылка на него автоматически добавляется в список окон, находящийся под управлением объекта Application (см. Application.Windows). Кроме того, первое окно, экземпляр которого создается, по умолчанию автоматически устанавливается Application в качестве главного окна приложения (см. Application.MainWindow).

Наконец, окно открывается путем вызова метода Show, как показано на следующем изображении:

A Window Opened by calling Window.Show

Окно, открытое с помощью вызова Show, является немодальным, то есть приложение работает в режиме, который позволяет пользователям активировать и другие окна в том же приложении.

Примечание.

ShowDialog вызывается, чтобы открыть окна, например диалоговые, в модальном режиме. См. подробнее в разделе Общие сведения о диалоговых окнах.

При вызове Show перед отображением окно выполняет работу по инициализации, чтобы установить инфраструктуру, которая позволяет ему получать данные, вводимые пользователем. После инициализации окна возникает событие SourceInitialized и окно отображается.

В качестве ярлыка можно задать StartupUri, чтобы указать первое окно, которое автоматически открывается при запуске приложения.

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

При запуске приложения окно, заданное значением StartupUri, открывается в немодальном режиме; внутри системы окно открывается путем вызова метода Show.

Владение окном

Окно, которое открывается с помощью метода Show, не имеет неявной связи с окном, которое его создало. Пользователи могут взаимодействовать с любым из окон независимо от другого, то есть любое окно может выполнять следующие действия:

  • Перекрывать другое (за исключением случая, когда свойству Topmost одного из окон задано значение true).

  • Сворачиваться, разворачиваться и восстанавливаться без влияния на другое окно.

Для некоторых окон требуется связь с окном, которое их открывает. Например приложение IDE может открывать окна свойств и окна инструментов, типичное поведение которых заключается в том, чтобы перекрыть окно, которое их создает. Кроме того, такие окна должны всегда закрываться, сворачиваться, разворачиваться и восстанавливаться вместе с окном, которое их создало. Такую связь можно установить, сделав одно окно владельцем другого. Для этого устанавливается свойство Ownerокна во владении со ссылкой на окно-владелец. Это показано в следующем примере.

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

После установки владения:

  • Окно во владении может ссылаться на окно-владелец, проверяя значение его свойства Owner.

  • Окно-владелец может найти все принадлежащие ему окна, проверив значение его свойства OwnedWindows.

Предотвращение активации окна

Существуют сценарии, в которых окна не должны активироваться при отображении, например окна сеанса обмена сообщениями в интернет-приложениях или окна уведомлений приложения электронной почты.

Если приложение содержит окно, которое не должно активироваться при отображении, можно задать для его свойства ShowActivated значение false перед первым вызовом метода Show. Результат:

  • Окно не активируется.

  • Событие окна Activated не запускается.

  • Текущее активированное окно останется активным.

Однако окно активируется, если пользователь щелкнет его неклиентскую или клиентскую область. В данном случае:

  • Окно активируется.

  • Событие окна Activated запускается.

  • Ранее активированное окно деактивируется.

  • Затем события окна Deactivated и Activated запускаются в ответ на действия пользователя.

Активация окна

При первом открытии окно становится активным (если только для ShowActivated не задано значение false). Активным окном является окно, которое в настоящий момент захватывает входные данные пользователя, например нажатие клавиш и щелчки мышью. Становясь активным, окно вызывает событие Activated.

Примечание.

При первом открытии окна события Loaded и ContentRendered запускаются только после запуска события Activated. С учетом этого окно может считаться открытым, если запущено событие ContentRendered.

После активизации окна пользователь может активировать другое окно в том же приложении или активировать другое приложение. В таком случае текущее активное окно становится неактивным и вызывает событие Deactivated. Аналогичным образом, когда пользователь выбирает неактивное окно, оно снова становится активным и запускается событие Activated.

Одна из распространенных причин обработки Activated и Deactivated — включение и отключение функций, которые могут выполняться, только если окно активно. Например, некоторые окна отображают интерактивное содержимое, которое требует постоянного ввода данных или внимания пользователя, включая игры и видеопроигрыватели. Ниже в качестве примера приведен упрощенный видеопроигрыватель, демонстрирующий обработку Activated и Deactivated для реализации этого повеления.

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

Другие типы приложений могут выполнять код в фоновом режиме, когда окно деактивировано. Например, почтовый клиент может продолжать опрашивать почтовый сервер, пока пользователь работает с другими приложениями. Такие приложения часто обеспечивают другое или дополнительное поведение, когда главное окно не активно. В случае почтовой программы это может означать как добавление нового почтового элемента в папку "Входящие", так и добавление значка уведомления на панель задач. Значок уведомления должен отображаться только в том случае, если окно почты не активно. Это можно определить путем проверки свойства IsActive.

Если фоновая задача завершается, окно может уведомить пользователя в более срочном порядке, вызвав метод Activate. Если пользователь взаимодействует с другим приложением, которое активно при вызове Activate, то кнопка панели задач окна мигает. Если пользователь взаимодействует с текущим приложением, вызов Activate перенесет окно на передний план.

Примечание.

Активировать область видимости приложения можно с помощью событий Application.Activated и Application.Deactivated.

Закрытие окна

Время существования окна заканчивается, когда пользователь его закрывает. Окно может быть закрыто с помощью элементов в неклиентской области, включая следующие:

  • Элемент Закрыть меню Система.

  • Нажатие клавиш ALT + F4.

  • Нажатие кнопки Закрыть.

Можно указать дополнительные способы закрытия окна для клиентской области, к наиболее типичным из которых относятся следующие:

  • Элемент Выход в меню Файл, обычно для главных окон приложений.

  • Элемент Закрыть в меню Файл, как правило, применим для вторичных окон приложений.

  • Кнопка Отменить, обычно для модального диалогового окна.

  • Кнопка Закрыть, обычно для немодального диалогового окна.

Чтобы закрыть окно одним из данных пользовательских способов, необходимо вызвать метод Close. В следующем примере реализуется возможность закрытия окна выбором пункта Выход в меню Файл.

<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

При закрытии окно запускает два события: Closing и Closed.

Closing вызывается перед закрытием окна и предоставляет механизм, с помощью которого можно предотвратить закрытие окна. Одна из распространенных причин, препятствующих закрытию окна, заключается в том, что содержимое окна содержит измененные данные. В этом случае событие Closing может быть обработано, чтобы определить наличие необработанных данных и запросить у пользователя, следует ли закрыть окно без сохранения данных или отменить закрытие окна. В следующем примере показаны ключевые аспекты обработки 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

В обработчик событий Closing передается событие CancelEventArgs, реализующее свойство BooleanCancel, для которого задается значение true с целью предотвратить закрытие окна.

Если событие Closing не обработано или обработано, но не отменено, окно закроется. Непосредственно перед фактическим закрытием окна запускается Closed. На этом этапе невозможно предотвратить закрытие окна.

Примечание.

Приложение можно настроить на автоматическое завершение работы при закрытии главного окна приложения (см. MainWindow) или при закрытии последнего окна. Дополнительные сведения см. в разделе ShutdownMode.

Хотя окно может быть непосредственно закрыто с помощью механизмов, предоставляемых в неклиентской и клиентской областях, оно также может быть неявно закрыто в результате поведения в других частях приложения или Windows, включая следующее:

  • Пользователь выходит из системы или завершает работу Windows.

  • Владелец окна закрывается (см. раздел Owner).

  • Главное окно приложения закрыто, а ShutdownMode — OnMainWindowClose.

  • Вызывается метод Shutdown.

Примечание.

После закрытия окно нельзя открыть повторно.

События времени существования окна

На следующем рисунке показана последовательность основных событий на протяжении времени существования окна.

Diagram that shows events in a window's lifetime.

На рисунке показана последовательность основных событий на протяжении времени существования окна, которое отображается без активации (ShowActivated установлен равным false до отображения окна).

Diagram that shows events in a window's lifetime without activation.

Расположение окна

Когда окно открыто, оно располагается в координатах x и y относительно рабочего стола. Чтобы определить расположение, необходимо проверить свойства Left и Top соответственно. Можно задать эти свойства, чтобы изменить расположение окна.

Можно также указать начальное расположение окна Window при первом появлении путем задания свойству WindowStartupLocation одного из следующих значений перечисления WindowStartupLocation:

Если расположение запуска указано как Manual, а свойства Left и Top не заданы, Window запросит у Windows расположение для отображения.

Окна верхнего уровня и Z-порядок

Помимо расположения в координатах x и y, окно имеет координату по оси z, которая определяет его вертикальную позицию относительно других окон. Это называется z-порядком окна. Существует два типа: обычный z-порядок и верхний z-порядок. Расположение окна в обычном z-порядке определяется тем, активно оно в данный момент или нет. По умолчанию окно находится в обычном z-порядке. Расположение окна в верхнем z-порядке также определяется тем, активно оно в данный момент или нет. Кроме того, окна в самом верхнем z-порядке всегда расположены над окнами в обычном z-порядке. Окно располагается в самом верхнем z-порядке путем установки для его свойства Topmost значения true.

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

В каждом z-порядке активное в данный момент окно появляется поверх всех других окон в том же z-порядке.

Размер окна

Помимо расположения на рабочем столе, окно имеет размер, определяемый несколькими свойствами, включая различные свойства ширины и высоты и SizeToContent.

MinWidth, Width и MaxWidth используются для управления диапазоном значений ширины, которые может иметь окно на протяжении своего времени существования, и настраиваются, как показано в следующем примере.

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

Высотой окна управляют параметры MinHeight, Height и MaxHeight, а настраиваются они, как показано в следующем примере.

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

Так как различные значения ширины и высоты определяют диапазон, то что ширина и высота изменяемого окна могут находиться в любом месте указанного диапазона для соответствующего измерения. Чтобы определить текущую ширину и высоту, проверьте свойства ActualWidth и ActualHeight соответственно.

Если ширина и высота окна должны соответствовать размеру содержимого, можно использовать свойство SizeToContent, которое имеет следующие значения:

  • Manual. Нет эффекта (по умолчанию).

  • Width. Соответствие ширине содержимого. Дает такой же эффект, как задание свойствам MinWidth и MaxWidth значения ширины содержимого.

  • Height. Соответствие высоте содержимого. Дает такой же эффект, как задание свойствам MinHeight и MaxHeight значения высоты содержимого.

  • WidthAndHeight. Соответствие ширине и высоте содержимого. Дает такой же эффект, как задание свойствам MinHeight и MaxHeight значения высоты содержимого, а свойствам MinWidth и MaxWidth — ширины.

В следующем примере показано окно, размеры которого автоматически устанавливаются равными его содержимому по вертикали и по горизонтали при первом отображении.

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

В следующем примере показано, как задать в коде свойство SizeToContent, чтобы указать изменение размеров окна в соответствии с его содержимым.


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

Порядок приоритета для свойств размера

Различные свойства размеров окна объединяются для определения диапазона ширины и высоты окна изменяемого размера. Чтобы не выходить за рамки допустимого диапазона, Window оценивает значения свойств размера с использованием следующего порядка приоритета.

Для свойств высоты:

  1. FrameworkElement.MinHeight

  2. FrameworkElement.MaxHeight

  3. SizeToContent.Height/SizeToContent.WidthAndHeight

  4. FrameworkElement.Height

Для свойств ширины:

  1. FrameworkElement.MinWidth

  2. FrameworkElement.MaxWidth

  3. SizeToContent.Width/SizeToContent.WidthAndHeight

  4. FrameworkElement.Width

Порядок приоритетов также может определять размер окна, когда оно развернуто, что определяется с помощью свойства WindowState.

Состояние окна

В течение времени существования окна изменяемого размера оно может иметь три состояния: обычное, свернутое и развернутое. Окно с обычным состоянием является состоянием окна по умолчанию. Окно с этим состоянием позволяет пользователю перемещать его и изменять размер, используя захват для изменения размера или границу.

Окно со свернутым состоянием сворачивается в кнопку на панели задач, если для параметра ShowInTaskbar установлено значение true. В противном случае оно сворачивается до минимально возможного размера и перемещается в нижний левый угол рабочего стола. Ни один из типов свернутого окна не может быть изменен с помощью границы или захвата для изменения размера, хотя свернутое окно, которое не отображается на панели задач, можно перетаскивать на рабочем столе.

Окно с развернутым состоянием разворачивается до максимально возможного размера, который не может превышать значения свойств MaxWidth, MaxHeight и SizeToContent. Как и для свернутого окна, размер развернутого окна нельзя изменить с помощью захвата для изменения размера или перетаскивания границы.

Примечание.

Значения свойств окна Top, Left, Width и Height всегда представляют значения для обычного состояния, даже если окно в текущий момент развернуто или свернуто.

Состояние окна можно настроить путем задания его свойства WindowState, которое может иметь одно из следующих значений перечисления WindowState:

В следующем примере показано создание окна, которое отображается развернутым при его открытии.

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

В общем случае следует задать WindowState для настройки начального состояния окна. После отображения окна изменяемого размера пользователи могут нажимать кнопки свертывания, развертывания и восстановления на панели заголовка окна, чтобы изменить состояние окна.

Внешний вид окна

Можно изменить внешний вид клиентской области окна, добавляя в нее определенное содержимое, такое как кнопки, метки и текстовые поля. Для настройки неклиентской области Window предоставляет несколько свойств, в том числе Icon для задания значка окна и Title для задания его заголовка.

Можно также изменить внешний вид и поведение границы неклиентской области, настраивая режим изменения размера окна, стиль окна и отображение в виде кнопки на панели задач рабочего стола.

Режим изменения размера

В зависимости от значения свойства WindowStyle можно разрешать или запрещать пользователям изменять размер окна, а также контролировать данный процесс. Выбор стиля окна влияет на то, может ли пользователь изменять размер окна, перетаскивая его границу мышью, появляются ли кнопки Свернуть , Развернуть и Изменить размер для неклиентской области и, если они отображаются, включены ли они.

Изменение размера окна можно настроить путем задания его свойства ResizeMode, которое может иметь одно из следующих значений перечисления ResizeMode:

Как и в случае WindowStyle, режим изменения размера окна редко изменяется на протяжении времени существования. Это означает, что, скорее всего, он устанавливается из разметки XAML.

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

Обратите внимание, что определить, развернуто, свернуто или восстановлено окно, можно путем проверки свойства WindowState.

Стиль окна

Граница, предоставляемая из неклиентской области окна, подходит для большинства приложений. Однако существуют ситуации, когда требуются различные типы границ либо границы вовсе не требуются, в зависимости от типа окна.

Для управления типом границы окна его свойству WindowStyle задается одно из следующих значений перечисления WindowStyle:

Эффект этих стилей окон показан на следующем рисунке.

Illustration of window border styles.

Можно задать WindowStyle с помощью разметки XAML или кода. Поскольку стиль редко изменяется во время существования окна, он, скорее всего, настраивается с помощью разметки XAML.

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

Непрямоугольный стиль окна

В некоторых ситуациях стилей границы, которые предлагает WindowStyle, недостаточно. Например, можно создать приложение с непрямоугольной границей, такой, как используется проигрывателем мультимедиа Microsoft Windows.

Рассмотрим окно "облачко с текстом", показанное на следующем рисунке.

A speech bubble window that says Drag Me.

Окно такого типа можно создать путем задания свойству WindowStyle значения None, а также использования поддержки прозрачности, предоставляемой Window.

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

Это сочетание значений указывает, что окно отрисовывается полностью прозрачным. В этом состоянии нельзя использовать элементы оформления неклиентской области окна (кнопки "Закрыть", "Минимизировать", "Развернуть" и "Восстановить" и т. д.). Следовательно, необходимо предоставить свои собственные элементы.

Наличие панели задач

По умолчанию внешний вид окна включает кнопку панели задач, как показано на следующем рисунке.

Screenshot that shows a window with a taskbar button.

Некоторые типы окон не имеют кнопки панели задач, например окна сообщений и диалоговые окна (см. Общие сведения о диалоговых окнах). Можно управлять отображением кнопки панели задач для окна, задав свойство ShowInTaskbar (true по умолчанию).

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

Соображения безопасности

Window требует создания экземпляра разрешения безопасности UnmanagedCode. Для приложений, установленных и запускаемых с локального компьютера, это включено в набор разрешений, предоставленных приложению.

Однако это выходит за рамки набора разрешений, предоставляемых приложениям, запускаемым из зоны Интернета или локальной интрасети, используя ClickOnce. Следовательно, пользователи получат предупреждение ClickOnce о безопасности и должны будут повысить набор разрешений для приложения до полного доверия.

Кроме того, XBAP не может отображать окна или диалоговые окна по умолчанию. Информацию о безопасности автономных приложений см. в разделе Стратегия безопасности WPF: безопасность платформы.

Другие типы окон

NavigationWindow — это окно, предназначенное для размещения перемещаемого содержимого. Дополнительные сведения см. в разделе Общие сведения о переходах.

Диалоговые окна — это окна, которые часто используются для сбора информации от пользователя для выполнения функции. Например, когда пользователь хочет открыть файл, приложение обычно отображает диалоговое окно Открыть файл, чтобы получить имя файла от пользователя. Дополнительные сведения см. в разделе Общие сведения о диалоговых окнах.

См. также