Свойство ShutdownMode указывает на способ выхода из приложения и может принимать одно из следующих значений:
- OnMainWindowClose : приложение работает, пока открыто главное окно
- OnLastWindowClose : приложение работает, пока открыто хотя бы одно окно
- OnExplicitShutdown : приложение работает, пока не будет явно вызвано Application.Shutdown()
Задать свойство ShutdownMode можно в коде xaml:
либо определить в App.xaml.cs:
public partial class App : Application < public App() < this.ShutdownMode = ShutdownMode.OnLastWindowClose; >>
События приложения
Класс Application определяет ряд событий, который могут использоваться для всего приложения:
- Startup : происходит после вызова метода Application.Run() и перед показом главного окна
- Activated : происходит, когда активизируется одно из окон приложения
- Deactivated : возникает при потере окном фокуса
- SessionEnding : происходит при завершении сеанса Windows при перезагрузке, выключении или выходе из системы текущего пользователя
- DispatcherUnhandledException : возникает при возникновении необработанных исключени
- LoadCompleted : возникает при завершении загрузки приложения
- Exit : возникает при выходе из приложения Это может быть закрытие главного или последнего окна, метод Application.Shutdown() или завершение сеанса
Так же, как и для элементов, обработчики события определяются для одноименных атрибутов в разметке xaml. Например, обработаем событие Startup:
Реализация кнопки «Свернуть» в WPF приложении (Главное окно, страница)
Затем в файле связанного кода App.xaml.cs пропишем обработчик события:
public partial class App : Application < //Запуск одной копии приложения System.Threading.Mutex mutex; private void App_Startup(object sender, StartupEventArgs e) < bool createdNew; string mutName = «Приложение»; mutex = new System.Threading.Mutex(true, mutName, out createdNew); if (!createdNew) < this.Shutdown(); >> >
В результате при запуске каждой новой копии данного приложение обработчик события будет определять, запущена ли уже приложение, и если оно запущено, то данная копия завершит свою работу.
Создание заставки приложения
Приложения бывают разные, одни открываются быстро, другие не очень. И чтобы пользователя как-то известить о том, что идет загрузка приложения, нередко используют заставку или сплеш-скрин. В WPF простые заставки на основе изображений очень легко сделать. Для этого добавьте в проект какое-нибудь изображение и после добавления установите для него в окне Properties (Свойства) для свойства BuildAction значение SplashScreen . И после запуска до появления окна приложения на экране будет висеть изображение заставки.
Обращение к текущему приложению
Создание и останов приложения
Добавление дополнительных окон в программу | WPF
В 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(). Это важно, потому что окна могут иметь код обработки событий, который инициируется при их закрытии.
Источник: professorweb.ru
Как программно выйти из приложения WPF?
В течение нескольких лет, когда я использовал С# (WinForms), я никогда не использовал WPF. Но теперь я люблю WPF, но я не знаю, как я должен выйти из приложения, когда пользователь нажимает на пункт меню «Выход» из меню «Файл».
this.Dispose(); this.Exit(); Application.ShutDown(); Application.Exit(); Application.Dispose();
Среди многих других. Ничего не работает.
ОТВЕТЫ
Ответ 1
Чтобы выйти из приложения, вы можете позвонить
System.Windows.Application.Current.Shutdown();
Как описано в документации к Application.Shutdown , вы также можете изменить поведение выключения приложения, указав ShutdownMode:
- Когда ShutdownMode установлен на OnLastWindowClose.
- Когда для параметра ShutdownMode установлено значение OnMainWindowClose.
- Когда пользователь заканчивает сеанс, и событие SessionEnding либо необработанно, либо обрабатывается без отмены.
Также обратите внимание, что Application.Current.Shutdown(); может вызываться только из потока, создавшего объект Application , т.е. обычно основной поток.
Ответ 2
Если вам действительно нужно закрыть его, вы также можете использовать Environment.Exit(), но это совсем не изящно (больше похоже на завершение процесс).
Environment.Exit(0)
Ответ 3
Как сказал wuminqi, Application.Current.Shutdown(); является необратимым, и я считаю, что он обычно используется для принудительного закрытия приложения, например, когда пользователь выходит из системы или выключает Windows. Вместо этого вызовите this.close() в главное окно. Это то же самое, что нажать «ALT-F4» или кнопку закрытия [x] в окне.
Это приведет к закрытию всех остальных закрытых окон и вызовет вызов Application.Current.Shutdown(); , пока действие закрытия не будет отменено. См. Документацию MSDN на Закрытие окна.
Кроме того, поскольку this.close() можно отменить, вы можете поместить в диалог подтверждения изменений изменений в обработчик закрывающего события. Просто создайте обработчик событий для и измените e.Cancel соответственно. (Подробнее о том, как это сделать, см. документ MSDN
Ответ 4
Это должно сделать трюк:
Application.Current.Shutdown();
Если вам интересно, вот некоторые дополнительные материалы, которые я нашел полезными:
Ответ 5
При необходимости используйте любое из следующих действий:
1.
App.Current.Shutdown(); OR Application.Current.Shutdown();
2.
App.Current.MainWindow.Close(); OR Application.Current.MainWindow.Close();
Прежде всего методы вызовут closing event класса Window , и выполнение может прекратиться в какой-то момент (так как обычно приложения ставят диалоги типа ) уверен? ‘ или’ Вы хотите сохранить данные перед закрытием? ‘, прежде чем окно будет полностью закрыто)
3. Но если вы хотите немедленно закрыть приложение без предупреждения. Используйте ниже
Environment.Exit(0);
Ответ 6
Не должно быть Application.ShutDown(); или .Exit().
Приложение представляет собой статический класс. Он не относится к текущему приложению Вам нужно перейти к текущему приложению, а затем закрыть его следующим образом:
Application.Current.Shutdown();
Ответ 7
Вот как я делаю свое:
// Any control that causes the Window.Closing even to trigger. private void MenuItemExit_Click(object sender, RoutedEventArgs e) < this.Close(); >// Method to handle the Window.Closing event. private void Window_Closing(object sender, CancelEventArgs e) < var response = MessageBox.Show(«Do you really want to exit?», «Exiting. «, MessageBoxButton.YesNo, MessageBoxImage.Exclamation); if (response == MessageBoxResult.No) < e.Cancel = true; >else < Application.Current.Shutdown(); >>
Я вызываю только Application.Current.ShutDown() из главного окна приложения, все остальные окна используют this.Close() . В моем главном окне Window_Closing(. ) обрабатывается верхняя правая кнопка x . Если какой-либо из методов вызывает приближение окна, Window_Closing(. ) захватывает событие для завершения, если пользователь подтверждает.
Я действительно использую Application.Current.ShutDown() в своем главном окне — это то, что я заметил, что если ошибка дизайна была сделана, и я не объявил родителя одного из моих окон в приложении, если это окно открывается без отображения перед последним активным закрытием окна, у меня осталось скрытое окно, работающее в фоновом режиме. Приложение не будет закрыто. Единственный способ предотвратить полную утечку памяти — это войти в диспетчер задач, чтобы закрыть приложение. Application.Current.ShutDown() защищает меня от непреднамеренных недостатков дизайна.
Это из моего личного опыта. В итоге используйте то, что лучше всего подходит для вашего сценария. Это всего лишь еще одна информация.
Ответ 8
private void _MenuExit_Click(object sender, RoutedEventArgs e) < System.Windows.Application.Current.MainWindow.Close(); >//Override the onClose method in the Application Main window protected override void OnClosing(System.ComponentModel.CancelEventArgs e) < MessageBoxResult result = MessageBox.Show(«Do you really want to close», «», MessageBoxButton.OKCancel); if (result == MessageBoxResult.Cancel) < e.Cancel = true; >base.OnClosing(e); >
Ответ 9
App.Current.Shutdown();
Application.Current.Shutdown();
Ответ 10
По моему мнению, Application.Current.Shutdown() также имеет свой недостаток,
если вы хотите показать окно подтверждения, чтобы пользователи могли подтвердить, что вы вышли или нет, Application.Current.Shutdown() является необратимым.
Ответ 11
Caliburn micro flavored
public class CloseAppResult : CancelResult < public override void Execute(CoroutineExecutionContext context) < Application.Current.Shutdown(); base.Execute(context); >> public class CancelResult : Result < public override void Execute(CoroutineExecutionContext context) < OnCompleted(this, new ResultCompletionEventArgs < WasCancelled = true >); > >