Uygulama Yönetimine Genel Bakış

  • Makale

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

Uygulama Sınıfı

WPF'de, yaygın uygulama kapsamlı işlevsellik sınıfında kapsüllenmiş Application . Application sı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.

  • İşlenmeyen özel durumları algılama ve yanıtlama.

  • 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 Application ilgilenmiyorsanız, aşağıdaki tabloda bazı ortak görevler Application ve bunların nasıl yerine getirilmediği listelenmiştir. İlgili API'yi ve konuları görüntüleyerek daha fazla bilgi ve örnek kod bulabilirsiniz.

Görev Yaklaşım
Geçerli uygulamayı temsil eden bir nesne alma Application.Current özelliğini 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 ShutdownApplication.Current yöntemini kullanın.
Komut satırından bağımsız değişkenleri alma Olayı işleyip Application.Startup özelliğini kullanın StartupEventArgs.Args . Bir örnek için olaya bakın Application.Startup .
Uygulama çıkış kodunu alma ve ayarlama ExitEventArgs.ApplicationExitCode Olay işleyicisinde Application.Exit özelliğini ayarlayın veya yöntemini çağırın Shutdown ve bir tamsayı geçirin.
İşlenmeyen özel durumları algılama ve yanıtlama Olayı işleyebilir DispatcherUnhandledException .
Uygulama kapsamlı kaynakları alma ve ayarlama Application.Resources özelliğini kullanın.
Uygulama kapsamı kaynak sözlüğü kullanma Bkz. Uygulama Kapsamı Kaynak Sözlüğü Kullanma.
Uygulama kapsamlı özellikleri alma ve ayarlama Application.Properties özelliğini kullanın.
Uygulamanın durumunu alma ve kaydetme Bkz. Uygulama Oturumları Arasında Uygulama Kapsamı Özelliklerini Kalıcı Hale Getir ve Geri Yükle.
Kaynak dosyaları, içerik dosyaları ve kaynak site dosyaları dahil olmak üzere kod dışı veri dosyalarını yönetin. Bkz. WPF Uygulama Kaynağı, İçeriği ve Veri Dosyaları.
Tek başına uygulamalarda pencereleri yönetme Bkz. WPF Windows'a Genel Bakış.
Gezintiyi izleme ve yönetme Bkz. Gezintiye Genel Bakış.

Uygulama Tanımı

sınıfının işlevselliğini Application kullanmak için bir uygulama tanımı uygulamanız gerekir. WPF uygulama tanımı, öğesinden Application türetilen ve özel bir MSBuild ayarıyla yapılandırılan bir sınıftır.

Uygulama Tanımı Uygulama

Tipik bir WPF uygulama tanımı hem işaretleme hem de arka planda kod kullanılarak uygulanır. Bu, olayları işlerken ve arka planda uygulamaya özgü davranışı uygularken uygulama özelliklerini, kaynaklarını ve olaylarını bildirim temelli olarak ayarlamak için işaretlemeyi kullanmanıza olanak tanır.

Aşağıdaki örnekte, hem işaretleme hem de arka planda kod kullanarak uygulama tanımının nasıl uygulandığı gösterilmektedir:

<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ı ve arka planda kod dosyasının birlikte çalışmasına izin vermek için aşağıdakilerin gerçekleşmesi gerekir:

  • İşaretlemede Application öğesinin x:Class özniteliğini içermesi gerekir. Uygulama oluşturulduğunda, işaretleme dosyasındaki varlığı x:Class MSBuild'in özniteliği tarafından belirtilen adlı ve türetilen Application bir partial sınıf oluşturmasına x:Class neden olur. Bunun için, XAML şeması (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml") ile ilgili bir XML ad alanı bildirimi eklenmesi gerekir.

  • Arka planda kodda sınıfı, işaretlemede özniteliği tarafından x:Class belirtilen aynı ada sahip bir partial sınıf olmalıdır ve öğesinden Applicationtüretilmelidir. Bu, arka planda kod dosyasının uygulama oluşturulduğunda işaretleme dosyası için oluşturulan sınıfla partial ilişkilendirilmesine olanak tanır (bkz . WPF Uygulaması Oluşturma).

Not

Visual Studio kullanarak yeni bir WPF Uygulaması projesi veya WPF Browser Uygulaması projesi oluşturduğunuzda, varsayılan olarak bir uygulama tanımı eklenir ve hem işaretleme hem de arka planda kod kullanılarak tanımlanır.

Bu kod, bir uygulama tanımını uygulamak için gereken en düşük koddur. Ancak, uygulamayı derlemeden ve çalıştırmadan önce uygulama tanımına ek bir MSBuild yapılandırması yapılması gerekir.

MSBuild için Uygulama Tanımını Yapılandırma

Tek başına uygulamalar ve XAML tarayıcı uygulamaları (XBAP'ler) çalıştırılabilmesi için belirli bir altyapı düzeyinin uygulanmasını gerektirir. Bu altyapının en önemli kısmı giriş noktasıdır. Bir uygulama bir kullanıcı tarafından başlatıldığında, işletim sistemi uygulamaları başlatmak için iyi bilinen bir işlev olan giriş noktasını çağırır.

Uyarı

XBAP'ler, Internet Explorer ve Firefox gibi eski tarayıcıların çalıştırılmasını gerektirir. Bu eski tarayıcı sürümleri genellikle Windows 10 ve Windows 11'de desteklenmez. Modern tarayıcılar artık güvenlik riskleri nedeniyle XBAP uygulamaları için gereken teknolojiyi desteklemiyor. XBAP'leri etkinleştiren eklentiler artık desteklenmemektedir.

Geleneksel olarak, geliştiricilerin teknolojiye bağlı olarak bu kodun bir kısmını veya tamamını kendileri için yazmaları gerekiyordu. Ancak WPF, aşağıdaki MSBuild proje dosyasında gösterildiği gibi uygulama tanımınızın işaretleme dosyası bir MSBuild ApplicationDefinition öğesi olarak yapılandırıldığında sizin için bu kodu oluşturur:

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

Arka planda kod dosyası kod içerdiğinden, normal olduğu gibi bir MSBuild Compile öğesi olarak işaretlenir.

Bu MSBuild yapılandırmalarının bir uygulama tanımının işaretleme ve arka planda kod dosyalarına uygulanması, MSBuild'in aşağıdaki gibi kod oluşturmasına 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, uygulama tanımınızı giriş noktası yöntemini Mainiçeren ek altyapı koduyla genişletiyor. STAThreadAttribute özniteliği, WPF uygulaması için ana UI iş parçacığının WPF uygulamaları için gerekli olan bir STA iş parçacığı olduğunu belirtmek için yöntemine uygulanırMain. Çağrıldığında, Main olayları kaydetmek ve işaretlemede uygulanan özellikleri ayarlamak için yöntemini çağırmadan InitializeComponent önce yeni bir örneği App oluşturur. InitializeComponent Sizin için oluşturulduğundan ve uygulamaları için PageWindow yaptığınız gibi bir uygulama tanımından açıkça çağrı InitializeComponent yapmanız gerekmez. Son olarak, Run 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 arasında paylaşıldığındanApplication, her biri için AppDomainsınıfının yalnızca bir örneği Application olabilir. Bunu zorunlu kılmak için, Application sınıfı tek bir sınıf olarak uygulanır (bkz . C#'de Singleton'ı Uygulama), tek bir örneğini oluşturur ve özelliğiyle staticCurrent bu sınıfa paylaşılan erişim sağlar.

Aşağıdaki kod, geçerli AppDomainiçin nesnesine Application başvuru alma işlemini 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 Application başvuru döndürür. Türetilmiş sınıfınıza Application bir başvuru istiyorsanız, aşağıdaki örnekte gösterildiği gibi özelliğinin Current değerini atamanız gerekir.

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

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

değerini Current bir nesnenin yaşam süresi içinde herhangi bir Application noktada inceleyebilirsiniz. Ancak dikkatli olmalısınız. Sınıfın Application örneği oluşturulurken, nesnenin durumunun Application tutarsız olduğu bir dönem vardır. Bu süre boyunca, uygulamanızın altyapısını oluşturma, Application özellikleri ayarlama ve olayları kaydetme dahil olmak üzere kodunuzun çalışması için gereken çeşitli başlatma görevlerini gerçekleştirir. Bu süre boyunca nesnesini kullanmayı Application denerseniz, özellikle ayarlanan çeşitli Application özelliklere bağlıysa kodunuz beklenmeyen sonuçlara neden olabilir.

Başlatma çalışmalarını tamamladığında Application , yaşam süresi gerçekten başlar.

Uygulama Ömrü

Bir WPF uygulamasının ömrü, uygulamanızın ne zaman başlatıldığını, etkinleştirildiğini ve devre dışı bırakıldığını ve kapatıldığını size bildirmek için tarafından tetiklenen birkaç olayla Application 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 uygulamanız yüklenirken başlangıç penceresinin görüntülenmesini kolaylaştırır. Pencere SplashScreen oluşturulur ve çağrılmadan önce Run gösterilir. Daha fazla bilgi için bkz . Uygulama Başlangıç Zamanı ve WPF Uygulamasına Giriş Ekranı Ekleme.

Uygulama Başlatma

Çağrıldıktan ve uygulama başlatıldıktan sonra Run , uygulama çalışmaya hazırdır. Olay tetiklendiğinde Startup bu an işaret edilir:

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 kullanım ömrü boyunca bu noktada yapılması gereken en yaygın şey kullanıcı arabirimini göstermektir.

Kullanıcı ArabirimiNi Gösterme

Tek başına Windows uygulamalarının çoğu, çalışmaya başladığında bir'i Window açar. Olay Startup 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

Tek başına bir uygulamada ilk Window örneği oluşturulacak olan, varsayılan olarak ana uygulama penceresi olur. Bu Window nesneye özelliği tarafından başvurulur Application.MainWindow . İlk örneklenden MainWindowWindow farklı bir pencere ana pencere olması gerekiyorsa, özelliğin değeri program aracılığıyla değiştirilebilir.

XBAP ilk başlatıldığında büyük olasılıkla bir Pageöğesine gider. 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

yalnızca bir Window öğesini açmak veya öğesine gitmek için PageişlersenizStartup, bunun yerine özniteliğini işaretlemede ayarlayabilirsinizStartupUri.

Aşağıdaki örnekte, tek başına bir uygulamadan uygulamasının bir uygulamasını açmak için nasıl kullanılacağı StartupUri gösterilmektedir Window.

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

Aşağıdaki örnekte, bir XBAP'ten bir öğesine gitmek için nasıl kullanılacağı StartupUri gösterilmektedir Page.

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

Bu işaretleme, bir pencereyi açmak için önceki kodla aynı etkiye sahiptir.

Not

Gezinti hakkında daha fazla bilgi için bkz . Gezintiye Genel Bakış.

Parametresiz bir Window oluşturucu kullanarak örneği oluşturmanız gerekiyorsa veya göstermeden önce özelliklerini ayarlamanız ya da olaylarına abone olmanız veya uygulama başlatıldığında sağlanan komut satırı bağımsız değişkenlerini işlemeniz gerekiyorsa, olayı açmak için olayı işlemeniz Startup gerekir.

Komut Satırı Bağımsız Değişkenlerini İşleme

Windows'ta 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 örnekte, "/StartMinimized" adlı tek bir komut satırı bağımsız değişkeniyle başlatılan bir uygulama gösterilmektedir:

wpfapplication.exe /StartMinimized

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

<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, /StartMinimized komut satırı bağımsız değişkeninin sağlanıp sağlanmadığını denetlemek için işlerStartup; sağlandıysa, ile ana pencereyi WindowStateMinimizedaçar. Özelliğin WindowState program aracılığıyla ayarlanması gerektiğinden, main Window öğesinin kodda açıkça açılması gerektiğini unutmayın.

ClickOnce dağıtımı kullanılarak başlatıldıklarından XBAP'ler komut satırı bağımsız değişkenlerini alamaz ve işleyemez (bkz . WPF Uygulaması Dağıtma). Ancak, sorgu dizesi parametrelerini başlatmak için kullanılan URL'lerden alabilir ve işleyebilirler.

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+SEKME tuş bileşimini kullanmaktır. Bir uygulamaya yalnızca kullanıcının seçebileceği görünür Window bir uygulama varsa geçiş yapılabilir. Şu anda seçili Window olan pencere etkin penceredir (ön plan penceresi olarak da bilinir) ve kullanıcı girişi alan penceredirWindow. Etkin penceresi olan uygulama, etkin uygulamadır (veya ön plan uygulamasıdır). Bir uygulama aşağıdaki durumlarda etkin uygulama olur:

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

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

Olayı işleyerek Application.Activated bir uygulamanın ne zaman etkin olduğunu algılayabilirsiniz.

Benzer şekilde, bir uygulama aşağıdaki durumlarda devre dışı olabilir:

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

  • Uygulama kapatıldığında.

Olayı işleyerek Application.Deactivated bir uygulamanın etkin olmadığı zamanları algılayabilirsiniz.

Aşağıdaki kod, bir uygulamanın etkin olup olmadığını belirlemek için ve Deactivated olaylarının nasıl işleneceğini Activated 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

A Window da etkinleştirilebilir ve devre dışı bırakılabilir. Window.Deactivated Daha fazla bilgi için ve bölümüne bakınWindow.Activated.

Not

Application.Activated XBAP'ler için ne oluşturulur ne de Application.Deactivated oluşturulur.

Uygulama Kapatma

Bir uygulamanın ömrü kapatıldığında sona erer ve bu durum aşağıdaki nedenlerle oluşabilir:

  • Bir kullanıcı her Windowöğesini kapatır.

  • Kullanıcı ana Windowöğesini kapatır.

  • Kullanıcı oturumu kapatarak veya kapatarak Windows oturumunu sonlandırır.

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

Uygulama kapatmayı Application yönetmenize yardımcı olmak için yöntemini, ShutdownMode özelliğini ve ve Exit olaylarını SessionEnding sağlarShutdown.

Not

Shutdown yalnızca içeren UIPermissionuygulamalardan çağrılabilir. Tek başına WPF uygulamaları her zaman bu izne sahiptir. Ancak, İnternet bölgesinde çalışan XBAP'ler kısmi güven güvenlik korumalı alanında çalışmaz.

Kapatma Modu

Çoğu uygulama, tüm pencereler kapatıldığında veya ana pencere kapatıldığında kapanır. Ancak bazen uygulamaya özgü diğer koşullar bir uygulamanın ne zaman kapanacağını belirleyebilir. Aşağıdaki ShutdownMode numaralandırma değerlerinden biriyle ayarlayarak ShutdownMode uygulamanızın hangi koşullar altında kapatılacağını belirtebilirsiniz:

varsayılan değeri ShutdownMode olan değeri, OnLastWindowCloseuygulamadaki son pencere kullanıcı tarafından kapatıldığında uygulamanın otomatik olarak kapatıldığı anlamına gelir. Ancak, ana pencere kapatıldığında uygulamanızın kapatılması gerekiyorsa, wpf olarak ayarlarsanız ShutdownModeOnMainWindowClosebunu otomatik olarak yapar. 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ü kapatma koşullarınız olduğunda olarak ayarlanır ShutdownModeOnExplicitShutdown. Bu durumda, yöntemi açıkça çağırarak Shutdown bir uygulamayı kapatmak sizin sorumluluğunuzdadır; aksi takdirde, tüm pencereler kapatılmış olsa bile uygulamanız çalışmaya devam eder. veya OnMainWindowCloseolduğunda ShutdownModeOnLastWindowClose örtük olarak çağrıldığını Shutdown unutmayın.

Not

ShutdownMode bir XBAP'den ayarlanabilir, ancak yoksayılır; bir XBAP, bir tarayıcıda veya XBAP'yi barındıran tarayıcı kapatıldığında her zaman kapatılır. Daha fazla bilgi için bkz . Gezintiye Genel Bakış.

Oturum Bitişi

özelliği tarafından ShutdownMode açıklanan kapatma koşulları bir uygulamaya özeldir. Ancak bazı durumlarda, bir uygulama bir dış koşulun sonucu olarak kapanabilir. En yaygın dış koşul, bir kullanıcı Windows oturumunu aşağıdaki eylemlerle sonlandırdığında oluşur:

  • Oturumu kapatma

  • Kapatma

  • Yeni -den başlatma

  • Hazırda Bekletme

Bir Windows oturumunun SessionEnding ne zaman bittiğini algılamak için, 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, Windows oturumunun ReasonSessionEnding nasıl sona erdiğini belirlemek için özelliğini inceler. Kullanıcıya bir onay iletisi görüntülemek için bu değeri kullanır. Kullanıcı oturumun bitmesini istemiyorsa, kod Windows oturumunun sona ermesini engelleyecek şekilde true ayarlarCancel.

Not

SessionEnding XBAP'ler için tetiklenmez.

Çıkış

Bir uygulama kapatıldığında, kalıcı uygulama durumu gibi bazı son işlemleri gerçekleştirmesi gerekebilir. Bu durumlarda, olay işleyicisinin Exit aşağıdaki örnekte yaptığı gibi App_Exit olayı işleyebilirsiniz. App.xaml dosyasında bir olay işleyicisi olarak tanımlanır. Uygulama, 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

Tam örnek için bkz . Uygulama Oturumları Arasında Uygulama Kapsamı Özelliklerini Kalıcı Hale Getir ve Geri Yükle.

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

  • Bir XBAP'den uzaklaşılır.

  • Internet Explorer'da, XBAP'yi barındıran sekme kapatıldığında.

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

Çıkış Kodu

Uygulamalar çoğunlukla bir kullanıcı isteğine yanıt olarak işletim sistemi tarafından başlatılır. Ancak, belirli bir görevi gerçekleştirmek için bir uygulama başka bir uygulama tarafından başlatılabilir. Başlatılan uygulama kapatıldığında, başlatan uygulama başlatılan uygulamanın hangi koşulda kapanacağını bilmek isteyebilir. Bu gibi durumlarda, Windows uygulamaların kapatma işleminde bir uygulama çıkış kodu döndürmesine izin verir. Varsayılan olarak, WPF uygulamaları 0 çıkış kodu değerini döndürür.

Not

Visual Studio'dan hata ayıkladığınızda, uygulama kapatıldığında çıkış penceresinde uygulama çıkış kodu aşağıdakine benzer bir iletide 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ış'a tıklayarak Çıkış penceresini açarsınız.

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

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

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

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

Not

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

İşlenmeyen Özel Durumlar

Bazen bir uygulama beklenmedik bir özel durum oluştuğunda olduğu gibi anormal koşullar altında kapatılabilir. Bu durumda, uygulama özel durumu algılamak ve işlemek için koda sahip olmayabilir. Bu tür bir özel durum işlenmeyen 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 açısından bakıldığında, bir uygulamanın aşağıdakilerden bazılarını veya tümünü yaparak bu varsayılan davranışı önlemesi daha iyidir:

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

  • Bir uygulamayı çalışır durumda tutmaya çalışma.

  • Windows olay günlüğüne ayrıntılı, geliştirici dostu özel durum bilgilerini kaydetme.

Bu desteğin uygulanması, olayın tetiklendiği işlenmeyen özel durumları algılayabilmeye DispatcherUnhandledException bağlıdı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"
  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 DispatcherUnhandledException işleyicisi, özel durumun kendisi (DispatcherUnhandledExceptionEventArgs.Exception) dahil olmak üzere işlenmeyen özel durumla ilgili bağlamsal bilgileri içeren bir DispatcherUnhandledExceptionEventArgs parametre geçirilir. Özel durumun nasıl işleneceğini belirlemek için bu bilgileri kullanabilirsiniz.

öğesini işlerken DispatcherUnhandledExceptionözelliğini trueolarak ayarlamanız DispatcherUnhandledExceptionEventArgs.Handled gerekir; aksi takdirde WPF yine de özel durumu işlenmemiş olarak değerlendirir ve daha önce açıklanan varsayılan davranışa geri döner. İşlenmeyen bir özel durum oluşturulursa ve DispatcherUnhandledException olay işlenmezse veya olay işlenir ve Handled olarak falseayarlanırsa, uygulama hemen kapanır. Ayrıca, başka Application hiçbir olay tetiklenir. Sonuç olarak, uygulamanız kapanmadan önce çalışması gereken bir koda sahipse işlemeniz DispatcherUnhandledException gerekir.

İşlenmeyen bir özel durum nedeniyle bir uygulama kapatılsa da, bir sonraki bölümde açıklandığı gibi bir uygulama genellikle kullanıcı isteğine yanıt olarak kapanır.

Uygulama Ömrü 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 ömründeki önemli olaylar ve bunların oluşturulduğu sıra gösterilmektedir.

Standalone Application - Application Object Events

Benzer şekilde, aşağıdaki şekilde bir XBAP'ın ömründeki önemli olaylar gösterilir ve bunların oluşturulduğu sıra gösterilir.

XBAP - Application Object Events

Ayrıca bkz.