Uygulama Yönetimine Genel Bakış

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, Application sınıfındaki uygulama oluşturma ve yönetme işlevlerine genel bir bakış sağlar.

Uygulama Sınıfı

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

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

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

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

  • Gezinmeyi takip etme ve yönetme.

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

Application sınıfının tüm ayrıntılarıyla ilgilenmiyorsanız, aşağıdaki tabloda Application için bazı yaygın görevler ve bunları nasıl gerçekleştirecekleri 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 Bakınız WPF Uygulamasına Başlangıç Ekranı Ekleme.
Uygulama başlatma Application.Run yöntemini kullanın.
Uygulamayı durdurma Shutdown nesnesinin Application.Current yöntemini kullanın.
Komut satırından bağımsız değişkenleri alma Application.Startup olayını işleyip StartupEventArgs.Args özelliğini kullanın. Bir örnek için Application.Startup olayına bakın.
Uygulama çıkış kodunu alma ve ayarlama ExitEventArgs.ApplicationExitCode olay işleyicisinde Application.Exit özelliğini ayarlayın veya Shutdown yöntemini çağırın ve bir tamsayı geçirin.
İşlenmeyen özel durumları tespit etme ve yanıtlama DispatcherUnhandledException olayını işle.
Uygulama kapsamlı kaynakları alma ve ayarlama Application.Resources özelliğini kullanın.
Uygulama kapsamı kaynak sözlüğü kullanma bkz. Application-Scope Kaynak Sözlüğü kullanma.
Uygulama kapsamındaki özellikleri alma ve ayarlama Application.Properties özelliğini kullanın.
Uygulamanın durumunu alma ve kaydetme Bkz. Uygulama Oturumlarında Application-Scope Ö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. Navigasyona Genel Bakış.

Uygulama Tanımı

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

Uygulama Tanımının Uygulanması

Tipik bir WPF uygulama tanımı hem işaretleme hem de arka planda kod kullanılarak uygulanır. Bu, işaretleme dilini kullanarak uygulama özelliklerini, kaynaklarını ve olayları bildirimsellikle ayarlamanıza olanak tanırken, olayları işlerken ve arka plan kodunda uygulamaya özgü davranışları uygulamanızı sağlar.

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 öğesi x:Class özniteliğini içermelidir. Uygulama oluşturulduğunda, işaretleme dosyasında x:Class varlığı, MSBuild'in partial'den türetilen ve Application özniteliği tarafından belirtilen ada sahip bir x:Class sınıfı oluşturmasına neden olur. Bunun için XAML şeması (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml") için bir XML ad alanı bildirimi eklenmesi gerekir.

  • Kodun arka planında sınıf, işaretlemedeki partial özniteliği tarafından belirtilen aynı ada sahip bir x:Class sınıfı olmalı ve Application'den türetilmelidir. Bu, arka planda kod dosyasının, uygulama oluşturulduğunda işaretleme dosyası için oluşturulan partial sınıfıyla ilişkilendirilmesine olanak tanır (bkz. WPF Uygulaması oluşturma).

Uyarı

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'un eski sürümleri gibi eski tarayıcıların çalıştırılmasını gerektirir. Bu eski tarayıcılar 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. Daha fazla bilgi için bkz. WPF tarayıcı tarafından barındırılan uygulamalar (XBAP)hakkında sık sorulan sorular.

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ı Maingiriş noktası yöntemini iç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 üzere Main yöntemine uygulanır. çağrıldığında, Main olayları kaydetmek ve işaretlemede uygulanan özellikleri ayarlamak için App yöntemini çağırmadan önce yeni bir InitializeComponent örneği oluşturur. InitializeComponent sizin için oluşturulduğundan, InitializeComponent ve Page uygulamaları için yaptığınız gibi bir uygulama tanımından Window açıkça çağırmanız gerekmez. Son olarak, uygulamayı başlatmak için Run yöntemi çağrılır.

Geçerli Uygulamayı Alma

Application sınıfının işlevselliği bir uygulama arasında paylaşıldığından, Applicationbaşına AppDomain sınıfının yalnızca bir örneği olabilir. Bunu zorlamak için, Application sınıfı singleton sınıf olarak tasarlanır (bkz. C#'de Singleton Uygulama), tek bir örneğini oluşturup staticCurrent özelliğiyle bu örneğe paylaşılan erişim sağlar.

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

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

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

Current, Application sınıfının bir örneğine referans döndürür. türetilmiş Application sınıfınıza başvuru istiyorsanız, aşağıdaki örnekte gösterildiği gibi Current özelliğinin 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)

bir Current nesnesinin ömrü boyunca herhangi bir noktada Application değerini inceleyebilirsiniz. Ancak dikkatli olmalısınız. Application sınıfı örneklendirildikten sonra, Application nesnesinin durumunun tutarsız olduğu bir dönem vardır. Bu süre boyunca, Application uygulama altyapısı oluşturma, özellikleri ayarlama ve olayları kaydetme dahil olmak üzere kodunuzun çalışması için gereken çeşitli başlatma görevlerini gerçekleştirmektedir. Bu süre boyunca Application nesnesini kullanmaya çalışırsanız, özellikle ayarlanan çeşitli Application özelliklerine bağlıysa kodunuz beklenmeyen sonuçlar verebilir.

Application başlatma işlemlerini tamamladığında, yaşam süresi gerçek anlamda 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 Application tarafından tetiklenen birkaç olayla işaretlenir.

Giriş Ekranı

.NET Framework 3.5 SP1'den başlayarak, başlangıç penceresinde kullanılacak bir görüntü veya giriş ekranıbelirtebilirsiniz. SplashScreen sınıfı, uygulamanız yüklenirken başlangıç penceresi görüntülemeyi kolaylaştırır. SplashScreen penceresi oluşturulur ve Run çağrılmadan ö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ışmaya hazırdır. Startup olayı tetiklendiğinde 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

Çoğu bağımsız Windows uygulaması çalışmaya başladığında bir Window açar. Startup olay 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

Uyarı

Tek başına bir uygulamada ilk örneklenen Window varsayılan olarak ana uygulama penceresi olur. Bu Window nesnesine Application.MainWindow özelliği ile başvurulur. MainWindow özelliğinin değeri, ilk oluşturulan Window yerine farklı bir pencere ana pencere olacaksa programlı olarak değiştirilebilir.

Bir XBAP ilk başlatıldığında, büyük olasılıkla bir Page'a 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 Startup açmak veya bir Window'ye gitmek için Page'ı ele alıyorsanız, bunun yerine işaretlemede StartupUri özniteliğini ayarlayabilirsiniz.

Aşağıdaki örnek, bağımsız bir uygulamadan StartupUri kullanılarak nasıl Windowaçılacağını göstermektedir.

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

Aşağıdaki örnekte, bir XBAP'den StartupUri kullanarak Page'e nasıl gidileceği gösterilmektedir.

<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.

Uyarı

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

Startup olayını, Window’i açmanız gerekiyorsa, parametresiz olmayan bir oluşturucu kullanarak örneğini oluşturmanız, veya özelliklerini ayarlamanız ya da göstermeden önce olaylarına abone olmanız ya da uygulama başlatıldığında sağlanan komut satırı argümanlarını işlemeniz gerekiyorsa ele almanız gerekir.

Command-Line Argümanlarını İş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 aktarılabilir. 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 Startup parametresinin Args özelliği aracılığıyla StartupEventArgs olay işleyicisine geçirir. Aşağıdaki gibi bir kod kullanarak komut satırı argümanlarını 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, Startup komut satırı bağımsız değişkeninin sağlanıp sağlanmadığını kontrol etmek için 'i işler; eğer sağlandıysa, WindowStateMinimized ile ana pencereyi açar. WindowState özelliğinin program aracılığıyla ayarlanması gerektiğinden, ana Window’in kodda açıkça açılması gerektiğini unutmayın.

XBAP'ler, ClickOnce dağıtımı kullanılarak başlatıldığı için komut satırı bağımsız değişkenlerini almak ve işlemek mümkün değildir (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 bir Window varsa geçiş yapılabilir. Seçili olan Window, etkin pencere (ön plan penceresiolarak da bilinir) ve kullanıcı girdisini alan Window'tir. Etkin penceresi olan uygulama, etkin uygulama (veya ön plan uygulaması). Bir uygulama aşağıdaki durumlarda etkin uygulama olur:

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

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

Application.Activated olayını işleyerek 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.

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

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

Bir Window da etkinleştirilebilir ve devre dışı bırakılabilir. Daha fazla bilgi için bkz. Window.Activated ve Window.Deactivated.

Uyarı

XBAP'ler için ne Application.Activated ne de Application.Deactivated tetiklenmez.

Uygulama Kapatma

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

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

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

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

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

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

Uyarı

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

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 ShutdownMode ayarlayarak uygulamanızın kapatılacağı koşulları belirtebilirsiniz:

ShutdownMode varsayılan değeri OnLastWindowClosedeğeridir. Bu, uygulamadaki 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, ShutdownModeOnMainWindowCloseolarak ayarlarsanız WPF bunu otomatik olarak yapar. Bu, aşağıdaki örnekte gösterilmiştir.

<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, ShutdownModeOnExplicitShutdownolarak ayarlarsınız. Bu durumda, Shutdown yöntemini açıkça çağırarak bir uygulamayı kapatmak sizin sorumluluğunuzdadır; aksi takdirde, tüm pencereler kapatıldığında bile uygulamanız çalışmaya devam eder. Shutdown ShutdownMode veya OnLastWindowCloseolduğunda OnMainWindowClose örtük olarak çağrıldığını unutmayın.

Uyarı

ShutdownMode bir XBAP'tan ayarlanabilir, ancak dikkate alınmaz; bir tarayıcıda sayfa değiştirildiğinde veya XBAP'yi barındıran tarayıcı kapatıldığında XBAP her zaman kapatılır. Daha fazla bilgi için bkz. Gezintiye Genel Bakış.

Oturum Bitişi

ShutdownMode özelliği tarafından 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

  • Yeniden başlatma

  • Uykuya Alma

Bir Windows oturumunun ne zaman bittiğini algılamak için, aşağıdaki örnekte gösterildiği gibi SessionEnding olayını 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 nasıl sona erdiğini belirlemek için ReasonSessionEnding ö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 önlemek için Canceltrue olarak ayarlar.

Uyarı

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, Exit olay işleyicisinin aşağıdaki örnekte yaptığı gibi App_Exit olayını işleyebilirsiniz. App.xaml dosyasında 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ında Application-Scope Ö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 durumlar söz konusu olduğunda Exit yükseltilir.

  • Bir XBAP'den çıkış yapı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.

Uyarı

Visual Studio'dan hata ayıkladığınızda, uygulama kapatıldığında uygulama çıkış kodu Çıktı penceresinde 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ündeki Çıktı seçeneğine tıklayarak Çıktı penceresini açarsınız.

Çıkış kodunu değiştirmek için, çıkış kodu olarak bir tamsayı bağımsız değişkeni kabul eden Shutdown(Int32) aşırı yüklemesini ç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ılayabilir ve Exit olayını işleyerek değiştirebilirsiniz. Exit olay işleyicisine, ExitEventArgs özelliğiyle çıkış koduna erişim sağlayan bir ApplicationExitCode geçer. Daha fazla bilgi için bkz. Exit.

Uyarı

Çıkış kodunu hem tek başına uygulamalarda hem de XBAP'lerde ayarlayabilirsiniz. Ancak, çıkış kodu değeri XBAP'ler için göz ardı edilir.

İş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.

İşlenmeyen özel durum bildirimini gösteren ekran görüntüsü.

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ı, DispatcherUnhandledException olayının neden olduğu işlenmeyen özel durumları algılayabilmeye 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

DispatcherUnhandledException olay işleyicisine, özel durumun kendisi (DispatcherUnhandledExceptionEventArgs) dahil işlenmeyen özel durumla ilgili bağlamsal bilgiler içeren bir DispatcherUnhandledExceptionEventArgs.Exception parametresi geçirilir. Özel durumun nasıl işleneceğini belirlemek için bu bilgileri kullanabilirsiniz.

DispatcherUnhandledExceptionişlerken DispatcherUnhandledExceptionEventArgs.Handled özelliğini trueolarak ayarlamanız gerekir; aksi takdirde WPF yine de özel durumun işlenmemiş olduğunu düşünür 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 Handledfalseolarak ayarlanırsa, uygulama hemen kapanır. Ayrıca, başka hiçbir Application olayı tetiklenmez. Sonuç olarak, uygulamanızın kapanmadan önce çalışması gereken kodu varsa DispatcherUnhandledException işlemeniz 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, bağımsız bir uygulamanın yaşam döngüsündeki ana olaylar ve bunların gerçekleştiği sıra gösterilmektedir.

Tek Başına Uygulama - Uygulama Nesnesi Olayları

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 - Uygulama Nesne Olayları

Ayrıca bakınız

  • Last updated on