Как закрыть приложение wpf

Как закрыть приложение wpf

Запустить приложение – одно дело, но после того, как с ним поработали, его надо закрыть. В Windows приложения можно закрыть, нажав Х в правом верхнем углу или нажав кнопки Ctrl + F4. Еще есть вариант закрыть из диспетчера задач, но это уже очень не «юзер-френдли».

Приложение должно иметь кнопку завершения работы. Если кнопок много, то кнопку закрытия приложения можно вынести в меню, но кнопка «Закрыть» непременно должна быть.

В нашем приложении кнопок пока мало, потому разместим ее в видимой области (Рис.1).

В XAML файле пропишите:

Рис.1. Кнопка Закрыть

Теперь выделите кнопку в дизайнере или строчку кода кнопки Закрыть и перейдите в окно Properties / Event handlers for the selected elements. Для автоматической генерации обработчика для кнопки дважды кликните на текстовое поле около свойства Click (Рис.2)

Рис.2. Генерация прототипа обработчика кнопки

После клика Visual studio автоматически откроет код обработчика.

В обработчике для кнопки добавьте код «this.Close();»:

private void btn_Close_Click(object sender, RoutedEventArgs e)

Запустите приложение и попробуйте закрыть его кнопкой. Если все сделали верно, то окно приложения закроется.

способы закрытия формы

Пользователь пытается закрыть программу стандартным способом, кликает на верхнюю правую кнопку «крестик», нажимает комбинацию клавиш Alt+F4 или в левом верхнем углу вызывает контекстное меню формы. Но программа сразу не закрывается, а появляется окно сообщения, в котором нужно подтвердить решение закрытия.
Событие FormClosingEventArgs принимает параметр «е». Этот параметр имеет свойство Cancel. Если установить его в false , форма закроется, если в true — останется открытой.

Копировать

• using System;
• using System.Collections.Generic;
• using System.ComponentModel;
• using System.Data;
• using System.Drawing;
• using System.Linq;
• using System.Text;
• using System.Threading.Tasks;
• using System.Windows.Forms;
• namespace _0006
• public partial class Form1 : Form
• public Form1()
• InitializeComponent();
• >
• private void Form1_FormClosing( object sender, FormClosingEventArgs e)
• DialogResult dialog = MessageBox.Show(
• «Вы действительно хотите выйти из программы?» ,
• «Завершение программы» ,
• MessageBoxButtons.YesNo,
• MessageBoxIcon.Warning
• );
• if (dialog == DialogResult.Yes)
• e.Cancel = false ;
• >
• else
• e.Cancel = true ;
• >
• >
• >
• >

• using System;
• using System.Collections.Generic;
• using System.ComponentModel;
• using System.Data;
• using System.Drawing;
• using System.Linq;
• using System.Text;
• using System.Threading.Tasks;
• using System.Windows.Forms;
• namespace _0006
• public partial class Form1 : Form
• public Form1()
• InitializeComponent();
• >
• private void Form1_FormClosing( object sender, FormClosingEventArgs e)
• DialogResult dialog = MessageBox.Show(
• «Вы действительно хотите выйти из программы?» ,
• «Завершение программы» ,
• MessageBoxButtons.YesNo,
• MessageBoxIcon.Warning
• );
• if (dialog == DialogResult.Yes)
• e.Cancel = false ;
• >
• else
• e.Cancel = true ;
• >
• >
• >
• >

Создание и останов приложения

В WPF приложение проходит через простой жизненный цикл. Вскоре после запуска приложения создается объект Application. Во время его выполнения возникают различные события приложения, которые можно отслеживать. И, наконец, когда объект приложения освобождается, приложение завершается.

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

Создание объекта Application

Простейший способ использования класса Application предусматривает его создание вручную. В следующем примере демонстрируется абсолютный минимум: точка входа в приложение (метод Main()), которая создает окно по имени Window1 и запускает новое приложение:

using System; using System.Windows; public class Startup < [STAThread()] static void Main() < // Создание приложения Application app = new Application(); // Создание главного окна. Window1 win = new Window1(); // Запуск приложения и отображение главного окна, app.Run(win); >

Передача окна методу Application.Run() приводит к тому, что это окно устанавливается в качестве главного и доступно во всем приложении через свойство Application.MainWindow. Метод Run() затем инициирует событие Application.Startup и отображает главное окно.

Запущенное подобным образом приложение продолжает работу до тех пор, пока главное окно и все его прочие окна не будут закрыты. В этот момент метод Run() вернет управление и, прежде чем завершится приложение, будет выполнен любой дополнительный код в Main().

Чтобы запустить приложение с использованием метода Main(), необходимо определить класс, который содержит метод Main() в качестве стартового объекта в Visual Studio. Чтобы сделать это, дважды щелкните на узле Properties (Свойства) в Solution Explorer и измените выбор в списке Startup Object (Стартовый объект). Обычно это делать не понадобится, потому что Visual Studio создает метод Main() автоматически на основе шаблона приложения XAML.

Наследование специального класса приложения

Хотя подход, описанный в предыдущем разделе (с созданием экземпляра базового класса Application и вызовом Run()), работает вполне удовлетворительно, при создании нового приложения WPF этот вариант в Visual Studio не используется.

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

Модель, реализованная в Visual Studio в отношении класса Application, по сути, та же, что и модель, применяемая для окон. Начальная точка — шаблон XAML, по умолчанию называемый App.xaml. Ниже показано, как примерно он выглядит:

Атрибут Class используется в XAML для создания класса, унаследованного от элемента. Таким образом, создается класс, унаследованный от Application, по имени WpfApplication1.App. (WpfApplication1 — название проекта, совпадающее с пространством имен, в котором определен класс, а App — имя, используемое Visual Studio для специального класса, унаследованного от Application. При желании это имя класса можно заменить более выразительным.)

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

Как и с окном, класс приложения определен в двух отдельных частях, которые объединяются вместе во время компиляции. Автоматически сгенерированная часть в проекте невидима, но она содержит точку входа Main() и код для запуска приложения. Выглядит это примерно так, как показано ниже:

#pragma checksum "..\..\..\App.xaml" "" "BA8CBEA9C2EFABD90D53B616FB80A081" //------------------------------------------------------------------------------ // // Этот код создан программой. // Исполняемая версия:4.0.30319.1 // // Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае // повторной генерации кода. // //------------------------------------------------------------------------------ using System; using System.Diagnostics; using System.Windows; using System.Windows.Automation; using System.Windows.Controls; using System.Windows.Controls.Primitives; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Ink; using System.Windows.Input; using System.Windows.Markup; using System.Windows.Media; using System.Windows.Media.Animation; using System.Windows.Media.Effects; using System.Windows.Media.Imaging; using System.Windows.Media.Media3D; using System.Windows.Media.TextFormatting; using System.Windows.Navigation; using System.Windows.Shapes; using System.Windows.Shell; namespace WpfApplication1 < /// 
/// App ///
 [System.CodeDom.Compiler.GeneratedCodeAttribute("PresentationBuildTasks", "4.0.0.0")] public partial class App : System.Windows.Application < /// 
/// InitializeComponent ///
 [System.Diagnostics.DebuggerNonUserCodeAttribute()] public void InitializeComponent() < #line 4 "..\..\..\App.xaml" this.StartupUri = new System.Uri("MainWindow.xaml", System.UriKind.Relative); #line default #line hidden >/// 
/// Application Entry Point. ///
 [System.STAThreadAttribute()] [System.Diagnostics.DebuggerNonUserCodeAttribute()] public static void Main() < WpfApplication1.App app = new WpfApplication1.App(); app.InitializeComponent(); app.Run(); >> >

Если вы действительно заинтересованы в том, чтобы увидеть специальный класс приложения, созданный шаблоном XAML, загляните в файл App.g.cs в папке obj —> Debug внутри каталога проекта.

Единственное отличие между автоматически сгенерированным кодом, показанным здесь, и специальным классом приложения, который вы можете создать самостоятельно, состоит в том, что автоматически сгенерированный класс использует свойство StartupUri вместо установки свойства MainWindow или передачи главного окна в качестве параметра методу Run(). Применяя тот же самый формат URI, можно создать специальный класс приложения, использующий этот подход.

Понадобится создать объект относительного URI, который именует документ XAML, находящийся в проекте. (Этот документ XAML компилируется и встраивается в сборку приложения в виде ресурса BAML. Именем ресурса является имя исходного файла XAML.)

Останов приложения

Обычно класс Application оставляет приложение активным до тех пор, пока открыто хотя бы одно окно. Если такое поведение не нужно, можно изменить значение свойства Application.ShutdownMode. При создании объекта Application вручную, свойство ShutdownMode должно быть установлено перед запуском Run(). Если используется файл App.xaml, можно просто установить свойство ShutdownMode в коде разметки XAML.

Режим останова приложения может принимать три значения:

OnLastWindowClose

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

OnMainWindowClose

Это традиционный подход — приложение остается активным только пока открыто главное окно

OnExplicitShutdown

Приложение не завершается (даже если все окна закрыты), пока не будет вызван метод Application.Shutdown(). Такой подход может быть оправдан, если приложение является интерфейсом для долго выполняющейся задачи. Также он применяется, если для принятия решения о закрытии приложения должна использоваться более сложная логика (в этом случае будет вызываться метод Application.Shutdown())

Независимо от того, какой способ останова используется, всегда есть возможность с помощью метода Application.Shutdown() немедленно завершить приложение. (Разумеется, после вызова метода Shutdown() приложение не обязательно сразу завершится. Вызов Application.Shutdown() заставляет метод Application.Run() немедленно вернуть управление, но может существовать дополнительный код, который выполняется в методе Main() или реагирует на событие Application.Exit.)

Когда ShutdownMode равно OnMainWindowClose, и закрывается главное окно, объект Application автоматически закроет все прочие окна перед тем, как метод Run() вернет управление. То же самое верно, если вызывается Application.Shutdown(). Это важно, потому что окна могут иметь код обработки событий, который инициируется при их закрытии.

Закрытие окна или диалогового окна (WPF .NET)

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

• Элемент Закрыть меню Система.
• Нажатие клавиш ALT+F4 .
• Нажатие кнопки Закрыть.
• Нажатие клавиши ESC , если свойство кнопки IsCancel имеет значение true в модальном окне.

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

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

После закрытия окна один и тот же экземпляр объекта не может использоваться для повторного открытия окна.

Дополнительные сведения о жизни окна см. в разделе «Обзор окон WPF: время существования окна».

Закрытие модального окна

При закрытии окна, открытого ShowDialog с помощью метода, задайте DialogResult для свойства true false значение «принято» или «отменено» соответственно. Как только свойству DialogResult задано значение, окно закрывается. В следующем коде показано, как задать DialogResult свойство:

private void okButton_Click(object sender, RoutedEventArgs e) => DialogResult = true; private void cancelButton_Click(object sender, RoutedEventArgs e) => DialogResult = false; 

Private Sub okButton_Click(sender As Object, e As RoutedEventArgs) DialogResult = True End Sub Private Sub cancelButton_Click(sender As Object, e As RoutedEventArgs) DialogResult = False End Sub 

Можно также вызвать Close метод. Close Если используется метод, DialogResult для свойства задано false значение .

После закрытия окна его невозможно повторно открыть с тем же экземпляром объекта. Если вы пытаетесь отобразить то же окно, InvalidOperationException создается исключение. Вместо этого создайте новый экземпляр окна и откройте его.

Закрытие безрежимного окна

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

private void closeButton_Click(object sender, RoutedEventArgs e) => Close(); 

Private Sub closeButton_Click(sender As Object, e As RoutedEventArgs) Close() End Sub 

Закрыть с IsCancel

Свойство Button.IsCancel можно задать, чтобы true включить клавишу ESC для автоматического закрытия окна. Это работает только при открытии окна с ShowDialog помощью метода.

Cancel 

Скрытие окна

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

private void saveButton_Click(object sender, RoutedEventArgs e) => Hide(); 

Private Sub saveButton_Click(sender As Object, e As RoutedEventArgs) Hide() End Sub 

Отмена закрытия и скрытия

Если вы разработали кнопки для скрытия окна вместо закрытия, пользователь по-прежнему может обойти это и закрыть окно. Элемент закрытия системного меню и кнопка «Закрыть» не клиентской области окна закроет окно вместо скрытия. Рассмотрим этот сценарий, когда намерение заключается в скрытии окна вместо закрытия.

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

При закрытии Closing окна возникает событие. Обработчик передается CancelEventArgs, который реализует Cancel свойство. Задайте это свойство, чтобы true предотвратить закрытие окна. В следующем коде показано, как отменить закрытие и скрыть окно:

private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) < // Cancel the closure e.Cancel = true; // Hide the window Hide(); >

Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs) ' Cancel the closure e.Cancel = True ' Hide the window Hide() End Sub 

Может возникнуть время, когда вы не хотите скрыть окно, но на самом деле запретить пользователю закрывать его. Дополнительные сведения см. в разделе «Обзор окон WPF: закрытие окна отмены».

См. также

• Общие сведения об окнах WPF
• Общие сведения о диалоговых окнах
• Открытие окна или диалогового окна
• System.Windows.Window.Close()
• System.Windows.Window.Closing
• System.Windows.Window.DialogResult
• System.Windows.Window.Hide()
• System.Windows.Window.Show()
• System.Windows.Window.ShowDialog()

Совместная работа с нами на GitHub

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