Uygulama Yönetimine Genel Bakış

Tüm uygulamalar, uygulama uygulaması ve yönetimi için geçerli olan ortak bir işlev kümesi paylaşma eğilimindedir. Bu konu, uygulama oluşturma ve yönetmeye ilişkin Application sınıfındaki işlevlere genel bir bakış sağlar.

Uygulama Sınıfı

WPF'de, yaygın uygulama kapsamlı işlevler sınıfında Application kapsüller. Applicationsınıfı aşağıdaki işlevleri içerir:

  • Uygulama ömrünü izleme ve uygulama ömrüyle etkileşim kurma.

  • Komut satırı parametrelerini alma ve işleme.

  • İşlenemeyen özel durumları algılama ve yanıt verme.

  • Uygulama kapsamı özelliklerini ve kaynaklarını paylaşma.

  • Tek başına uygulamalarda pencereleri yönetme.

  • Gezintiyi izleme ve yönetme.

Uygulama Sınıfını Kullanarak Ortak Görevleri Gerçekleştirme

Sınıfın tüm ayrıntılarıyla ilgilenmezsiniz, aşağıdaki tabloda için bazı yaygın görevler ve bunların Application nasıl Application gerçekleştirnleri listele türetir. İlgili API'yi ve konuları görüntüerek daha fazla bilgi ve örnek kod bulabilirsiniz.

Görev Yaklaşım
Geçerli uygulamayı temsil eden bir nesne al özelliğini Application.Current kullanın.
Uygulamaya başlangıç ekranı ekleme Bkz. WPF Uygulamasına Giriş Ekranı Ekleme.
Uygulama başlatma Application.Run yöntemini kullanın.
Uygulamayı durdurma nesnesinin Shutdown yöntemini Application.Current kullanın.
Komut satırı bağımsız değişkenlerini al Olayı Application.Startup işin ve özelliğini StartupEventArgs.Args kullanın. Örneğin olayına Application.Startup bakın.
Uygulama çıkış kodunu al ve ayarla Olay ExitEventArgs.ApplicationExitCode işleyicisinde Application.Exit özelliğini ayarlayın veya yöntemini Shutdown çağırarak bir tamsayıyı girin.
İşlenemeyen özel durumları algılama ve yanıtlama Olayı DispatcherUnhandledException işle.
Uygulama kapsamlı kaynakları al ve ayarla özelliğini Application.Resources kullanın.
Uygulama kapsamı kaynak sözlüğü kullanma Bkz. Application-Scope Kaynak Sözlüğü kullanma.
Uygulama kapsamlı özellikleri al ve ayarla özelliğini Application.Properties kullanın.
Uygulamanın durumunu al ve kaydet Bkz. Uygulama Oturumları arasında Application-Scope Kalıcı Ve Geri YüklemeÖzellikleri.
Kaynak dosyaları, içerik dosyaları ve kaynak site dosyaları da dahil olmak üzere kod olmayan veri dosyalarını yönetin. Bkz. WPF Uygulama Kaynağı, İçerik ve Veri Dosyaları.
Tek başına uygulamalarda pencereleri yönetme Bkz. WPF Windows Genel Bakış.
Gezintiyi izleme ve yönetme Bkz. Gezintiye Genel Bakış.

Uygulama Tanımı

sınıfının işlevselliğini kullanmak için Application bir uygulama tanımı uygulamalı. WPF uygulama tanımı, 'den türeten ve özel bir uygulama Application tanımı ayarıyla yapılandırılmış MSBuild sınıfıdır.

Uygulama Tanımı Uygulama

Tipik bir WPF uygulama tanımı hem işaretleme hem de arka kod kullanılarak uygulanır. Bu, işaretlemeyi kullanarak uygulama özelliklerini, kaynaklarını ve kayıt olaylarını bildirimli olarak ayarlamaya, olayları işlemeye ve arka kodda uygulamaya özgü davranış uygulamaya olanak sağlar.

Aşağıdaki örnekte, bir uygulama tanımının hem işaretleme hem de arka kod kullanılarak nasıl uygulanarak uygulanarak gerçekleştirilleri gösterir:

<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

Bir işaretleme dosyasının ve arka arkasındaki kodun birlikte çalışmasına izin vermek için aşağıdakilerin yapılması gerekir:

  • işaretlemesinde, Application öğesi özniteliğini x:Class içermeli. Uygulama yerleşik olduğunda, işaretleme dosyasında varlığı MSBuild ve özniteliği tarafından belirtilen adı olan bir sınıf oluşturmak için x:Classpartial neden Applicationx:Class olur. Bu, XAML şeması () için bir XML ad alanı bildiriminin ekini xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" gerektirir.

  • Arka kodda, sınıfı işaretlemede özniteliği tarafından belirtilen aynı adla bir sınıf olmalı ve partialx:Class 'den türetilmelidir. Application Bu, arka arkasındaki kod dosyasının, uygulama oluşturulurken işaretleme dosyası için oluşturulan sınıfla ilişkilendirilebilir partial (bkz. partialUygulaması Oluşturma).

Not

Visual Studio kullanarak yeni bir WPF Uygulaması projesi veya WPF Tarayıcı Uygulaması projesi sanız, uygulama tanımı varsayılan olarak dahil edilir ve hem işaretleme hem de arka kod kullanılarak tanımlanır.

Bu kod, uygulama tanımını uygulamak için gereken en düşük değerdir. Ancak, uygulamayı MSBuild çalıştırmadan önce uygulama tanımına ek bir yapılandırma ekinin yapılması gerekir.

Uygulama Tanımını MSBuild

Tek başına uygulamalar ve XAML tarayıcı uygulamaları (XBAP'ler) çalıştırılamadan önce belirli bir altyapı düzeyinin uygulanmasını gerektirir. Bu altyapının en önemli bölümü giriş noktasıdır. Bir uygulama bir kullanıcı tarafından başlatılan işletim sistemi, uygulamaları başlatmaya yönelik iyi bilinen bir işlev olan giriş noktasını arar.

Geleneksel olarak, geliştiricilerin teknolojiye bağlı olarak bu kodun bir veya hepsini kendileri yazmaları gerekiyordu. Ancak, aşağıdaki proje dosyasında gösterildiği gibi, uygulama tanımınızı işaretleme dosyası bir MSBuild öğesi olarak yapılandırıldığında WPF ApplicationDefinition bu MSBuild üretir:

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

Arka arkasındaki kod dosyası kod içerdiği için normal bir MSBuild Compile olarak işaretlenir.

Bu yapılandırmaların MSBuild bir uygulama tanımının işaretleme ve arka kod arka MSBuild aşağıdaki gibi kod oluşturması neden olur:

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

Sonuçta elde edilen kod, giriş noktası yöntemini içeren ek altyapı koduyla uygulama tanımınızı Main artırıyor. özniteliği, WPF uygulaması için ana kullanıcı arabirimi iş parçacığının WPF uygulamaları için gerekli olan bir STA iş parçacığı olduğunu belirtmek STAThreadAttributeMain için yöntemine uygulanır. Çağrıldıklarında, olayları kaydetmek ve işaretlemede uygulanan özellikleri ayarlamak için yöntemini MainAppInitializeComponent çağırmadan önce yeni bir örneği oluşturur. sizin için oluşturulmuş olduğundan, ve uygulamaları gibi bir uygulama tanımından açıkça InitializeComponentInitializeComponentPage çağırmaya gerek Window yok. Son Run olarak, uygulamayı başlatmak için yöntemi çağrılır.

Geçerli Uygulamayı Alma

Sınıfının işlevselliği bir uygulama Application arasında paylaştırılır, çünkü sınıfının başına yalnızca bir Application örneği AppDomain olabilir. Bunu zorlamak için, sınıfı tekil bir sınıf olarak uygulanır ApplicationApplication'de Tekil'i Uygulama). Bu, tek bir örneği oluşturur ve özelliğiyle buna paylaşılan erişim staticCurrent sağlar.

Aşağıdaki kod, geçerli için nesnesine başvuru Application edinmeyi AppDomain gösterir.

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

Current sınıfının bir örneğine başvuru Application döndürür. Türetilmiş sınıfınıza bir başvuru almak için, aşağıdaki örnekte gösterildiği gibi ApplicationCurrent özelliğinin değerini türetin.

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

nesnesinin ömrünün Current herhangi bir noktasında değerini Application inceebilirsiniz. Ancak dikkatli olmalısınız. Sınıf Application örneği edildikten sonra, nesnenin durumunun Application tutarsız olduğu bir dönem vardır. Bu süre boyunca, uygulama altyapısı oluşturma, özellikleri ayarlama ve olayları kaydetme dahil olmak üzere kodunuzun çalışması için gereken çeşitli başlatma Application görevlerini gerçekleştirmektedir. Bu süre boyunca nesnesini kullanmayı denersanız, kodunuzun beklenmeyen sonuçları olabilir, özellikle de Application ayarlandı olan çeşitli Application özelliklere bağlı olması.

Başlatma Application çalışması tamamlandığında yaşam süresi gerçekten başlar.

Uygulama Ömrü

Bir WPF uygulamasının ömrü, tarafından başlatıldığında, etkinleştirildiğinde ve devre dışı bırakıldığında ve kapatıldığında size haber verilebilecek çeşitli Application olaylarla işaretlenir.

Giriş Ekranı

.NET Framework 3.5 SP1'den başlayarak, başlangıç penceresinde veya giriş ekranında kullanılacak bir görüntü belirtebilirsiniz. sınıfı, SplashScreen uygulama yüklenirken bir başlangıç penceresini görüntülemeyi kolaylaştırır. Pencere SplashScreen oluşturulur ve çağrılmadan Run önce gösterilir. Daha fazla bilgi için bkz. Uygulama Başlangıç Zamanıve WPF Uygulamasına Giriş Ekranı Ekleme.

Uygulama Başlatma

Runçağrıldıktan ve uygulama başlatıldıktan sonra, uygulama çalıştırmaya hazırdır. Bu an, olay 2011'de Startup ortaya çıkar:

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>

Bir uygulamanın ömrünün bu noktasında, en yaygın yapılan şey bir kullanıcı arabirimi göstermektir.

Kullanıcı arabirimini gösterme

en tek başına Windows uygulamalar Window çalışmaya başladıklarında bir açılır. StartupOlay işleyicisi, aşağıdaki kodda gösterildiği gibi bunu yapabileceğiniz bir konumdur.

<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

Not

WindowTek başına bir uygulamada örneği oluşturulan ilk, varsayılan olarak ana uygulama penceresi olur. Bu Window nesneye özelliği tarafından başvuruluyor Application.MainWindow . MainWindowİlk örneği oluşturulmuş olandan farklı bir pencere ana pencere olmalıdır özelliğinin değeri program aracılığıyla değiştirilebilir Window .

Bir XBAP ilk kez başladığında, büyük olasılıkla bir ' a gidecektir Page . Bu, aşağıdaki kodda gösterilmiştir.

<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

StartupYalnızca bir Window ' ı açmak veya bir öğesine gitmek istiyorsanız Page , StartupUri bunun yerine biçimlendirme içindeki özniteliği ayarlayabilirsiniz.

Aşağıdaki örnek, StartupUri bir tek başına uygulamasından öğesini açmak için nasıl kullanacağınızı gösterir Window .

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

Aşağıdaki örnek, StartupUri BIR XBAP 'den ' a gitmek için nasıl kullanılacağını gösterir Page .

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

Bu biçimlendirme, bir pencere açmak için önceki kodla aynı etkiye sahiptir.

Not

Gezinti hakkında daha fazla bilgi için bkz. gezintiye genel bakış.

StartupWindow Parametresiz bir Oluşturucu kullanarak örneğini oluşturmanız gerekiyorsa veya onu göstermeden önce özelliklerini ayarlamanız veya olaylarına abone olmanız ya da uygulamanın başlatıldığı sırada sağlanan tüm komut satırı bağımsız değişkenlerini işlemeniz gerekiyorsa, bir öğesini açmak için olayı işlemeniz gerekir.

Command-Line bağımsız değişkenlerini işleme

Windows, tek başına uygulamalar bir komut isteminden veya masaüstünden başlatılabilir. Her iki durumda da, komut satırı bağımsız değişkenleri uygulamaya geçirilebilir. Aşağıdaki örnek tek bir komut satırı bağımsız değişkeniyle başlatılan bir uygulamayı gösterir, "/Startküçültülmüş":

wpfapplication.exe /StartMinimized

Uygulama başlatma sırasında WPF, komut satırı bağımsız değişkenlerini işletim sisteminden alır ve StartupArgs parametresini parametresinin özelliği aracılığıyla olay işleyicisine geçirir StartupEventArgs . Aşağıdaki gibi bir kod kullanarak komut satırı bağımsız değişkenlerini alabilir ve kaydedebilirsiniz.

<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

Kod, StartupStartup komut satırı bağımsız değişkeninin sağlandığını denetlemek için işler; bu durumda, ile ana pencereyi açar WindowStateMinimized . WindowStateÖzelliğin programlı olarak ayarlanması gerektiğinden, Main 'in doğrudan kodda açık olması gerektiğini unutmayın Window .

xbap 'ler ClickOnce dağıtımı kullanılarak başlatıldıklarından, komut satırı bağımsız değişkenlerini alamıyor ve işleyemez (bkz. WPF uygulaması dağıtma). Ancak, sorgu dizesi parametrelerini bunları başlatmak için kullanılan URL 'lerden alıp işleyebilir.

Uygulama etkinleştirme ve devre dışı bırakma

Windows, kullanıcıların uygulamalar arasında geçiş yapmasına olanak tanır. En yaygın yol, ALT + TAB tuş birleşimini kullanmaktır. Bir uygulama yalnızca kullanıcının seçim yaptığı bir görünür durumdaysa öğesine geçiş yapılabilir Window . Şu anda seçili olan WindowWindow ( ön plan penceresiolarak da bilinir) ve Kullanıcı girişini alır. Etkin pencere olan uygulama, etkin uygulama (veya ön plan uygulaması). Bir uygulama, aşağıdaki durumlarda etkin uygulama olur:

  • Başlatılır ve bir gösterir Window .

  • Kullanıcı, uygulamada bir seçerek başka bir uygulamadan geçiş yapar Window .

Olayı işleyerek bir uygulamanın etkin hale geldiğini tespit edebilirsiniz Application.Activated .

Benzer şekilde, bir uygulama aşağıdaki koşullarda etkin değil olabilir:

  • Kullanıcı geçerli bir uygulamaya başka bir uygulamaya geçer.

  • Uygulama kapandığında.

Olayı işleyerek bir uygulamanın ne zaman etkin hale geldiğini tespit edebilirsiniz Application.Deactivated .

Aşağıdaki kod, ActivatedDeactivated bir uygulamanın etkin olup olmadığını belirlemede ve olaylarının nasıl işleneceğini gösterir.

<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

WindowAyrıca, etkinleştirilebilir ve devre dışı bırakılabilir. Window.ActivatedWindow.Deactivated Daha fazla bilgi için bkz. ve.

Not

Application.ActivatedXBAP 'ler için ne de Application.Deactivated oluşturulmaz.

Uygulama kapanıyor

Bir uygulamanın yaşam süresi kapatıldığında sona erer, bu durum aşağıdaki nedenlerden kaynaklanabilir:

  • Kullanıcı her bir kapatır Window .

  • Kullanıcı Main 'i kapatır Window .

  • kullanıcı, oturum kapatarak veya kapatmadan Windows oturumu sonlandırır.

  • Uygulamaya özgü bir koşul karşılandı.

Uygulama kapatılmasını yönetmenize yardımcı olmak için ApplicationShutdown yöntemi, ShutdownMode özelliği ve SessionEnding ve Exit olaylarını sağlar.

Not

Shutdown yalnızca, olan uygulamalardan çağrılabilir UIPermission . Tek başına WPF uygulamaları her zaman bu izne sahiptir. Ancak, Internet bölgesi kısmi güven güvenlik korumalı alanı içinde çalışan XBAP 'ler değildir.

Kapalı modu

Çoğu uygulama, tüm pencereler kapandıktan ya da ana pencere kapatıldığında kapanır. Ancak, bazı durumlarda, uygulamaya özgü diğer koşullar bir uygulamanın ne zaman kapandığını tespit edebilir. ShutdownModeAşağıdaki sabit listesi değerlerinden biriyle, uygulamanız tarafından kapatılacak koşulları belirtebilirsiniz ShutdownMode :

Varsayılan değeri, ShutdownModeOnLastWindowClose , uygulamadaki son pencere Kullanıcı tarafından kapatıldığında uygulamanın otomatik olarak kapanması anlamına gelir. Ancak, ana pencere kapalıyken uygulamanız kapatıldıysa, olarak ayarlarsanız WPF otomatik olarak bunu yapar ShutdownModeOnMainWindowClose . Bu, aşağıdaki örnekte gösterilir.

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

Uygulamaya özgü kapatılma koşullarınız olduğunda, ShutdownMode olarak ayarlanır OnExplicitShutdown . Bu durumda, yöntemi açıkça çağırarak bir uygulamayı kapatmak sizin sorumluluğunuzdadır Shutdown ; Aksi takdirde, tüm pencereler kapansa bile uygulamanız çalışmaya devam edecektir. ShutdownYa da olduğunda örtük olarak çağırılır ShutdownModeOnLastWindowCloseOnMainWindowClose .

Not

ShutdownMode bir XBAP 'den ayarlanabilir ancak yok sayılır; bir XBAP, bir tarayıcıdan veya XBAP 'yi barındıran tarayıcı kapatıldığında her zaman kapanır. Daha fazla bilgi için bkz. gezintiye genel bakış.

Oturum sonlandırılıyor

Özelliği tarafından tanımlanan kapatılma koşulları ShutdownMode bir uygulamaya özeldir. Ancak, bazı durumlarda, bir dış koşulun sonucu olarak bir uygulama kapatılabilir. en yaygın dış koşul, bir kullanıcı aşağıdaki eylemler tarafından Windows oturumunu sona erdirdiğinde oluşur:

  • Oturumu kapatma

  • Kapanıyor

  • Başlamasını

  • Beklet

Windows oturumunun ne zaman sona ereceğini algılamak için, SessionEnding aşağıdaki örnekte gösterildiği gibi olayı işleyebilirsiniz.

<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

bu örnekte, kod ReasonSessionEnding Windows oturumunun nasıl sona erdirmekte olduğunu belirlemek için özelliği inceler. Kullanıcıya bir onay iletisi göstermek için bu değeri kullanır. kullanıcı oturumun bitmesini istemiyor, Cancel Windows oturumun bitmesini engellemek için kod kümesi olarak ayarlanır true .

Not

SessionEnding XBAP 'ler için çıkarılmadı.

Çıkış

Bir uygulama kapandığında, kalıcı uygulama durumu gibi bazı son işlemler gerçekleştirmek gerekebilir. Bu durumlar için olay Exit işleyicisi aşağıdaki örnekte olduğu gibi olayını işleyebilirsiniz App_Exit . App. xaml dosyasında bir olay işleyicisi olarak tanımlanır. Uygulaması app. xaml. cs ve Application. xaml. vb dosyalarında vurgulanır.

<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

Tüm örnek için bkz. uygulama oturumlarında Application-Scope özellikleri kalıcı ve geri yükleme.

Exit , hem tek başına uygulamalar hem de XBAP 'ler tarafından işlenebilir. XBAP 'ler için, Exit aşağıdaki durumlarda oluşturulur:

  • Bir XBAP üzerinden gezinilebilir.

  • Internet Explorer 'da, XBAP 'yi barındıran sekme kapalı olduğunda.

  • Tarayıcı kapatıldığında.

Çıkış Kodu

Uygulamalar, genellikle bir kullanıcı isteğine yanıt olarak işletim sistemi tarafından başlatılır. Ancak, bir uygulama belirli bir görevi gerçekleştirmek için başka bir uygulama tarafından başlatılabilir. Başlatılan uygulama kapandığında, başlatılan uygulama, başlatılmış uygulamanın hangi koşullarda kapandığını bilmesini isteyebilir. bu durumlarda Windows, uygulamaların kapatılırken bir uygulama çıkış kodu döndürmesini sağlar. WPF uygulamaları varsayılan olarak 0 çıkış kodu değeri döndürür.

Not

Hata ayıklama Visual Studio çıkış kodu, uygulama kapatılıyorsa Çıkış penceresinde aşağıdakine benzer bir iletiyle görüntülenir:

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

Görünüm menüsünde Çıkış'atıklayarak Çıkış penceresini açarsınız.

Çıkış kodunu değiştirmek için, çıkış kodu olarak tamsayı bağımsız değişken kabul eden Shutdown(Int32) aşırı yüklemeyi çağırabilirsiniz:

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

Çıkış kodunun değerini algılanabilir ve olayı işerek Exit değiştirebilirsiniz. Olay Exit işleyicisi, ExitEventArgs özelliğiyle çıkış koduna erişim sağlayan bir ApplicationExitCode geçirildi. Daha fazla bilgi için bkz. Exit.

Not

Çıkış kodunu hem tek başına uygulamalarda hem de XBAP'lerde ayarlayın. Ancak çıkış kodu değeri XBAP'ler için yoksayılır.

İşlenemeyen Özel Durumlar

Bazen bir uygulama, örneğin, belirlenemeyen bir özel durum ortaya çıkar gibi anormal koşullar altında kapanabiliyor. Bu durumda, uygulama özel durumu algılayan ve işleyen koda sahip değildir. Bu özel durum türü işlanmamış bir özel durumdur; Uygulama kapatılana kadar aşağıdaki şekilde gösterilene benzer bir bildirim görüntülenir.

Screenshot that shows an unhandled exception notification.

Kullanıcı deneyimi perspektifinden bakıldığında, bir uygulamanın aşağıdakilerin bir veya hepsini yaparak bu varsayılan davranışı önlemesi daha iyidir:

  • Kullanıcı dostu bilgileri görüntüleme.

  • Bir uygulamayı çalıştırmaya çalışma.

  • Ayrıntılı, geliştirici dostu özel durum bilgilerini olay Windows kaydetme.

Bu desteğin uygulanması, işlanmamış özel durumları algılayama durumuna bağlıdır ve olay DispatcherUnhandledException bu nedenle ortaya çıkar.

<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

Olay işleyicisi, özel durumun kendisi () dahil olmak üzere DispatcherUnhandledExceptionDispatcherUnhandledExceptionEventArgs işsiz özel durumla ilgili bağlamsal bilgileri içeren bir parametreye DispatcherUnhandledExceptionEventArgs.Exception geçirildi. Bu bilgileri kullanarak özel durumu nasıl işleyebilirsiniz?

'yi işleseniz özelliğini olarak ayarlamış olur, aksi takdirde WPF yine de özel durumun işsiz olduğunu kabul ediyor ve daha önce açıklanan DispatcherUnhandledExceptionDispatcherUnhandledExceptionEventArgs.Handled varsayılan true davranışa geri döner. İşlenemeyen bir özel durum ortaya çıkarsa ve olay işlanmazsa veya olay işulur ve olarak ayarlanırsa, DispatcherUnhandledExceptionHandled uygulama hemen false kapanıyor. Ayrıca, başka hiçbir Application olay yükseltilir. Sonuç olarak, uygulamanın DispatcherUnhandledException kapanmadan önce çalışması gereken kod varsa bunu işlemeniz gerekir.

Bir uygulama, iş alınemeyen bir özel durumun sonucu olarak kapatılasa da, bir sonraki bölümde ele alınarak bir kullanıcı isteğine yanıt olarak uygulama genellikle kapanıyor.

Uygulama Yaşam Süresi Olayları

Tek başına uygulamalar ve XBAP'ler tam olarak aynı yaşam süresine sahip değildir. Aşağıdaki şekilde, tek başına bir uygulamanın yaşam süresinde önemli olaylar ve bunların hangi sırayla yükseltildikleri gösterir.

Standalone Application - Application Object Events

Benzer şekilde, aşağıdaki şekilde bir XBAP'nin yaşam süresinde önemli olaylar ve bunların hangi sırayla yükseltildiklerini gösterir.

XBAP - Application Object Events

Ayrıca bkz.