Bagikan melalui

Gambaran Umum Manajemen Aplikasi

  • Artikel

Semua aplikasi cenderung berbagi serangkaian fungsionalitas umum yang berlaku untuk implementasi dan manajemen aplikasi. Topik ini memberikan gambaran umum tentang fungsionalitas di Application kelas untuk membuat dan mengelola aplikasi.

Kelas Aplikasi

Di WPF, fungsionalitas cakupan aplikasi umum dienkapsulasi di Application kelas . Kelas Application ini mencakup fungsionalitas berikut:

  • Melacak dan berinteraksi dengan masa pakai aplikasi.

  • Mengambil dan memproses parameter baris perintah.

  • Mendeteksi dan merespons pengecualian yang tidak tertangani.

  • Berbagi properti dan sumber daya cakupan aplikasi.

  • Mengelola windows dalam aplikasi mandiri.

  • Melacak dan mengelola navigasi.

Cara Melakukan Tugas Umum Menggunakan Kelas Aplikasi

Jika Anda tidak tertarik dengan semua detail Application kelas, tabel berikut mencantumkan beberapa tugas umum untuk Application dan cara menyelesaikannya. Dengan melihat API dan topik terkait, Anda dapat menemukan informasi lebih lanjut dan kode sampel.

Tugas Pendekatan
Mendapatkan objek yang mewakili aplikasi saat ini Gunakan properti Application.Current.
Menambahkan layar startup ke aplikasi Lihat Menambahkan Layar Splash ke Aplikasi WPF.
Memulai aplikasi Gunakan metode Application.Run.
Menghentikan aplikasi Shutdown Gunakan metode Application.Current objek.
Mendapatkan argumen dari baris perintah Application.Startup Tangani peristiwa dan gunakan StartupEventArgs.Args properti . Misalnya, lihat Application.Startup peristiwa.
Mendapatkan dan mengatur kode keluar aplikasi Atur ExitEventArgs.ApplicationExitCodeApplication.Exit properti di penanganan aktivitas atau panggil Shutdown metode dan teruskan bilangan bulat.
Mendeteksi dan merespons pengecualian yang tidak tertangani DispatcherUnhandledException Tangani peristiwa.
Mendapatkan dan mengatur sumber daya cakupan aplikasi Gunakan properti Application.Resources.
Menggunakan kamus sumber daya cakupan aplikasi Lihat Menggunakan Kamus Sumber Daya Cakupan Aplikasi.
Mendapatkan dan mengatur properti cakupan aplikasi Gunakan properti Application.Properties.
Mendapatkan dan menyimpan status aplikasi Lihat Mempertahankan dan Memulihkan Properti Cakupan Aplikasi di Seluruh Sesi Aplikasi.
Mengelola file data non-kode, termasuk file sumber daya, file konten, dan file situs asal. Lihat Sumber Daya Aplikasi, Konten, dan File Data WPF.
Mengelola jendela dalam aplikasi mandiri Lihat Gambaran Umum Windows WPF.
Melacak dan mengelola navigasi Lihat Gambaran Umum Navigasi.

Definisi Aplikasi

Untuk menggunakan fungsionalitas Application kelas, Anda harus menerapkan definisi aplikasi. Definisi aplikasi WPF adalah kelas yang berasal dari Application dan dikonfigurasi dengan pengaturan MSBuild khusus.

Menerapkan Definisi Aplikasi

Definisi aplikasi WPF umum diimplementasikan menggunakan markup dan code-behind. Ini memungkinkan Anda menggunakan markup untuk secara deklaratif mengatur properti aplikasi, sumber daya, dan mendaftarkan peristiwa, sambil menangani peristiwa dan menerapkan perilaku khusus aplikasi di code-behind.

Contoh berikut menunjukkan cara menerapkan definisi aplikasi menggunakan markup dan code-behind:

<Application 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
  x:Class="SDKSample.App" />

using System.Windows;

namespace SDKSample
{
    public partial class App : Application { }
}


Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
    End Class
End Namespace

Untuk mengizinkan file markup dan file code-behind bekerja sama, hal berikut perlu terjadi:

  • Dalam markup, elemen Application harus menyertakan atribut x:Class. Ketika aplikasi dibuat, keberadaan x:Class dalam file markup menyebabkan MSBuild membuat partial kelas yang berasal dari Application dan memiliki nama yang ditentukan oleh x:Class atribut . Hal ini memerlukan penambahan deklarasi namespace XML untuk skema XAML (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

  • Dalam code-behind, kelas harus kelas partial dengan nama yang sama yang ditentukan oleh x:Class atribut dalam markup dan harus berasal dari Application. Ini memungkinkan file code-behind dikaitkan dengan partial kelas yang dihasilkan untuk file markup saat aplikasi dibuat (lihat Membangun Aplikasi WPF).

Catatan

Saat Anda membuat proyek Aplikasi WPF baru atau proyek Aplikasi Browser WPF menggunakan Visual Studio, definisi aplikasi disertakan secara default dan didefinisikan menggunakan markup dan kode di belakang.

Kode ini adalah minimum yang diperlukan untuk menerapkan definisi aplikasi. Namun, konfigurasi MSBuild tambahan perlu dibuat ke definisi aplikasi sebelum membangun dan menjalankan aplikasi.

Mengonfigurasi Definisi Aplikasi untuk MSBuild

Aplikasi mandiri dan aplikasi browser XAML (XBAP) memerlukan implementasi tingkat infrastruktur tertentu sebelum dapat berjalan. Bagian terpenting dari infrastruktur ini adalah titik masuk. Ketika aplikasi diluncurkan oleh pengguna, sistem operasi memanggil titik masuk, yang merupakan fungsi terkenal untuk memulai aplikasi.

Peringatan

XBAP memerlukan browser warisan untuk beroperasi, seperti Internet Explorer dan Firefox. Versi browser lama ini biasanya tidak didukung pada Windows 10 dan Windows 11. Browser modern tidak lagi mendukung teknologi yang diperlukan untuk aplikasi XBAP karena risiko keamanan. Plugin yang mengaktifkan XBAP tidak lagi didukung.

Secara tradisional, pengembang harus menulis beberapa atau semua kode ini untuk diri mereka sendiri, tergantung pada teknologinya. Namun, WPF menghasilkan kode ini untuk Anda ketika file markup definisi aplikasi Anda dikonfigurasi sebagai item MSBuild ApplicationDefinition , seperti yang ditunjukkan dalam file proyek MSBuild berikut:

<Project
  DefaultTargets="Build"
                        xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  ...
  <ApplicationDefinition Include="App.xaml" />
  <Compile Include="App.xaml.cs" />
  ...
</Project>

Karena file code-behind berisi kode, file tersebut ditandai sebagai item MSBuild Compile , seperti biasa.

Aplikasi konfigurasi MSBuild ini ke file markup dan code-behind dari definisi aplikasi menyebabkan MSBuild menghasilkan kode seperti berikut:

using System;
using System.Windows;

namespace SDKSample
{
    public class App : Application
    {
        public App() { }
        [STAThread]
        public static void Main()
        {
            // Create new instance of application subclass
            App app = new App();

            // Code to register events and set properties that were
            // defined in XAML in the application definition
            app.InitializeComponent();

            // Start running the application
            app.Run();
        }

        public void InitializeComponent()
        {
            // Initialization code goes here.
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Public Class App
        Inherits Application
        Public Sub New()
        End Sub
        <STAThread>
        Public Shared Sub Main()
            ' Create new instance of application subclass
            Dim app As New App()

            ' Code to register events and set properties that were
            ' defined in XAML in the application definition
            app.InitializeComponent()

            ' Start running the application
            app.Run()
        End Sub

        Public Sub InitializeComponent()
            ' Initialization code goes here.	
        End Sub
    End Class
End Namespace

Kode yang dihasilkan menambah definisi aplikasi Anda dengan kode infrastruktur tambahan, yang mencakup metode Maintitik masuk . Atribut STAThreadAttribute diterapkan ke Main metode untuk menunjukkan bahwa utas UI utama untuk aplikasi WPF adalah utas STA, yang diperlukan untuk aplikasi WPF. Saat dipanggil, Main buat instans App baru sebelum memanggil InitializeComponent metode untuk mendaftarkan peristiwa dan mengatur properti yang diimplementasikan dalam markup. Karena InitializeComponent dibuat untuk Anda, Anda tidak perlu secara eksplisit memanggil InitializeComponent dari definisi aplikasi seperti yang Anda lakukan untuk Page dan Window implementasi. Akhirnya, Run metode ini dipanggil untuk memulai aplikasi.

Mendapatkan Aplikasi Saat Ini

Karena fungsionalitas Application kelas dibagikan di seluruh aplikasi, hanya ada satu instans Application kelas per AppDomain. Untuk menerapkan ini, Application kelas diimplementasikan sebagai kelas singleton (lihat Menerapkan Singleton di C#), yang membuat satu instans itu sendiri dan menyediakan akses bersama ke staticCurrent dalamnya dengan properti .

Kode berikut menunjukkan cara memperoleh referensi ke Application objek untuk saat ini AppDomain.

// Get current application
Application current = App.Current;

' Get current application
Dim current As Application = App.Current

Current mengembalikan referensi ke instans Application kelas. Jika Anda menginginkan referensi ke kelas turunan, Application Anda harus mentransmisikan nilai Current properti, seperti yang ditunjukkan dalam contoh berikut.

// Get strongly-typed current application
App app = (App)App.Current;

' Get strongly-typed current application
Dim appCurrent As App = CType(App.Current, App)

Anda dapat memeriksa nilai Current kapan saja dalam masa Application pakai objek. Namun, Anda harus berhati-hati. Application Setelah kelas dibuat, ada periode di mana status Application objek tidak konsisten. Selama periode ini, Application sedang melakukan berbagai tugas inisialisasi yang diperlukan oleh kode Anda untuk dijalankan, termasuk membuat infrastruktur aplikasi, mengatur properti, dan mendaftarkan peristiwa. Jika Anda mencoba menggunakan Application objek selama periode ini, kode Anda mungkin memiliki hasil yang tidak terduga, terutama jika bergantung pada berbagai Application properti yang diatur.

Ketika Application menyelesaikan pekerjaan inisialisasinya, masa pakainya benar-benar dimulai.

Masa Pakai Aplikasi

Masa pakai aplikasi WPF ditandai oleh beberapa peristiwa yang dinaikkan oleh Application untuk memberi tahu Anda ketika aplikasi Anda telah dimulai, telah diaktifkan dan dinonaktifkan, dan telah dimatikan.

Layar Percikan

Mulai dari .NET Framework 3.5 SP1, Anda dapat menentukan gambar yang akan digunakan di jendela startup, atau layar percikan. Kelas SplashScreen memudahkan untuk menampilkan jendela startup saat aplikasi Anda dimuat. Jendela SplashScreen dibuat dan ditampilkan sebelumnya Run dipanggil. Untuk informasi selengkapnya, lihat Waktu Startup Aplikasi dan Menambahkan Layar Splash ke Aplikasi WPF.

Memulai Aplikasi

Setelah Run dipanggil dan aplikasi diinisialisasi, aplikasi siap dijalankan. Momen ini ditandatangani ketika Startup acara dinaikkan:

using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Application is running
        }
    }
}


Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Application is running
            '</SnippetStartupCODEBEHIND1>
    End Class
End Namespace
'</SnippetStartupCODEBEHIND2>

Pada titik ini dalam masa pakai aplikasi, hal paling umum yang harus dilakukan adalah menunjukkan UI.

Menampilkan Antarmuka Pengguna

Sebagian besar aplikasi Windows mandiri membuka Window ketika mereka mulai berjalan. Penanganan Startup aktivitas adalah salah satu lokasi tempat Anda dapat melakukan ini, seperti yang ditunjukkan oleh kode berikut.

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

using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Open a window
            MainWindow window = new MainWindow();
            window.Show();
        }
    }
}


Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Open a window
            Dim window As New MainWindow()
            window.Show()
        End Sub
    End Class
End Namespace

Catatan

Yang pertama Window dibuat dalam aplikasi mandiri menjadi jendela aplikasi utama secara default. Objek ini Window dirujuk oleh Application.MainWindow properti . Nilai MainWindow properti dapat diubah secara terprogram jika jendela yang berbeda dari jendela pertama yang dibuat Window harus menjadi jendela utama.

Ketika XBAP pertama kali dimulai, kemungkinan besar akan menavigasi ke Page. Hal ini ditunjukkan dalam segmen kode berikut.

<Application 
  x:Class="SDKSample.App"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Startup="App_Startup" />

using System;
using System.Windows;
using System.Windows.Navigation;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            ((NavigationWindow)this.MainWindow).Navigate(new Uri("HomePage.xaml", UriKind.Relative));
        }
    }
}


Imports System.Windows
Imports System.Windows.Navigation

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            CType(Me.MainWindow, NavigationWindow).Navigate(New Uri("HomePage.xaml", UriKind.Relative))
        End Sub
    End Class
End Namespace

Jika Anda menangani Startup untuk hanya membuka Window atau menavigasi ke Page, Anda dapat mengatur StartupUri atribut dalam markup sebagai gantinya.

Contoh berikut menunjukkan cara menggunakan StartupUri dari aplikasi mandiri untuk membuka Window.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="MainWindow.xaml" />

Contoh berikut menunjukkan cara menggunakan StartupUri dari XBAP untuk menavigasi ke Page.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    StartupUri="HomePage.xaml" />

Markup ini memiliki efek yang sama dengan kode sebelumnya untuk membuka jendela.

Catatan

Untuk informasi selengkapnya tentang navigasi, lihat Gambaran Umum Navigasi.

Anda perlu menangani Startup peristiwa untuk membuka Window jika Anda perlu membuat instansnya menggunakan konstruktor non-parameterless, atau Anda perlu mengatur propertinya atau berlangganan peristiwanya sebelum menampilkannya, atau Anda perlu memproses argumen baris perintah apa pun yang disediakan saat aplikasi diluncurkan.

Memproses Argumen Baris Perintah

Di Windows, aplikasi mandiri dapat diluncurkan dari prompt perintah atau desktop. Dalam kedua kasus, argumen baris perintah dapat diteruskan ke aplikasi. Contoh berikut menunjukkan aplikasi yang diluncurkan dengan argumen baris perintah tunggal, "/StartMinimized":

wpfapplication.exe /StartMinimized

Selama inisialisasi aplikasi, WPF mengambil argumen baris perintah dari sistem operasi dan meneruskannya ke Startup penanganan aktivitas melalui Args properti StartupEventArgs parameter. Anda dapat mengambil dan menyimpan argumen baris perintah menggunakan kode seperti berikut ini.

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

using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_Startup(object sender, StartupEventArgs e)
        {
            // Application is running
            // Process command line args
            bool startMinimized = false;
            for (int i = 0; i != e.Args.Length; ++i)
            {
                if (e.Args[i] == "/StartMinimized")
                {
                    startMinimized = true;
                }
            }

            // Create main application window, starting minimized if specified
            MainWindow mainWindow = new MainWindow();
            if (startMinimized)
            {
                mainWindow.WindowState = WindowState.Minimized;
            }
            mainWindow.Show();
        }
    }
}


Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Application is running
            ' Process command line args
            Dim startMinimized As Boolean = False
            Dim i As Integer = 0
            Do While i <> e.Args.Length
                If e.Args(i) = "/StartMinimized" Then
                    startMinimized = True
                End If
                i += 1
            Loop

            ' Create main application window, starting minimized if specified
            Dim mainWindow As New MainWindow()
            If startMinimized Then
                mainWindow.WindowState = WindowState.Minimized
            End If
            mainWindow.Show()
        End Sub
    End Class
End Namespace

Kode menangani Startup untuk memeriksa apakah argumen baris perintah /StartMinimized disediakan; jika demikian, kode akan membuka jendela utama dengan WindowState .Minimized Perhatikan bahwa karena WindowState properti harus diatur secara terprogram, yang utama Window harus dibuka secara eksplisit dalam kode.

XBAP tidak dapat mengambil dan memproses argumen baris perintah karena diluncurkan menggunakan penyebaran ClickOnce (lihat Menyebarkan Aplikasi WPF). Namun, mereka dapat mengambil dan memproses parameter string kueri dari URL yang digunakan untuk meluncurkannya.

Aktivasi dan Pennonaktifkanan Aplikasi

Windows memungkinkan pengguna beralih antar aplikasi. Cara paling umum adalah menggunakan kombinasi tombol ALT+TAB. Aplikasi hanya dapat dialihkan jika memiliki tampilan Window yang dapat dipilih pengguna. Yang saat ini dipilih Window adalah jendela aktif (juga dikenal sebagai jendela latar depan) dan merupakan Window yang menerima input pengguna. Aplikasi dengan jendela aktif adalah aplikasi aktif (atau aplikasi latar depan). Aplikasi menjadi aplikasi aktif dalam keadaan berikut:

  • Ini diluncurkan dan menunjukkan Window.

  • Pengguna beralih dari aplikasi lain dengan memilih Window di aplikasi.

Anda dapat mendeteksi kapan aplikasi menjadi aktif dengan menangani Application.Activated peristiwa.

Demikian juga, aplikasi dapat menjadi tidak aktif dalam keadaan berikut:

  • Pengguna beralih ke aplikasi lain dari aplikasi saat ini.

  • Ketika aplikasi dimatikan.

Anda dapat mendeteksi kapan aplikasi menjadi tidak aktif dengan menangani Application.Deactivated peristiwa.

Kode berikut menunjukkan cara menangani Activated peristiwa dan Deactivated untuk menentukan apakah aplikasi aktif.

<Application 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App"
  StartupUri="MainWindow.xaml"
  Activated="App_Activated" 
  Deactivated="App_Deactivated" />

using System;
using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        bool isApplicationActive;

        void App_Activated(object sender, EventArgs e)
        {
            // Application activated
            this.isApplicationActive = true;
        }

        void App_Deactivated(object sender, EventArgs e)
        {
            // Application deactivated
            this.isApplicationActive = false;
        }
    }
}


Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private isApplicationActive As Boolean

        Private Sub App_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Application activated
            Me.isApplicationActive = True
        End Sub

        Private Sub App_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
            ' Application deactivated
            Me.isApplicationActive = False
        End Sub
    End Class
End Namespace

Juga Window dapat diaktifkan dan dinonaktifkan. Lihat Window.Activated dan Window.Deactivated untuk informasi selengkapnya.

Catatan

Baik Application.Activated maupun Application.Deactivated dinaikkan untuk XBAP.

Penonaktifan Aplikasi

Masa pakai aplikasi berakhir ketika dimatikan, yang dapat terjadi karena alasan berikut:

  • Pengguna menutup setiap Window.

  • Pengguna menutup utama Window.

  • Pengguna mengakhiri sesi Windows dengan log keluar atau mematikan.

  • Kondisi khusus aplikasi telah terpenuhi.

Untuk membantu Anda mengelola penonaktifan aplikasi, Application berikan metode, ShutdownMode properti, dan SessionEnding peristiwa dan Exit .Shutdown

Catatan

Shutdown hanya dapat dipanggil dari aplikasi yang memiliki UIPermission. Aplikasi WPF mandiri selalu memiliki izin ini. Namun, XBAP yang berjalan di kotak pasir keamanan kepercayaan parsial zona Internet tidak.

Mode Matikan

Sebagian besar aplikasi dimatikan baik ketika semua jendela ditutup atau ketika jendela utama ditutup. Namun, terkadang, kondisi khusus aplikasi lainnya dapat menentukan kapan aplikasi dimatikan. Anda dapat menentukan kondisi di mana aplikasi Anda akan dimatikan dengan mengatur ShutdownMode dengan salah satu nilai enumerasi berikut ShutdownMode :

Nilai ShutdownMode default adalah OnLastWindowClose, yang berarti bahwa aplikasi secara otomatis dimatikan ketika jendela terakhir dalam aplikasi ditutup oleh pengguna. Namun, jika aplikasi Anda harus dimatikan saat jendela utama ditutup, WPF secara otomatis melakukannya jika Anda mengatur ShutdownMode ke OnMainWindowClose. Hal ini ditunjukkan di contoh berikut.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    ShutdownMode="OnMainWindowClose" />

Ketika Anda memiliki kondisi matikan khusus aplikasi, Anda mengatur ShutdownMode ke OnExplicitShutdown. Dalam hal ini, Anda bertanggung jawab untuk mematikan aplikasi dengan secara eksplisit memanggil Shutdown metode; jika tidak, aplikasi Anda akan terus berjalan bahkan jika semua jendela ditutup. Perhatikan bahwa Shutdown dipanggil secara implisit ketika ShutdownMode adalah OnLastWindowClose atau OnMainWindowClose.

Catatan

ShutdownMode dapat diatur dari XBAP, tetapi diabaikan; XBAP selalu dimatikan ketika dinavigasi jauh dari browser atau ketika browser yang menghosting XBAP ditutup. Untuk informasi selengkapnya, lihat Gambaran Umum Navigasi.

Akhir Sesi

Kondisi matikan yang dijelaskan oleh ShutdownMode properti khusus untuk aplikasi. Namun, dalam beberapa kasus, aplikasi dapat dimatikan sebagai akibat dari kondisi eksternal. Kondisi eksternal yang paling umum terjadi ketika pengguna mengakhiri sesi Windows dengan tindakan berikut:

  • Pengelogan nonaktif

  • Mematikan

  • Restart

  • Hibernasi

Untuk mendeteksi kapan sesi Windows berakhir, Anda dapat menangani SessionEnding peristiwa, seperti yang diilustrasikan dalam contoh berikut.

<Application 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="MainWindow.xaml"
    SessionEnding="App_SessionEnding" />

using System.Windows;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_SessionEnding(object sender, SessionEndingCancelEventArgs e)
        {
            // Ask the user if they want to allow the session to end
            string msg = string.Format("{0}. End session?", e.ReasonSessionEnding);
            MessageBoxResult result = MessageBox.Show(msg, "Session Ending", MessageBoxButton.YesNo);

            // End session, if specified
            if (result == MessageBoxResult.No)
            {
                e.Cancel = true;
            }
        }
    }
}


Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_SessionEnding(ByVal sender As Object, ByVal e As SessionEndingCancelEventArgs)
            ' Ask the user if they want to allow the session to end
            Dim msg As String = String.Format("{0}. End session?", e.ReasonSessionEnding)
            Dim result As MessageBoxResult = MessageBox.Show(msg, "Session Ending", MessageBoxButton.YesNo)

            ' End session, if specified
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End Sub
    End Class
End Namespace

Dalam contoh ini, kode memeriksa ReasonSessionEnding properti untuk menentukan bagaimana sesi Windows berakhir. Ini menggunakan nilai ini untuk menampilkan pesan konfirmasi kepada pengguna. Jika pengguna tidak ingin sesi berakhir, kode diatur Cancel untuk true mencegah sesi Windows berakhir.

Catatan

SessionEnding tidak dinaikkan untuk XBAP.

Keluar

Ketika aplikasi dimatikan, aplikasi mungkin perlu melakukan beberapa pemrosesan akhir, seperti status aplikasi yang bertahan. Untuk situasi ini, Anda dapat menangani Exit peristiwa, seperti yang App_Exit dilakukan penanganan aktivitas dalam contoh berikut. Ini didefinisikan sebagai penanganan aktivitas dalam file App.xaml . Implementasinya disorot dalam file App.xaml.cs dan Application.xaml.vb .

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="MainWindow.xaml" 
    Startup="App_Startup" 
    Exit="App_Exit">
    <Application.Resources>
        <SolidColorBrush x:Key="ApplicationScopeResource" Color="White"></SolidColorBrush>
    </Application.Resources>
</Application>

using System.Windows;
using System.IO;
using System.IO.IsolatedStorage;

namespace SDKSample
{
    public partial class App : Application
    {
        string filename = "App.txt";

        public App()
        {
            // Initialize application-scope property
            this.Properties["NumberOfAppSessions"] = 0;
        }

        private void App_Startup(object sender, StartupEventArgs e)
        {
            // Restore application-scope property from isolated storage
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForDomain();
            try
            {
                using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(filename, FileMode.Open, storage))
                using (StreamReader reader = new StreamReader(stream))
                {
                    // Restore each application-scope property individually
                    while (!reader.EndOfStream)
                    {
                        string[] keyValue = reader.ReadLine().Split(new char[] {','});
                        this.Properties[keyValue[0]] = keyValue[1];
                    }
                }
            }
            catch (FileNotFoundException ex)
            {
                // Handle when file is not found in isolated storage:
                // * When the first application session
                // * When file has been deleted
            }
        }

        private void App_Exit(object sender, ExitEventArgs e)
        {
            // Persist application-scope property to isolated storage
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForDomain();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(filename, FileMode.Create, storage))
            using (StreamWriter writer = new StreamWriter(stream))
            {
                // Persist each application-scope property individually
                foreach (string key in this.Properties.Keys)
                {
                    writer.WriteLine("{0},{1}", key, this.Properties[key]);
                }
            }
        }
    }
}

Imports System.IO
Imports System.IO.IsolatedStorage

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private filename As String = "App.txt"

        Public Sub New()
            ' Initialize application-scope property
            Me.Properties("NumberOfAppSessions") = 0
        End Sub

        Private Sub App_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Restore application-scope property from isolated storage
            Dim storage As IsolatedStorageFile = IsolatedStorageFile.GetUserStoreForDomain()
            Try
                Using stream As New IsolatedStorageFileStream(filename, FileMode.Open, storage)
                Using reader As New StreamReader(stream)
                    ' Restore each application-scope property individually
                    Do While Not reader.EndOfStream
                        Dim keyValue() As String = reader.ReadLine().Split(New Char() {","c})
                        Me.Properties(keyValue(0)) = keyValue(1)
                    Loop
                End Using
                End Using
            Catch ex As FileNotFoundException
                ' Handle when file is not found in isolated storage:
                ' * When the first application session
                ' * When file has been deleted
            End Try
        End Sub

        Private Sub App_Exit(ByVal sender As Object, ByVal e As ExitEventArgs)
            ' Persist application-scope property to isolated storage
            Dim storage As IsolatedStorageFile = IsolatedStorageFile.GetUserStoreForDomain()
            Using stream As New IsolatedStorageFileStream(filename, FileMode.Create, storage)
            Using writer As New StreamWriter(stream)
                ' Persist each application-scope property individually
                For Each key As String In Me.Properties.Keys
                    writer.WriteLine("{0},{1}", key, Me.Properties(key))
                Next key
            End Using
            End Using
        End Sub
    End Class
End Namespace

Untuk contoh lengkapnya, lihat Mempertahankan dan Memulihkan Properti Cakupan Aplikasi Di Seluruh Sesi Aplikasi.

Exit dapat ditangani oleh aplikasi mandiri dan XBAP. Untuk XBAP, Exit dimunculkan ketika dalam keadaan berikut:

  • XBAP dinavigasi menjauh.

  • Di Internet Explorer, ketika tab yang menghosting XBAP ditutup.

  • Saat browser ditutup.

Kode Keluar

Aplikasi sebagian besar diluncurkan oleh sistem operasi sebagai respons terhadap permintaan pengguna. Namun, aplikasi dapat diluncurkan oleh aplikasi lain untuk melakukan beberapa tugas tertentu. Ketika aplikasi yang diluncurkan dimatikan, aplikasi peluncuran mungkin ingin mengetahui kondisi di mana aplikasi yang diluncurkan dimatikan. Dalam situasi ini, Windows memungkinkan aplikasi untuk mengembalikan kode keluar aplikasi saat dimatikan. Secara default, aplikasi WPF mengembalikan nilai kode keluar 0.

Catatan

Saat Anda men-debug dari Visual Studio, kode keluar aplikasi ditampilkan di jendela Output saat aplikasi dimatikan, dalam pesan yang terlihat seperti berikut ini:

The program '[5340] AWPFApp.vshost.exe: Managed' has exited with code 0 (0x0).

Anda membuka jendela Output dengan mengklik Output pada menu Tampilan .

Untuk mengubah kode keluar, Anda dapat memanggil Shutdown(Int32) kelebihan beban, yang menerima argumen bilangan bulat menjadi kode keluar:

// Shutdown and return a non-default exit code
Application.Current.Shutdown(-1);

' Shutdown and return a non-default exit code
Application.Current.Shutdown(-1)

Anda dapat mendeteksi nilai kode keluar, dan mengubahnya, dengan menangani Exit peristiwa. Penanganan Exit aktivitas diteruskan yang ExitEventArgs menyediakan akses ke kode keluar dengan ApplicationExitCode properti . Untuk informasi selengkapnya, lihat Exit .

Catatan

Anda dapat mengatur kode keluar di aplikasi mandiri dan XBAP. Namun, nilai kode keluar diabaikan untuk XBAP.

Pengecualian Tidak Tertangani

Terkadang aplikasi dapat dimatikan dalam kondisi abnormal, seperti ketika pengecualian yang tidak diantisipasi dilemparkan. Dalam hal ini, aplikasi mungkin tidak memiliki kode untuk mendeteksi dan memproses pengecualian. Jenis pengecualian ini adalah pengecualian yang tidak tertangani; pemberitahuan yang mirip dengan yang ditunjukkan pada gambar berikut ditampilkan sebelum aplikasi ditutup.

Screenshot that shows an unhandled exception notification.

Dari perspektif pengalaman pengguna, lebih baik aplikasi menghindari perilaku default ini dengan melakukan beberapa atau semua hal berikut:

  • Menampilkan informasi yang mudah digunakan.

  • Mencoba untuk menjaga aplikasi tetap berjalan.

  • Merekam informasi pengecualian terperinci dan ramah pengembang di log peristiwa Windows.

Menerapkan dukungan ini tergantung pada kemampuan untuk mendeteksi pengecualian yang tidak tertangani, yang merupakan tujuan DispatcherUnhandledException dimunculkannya peristiwa tersebut.

<Application
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="SDKSample.App"
  StartupUri="MainWindow.xaml"
  DispatcherUnhandledException="App_DispatcherUnhandledException" />

using System.Windows;
using System.Windows.Threading;

namespace SDKSample
{
    public partial class App : Application
    {
        void App_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            // Process unhandled exception

            // Prevent default unhandled exception processing
            e.Handled = true;
        }
    }
}

Imports System.Windows
Imports System.Windows.Threading

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub App_DispatcherUnhandledException(ByVal sender As Object, ByVal e As DispatcherUnhandledExceptionEventArgs)
            ' Process unhandled exception

            ' Prevent default unhandled exception processing
            e.Handled = True
        End Sub
    End Class
End Namespace

Penanganan DispatcherUnhandledException aktivitas diteruskan parameter DispatcherUnhandledExceptionEventArgs yang berisi informasi kontekstual mengenai pengecualian yang tidak tertangani, termasuk pengecualian itu sendiri (DispatcherUnhandledExceptionEventArgs.Exception). Anda dapat menggunakan informasi ini untuk menentukan cara menangani pengecualian.

Ketika Anda menangani , Anda harus mengatur DispatcherUnhandledExceptionEventArgs.Handled properti ke true; jika tidak, WPF masih menganggap pengecualian tidak tertangani DispatcherUnhandledExceptiondan kembali ke perilaku default yang dijelaskan sebelumnya. Jika pengecualian yang tidak tertangani dinaikkan dan DispatcherUnhandledException peristiwa tidak ditangani, atau peristiwa ditangani dan Handled diatur ke false, aplikasi segera dimatikan. Selain itu, tidak ada peristiwa lain Application yang dimunculkan. Akibatnya, Anda perlu menangani DispatcherUnhandledException apakah aplikasi Anda memiliki kode yang harus berjalan sebelum aplikasi dimatikan.

Meskipun aplikasi dapat dimatikan sebagai akibat dari pengecualian yang tidak tertangani, aplikasi biasanya dimatikan sebagai respons terhadap permintaan pengguna, seperti yang dibahas di bagian berikutnya.

Peristiwa Seumur Hidup Aplikasi

Aplikasi mandiri dan XBAP tidak memiliki masa pakai yang sama persis. Gambar berikut mengilustrasikan peristiwa utama dalam masa pakai aplikasi mandiri dan menunjukkan urutan di mana mereka dinaikkan.

Standalone Application - Application Object Events

Demikian juga, gambar berikut mengilustrasikan peristiwa utama dalam masa pakai XBAP, dan menunjukkan urutan di mana mereka dinaikkan.

XBAP - Application Object Events

Lihat juga