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

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

Примечание

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

Класс окна

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

Снимок экрана, на котором показаны элементы окна.

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

Неклиентская область окна реализуется 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 атрибутом. Для этого требуется добавить объявление пространства имен XML для 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 метода; результат показан на следующем рисунке.

Окно, открытое при вызове Window. показывать

Окно, открываемое путем вызова, 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.

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

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

Если приложение содержит окно, которое не должно активироваться при отображении, можно задать для его свойства 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 , который реализует Boolean Cancel свойство, для которого задается значение, true чтобы предотвратить закрытие окна.

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

Примечание

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

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

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

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

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

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

Примечание

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

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

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

Схема, показывающая события на протяжении времени существования окна.

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

Схема, показывающая события на протяжении времени существования окна без активации.

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

Когда окно открыто, оно располагается в координатах 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:

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

Иллюстрация стилей границ окна.

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

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

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

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

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

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

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

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

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

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

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

Снимок экрана, на котором показано окно с кнопкой на панели задач.

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

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

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

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

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

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

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

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

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

См. также раздел