アプリケーション管理の概要Application Management Overview

すべてのアプリケーションは、アプリケーションの実装と管理に適用される機能を共有することがよくあります。All applications tend to share a common set of functionality that applies to application implementation and management. このトピックでは、アプリケーションの作成と管理のための Application クラスの機能の概要について説明します。This topic provides an overview of the functionality in the Application class for creating and managing applications.

Application クラスThe Application Class

WPF では、共通のアプリケーション スコープの機能は、Application クラスにカプセル化されます。In WPF, common application-scoped functionality is encapsulated in the Application class. Application クラスには、次の機能が含まれています。The Application class includes the following functionality:

  • アプリケーションの有効期間を追跡し、相互作用する。Tracking and interacting with application lifetime.

  • コマンド ライン パラメーターを取得し、処理する。Retrieving and processing command-line parameters.

  • 未処理の例外を検出し、応答する。Detecting and responding to unhandled exceptions.

  • アプリケーション スコープのプロパティと リソースを共有する。Sharing application-scope properties and resources.

  • スタンドアロン アプリケーションのウィンドウを管理する。Managing windows in standalone applications.

  • ナビゲーションを追跡し、管理する。Tracking and managing navigation.

アプリケーションのクラスを使用して一般的なタスクを実行する方法How to Perform Common Tasks Using the Application Class

Application クラスのすべての詳細に興味がない場合は、Application の一般的なタスクとそれらを実行する方法を示す次の表を参照してください。If you are not interested in all of the details of the Application class, the following table lists some of the common tasks for Application and how to accomplish them. 関連する API とトピックを表示することによって、詳細情報とサンプル コードを参照できます。By viewing the related API and topics, you can find more information and sample code.

タスクTask 方法Approach
現在のアプリケーションを表すオブジェクトを取得するGet an object that represents the current application Application.Current プロパティを使用します。Use the Application.Current property.
起動画面をアプリケーションに追加するAdd a startup screen to an application スプラッシュ スクリーンを WPF アプリケーションに追加する」を参照してください。See Add a Splash Screen to a WPF Application.
アプリケーションを起動するStart an application Application.Run メソッドを使用します。Use the Application.Run method.
アプリケーションを停止するStop an application Shutdown オブジェクトの Application.Current メソッドを使用します。Use the Shutdown method of the Application.Current object.
コマンド ラインから引数を取得するGet arguments from the command line Application.Startup イベントを処理し、StartupEventArgs.Args プロパティを使用します。Handle the Application.Startup event and use the StartupEventArgs.Args property. 例については、Application.Startup を参照してください。For an example, see the Application.Startup event.
アプリケーションの終了コードを取得し、設定するGet and set the application exit code Application.Exit イベント ハンドラーの ExitEventArgs.ApplicationExitCode プロパティを設定するか、Shutdown メソッドを呼び出して、整数を渡します。Set the ExitEventArgs.ApplicationExitCode property in the Application.Exit event handler or call the Shutdown method and pass in an integer.
未処理の例外を検出し、応答するDetect and respond to unhandled exceptions DispatcherUnhandledException イベントを処理します。Handle the DispatcherUnhandledException event.
アプリケーション スコープのリソースを取得し、設定するGet and set application-scoped resources Application.Resources プロパティを使用します。Use the Application.Resources property.
アプリケーション スコープのリソース ディクショナリを使用するUse an application-scope resource dictionary アプリケーション スコープのリソース ディクショナリを使用する」を参照してください。See Use an Application-Scope Resource Dictionary.
アプリケーション スコープのプロパティを取得し、設定するGet and set application-scoped properties Application.Properties プロパティを使用します。Use the Application.Properties property.
アプリケーションの状態を取得し、保存するGet and save an application's state アプリケーション セッション全体でアプリケーション スコープのプロパティを永続化および復元する」を参照してください。See Persist and Restore Application-Scope Properties Across Application Sessions.
リソース ファイル、コンテンツ ファイル、起点ファイルなど、コード以外のデータ ファイルを管理する。Manage non-code data files, including resource files, content files, and site-of-origin files. WPF アプリケーションのリソース、コンテンツ ファイル、およびデータ ファイル」を参照してください。See WPF Application Resource, Content, and Data Files.
スタンドアロン アプリケーションのウィンドウを管理するManage windows in standalone applications WPF ウィンドウの概要」を参照してください。See WPF Windows Overview.
ナビゲーションを追跡し、管理するTrack and manage navigation ナビゲーションの概要」を参照してください。See Navigation Overview.

アプリケーション定義The Application Definition

Application クラスの機能を利用するには、アプリケーション定義を実装する必要があります。To utilize the functionality of the Application class, you must implement an application definition. WPF アプリケーションの定義は、Application から派生したクラスであり、特別な MSBuild の設定で構成されます。A WPF application definition is a class that derives from Application and is configured with a special MSBuild setting.

アプリケーション定義の実装Implementing an Application Definition

一般的な WPF アプリケーション定義は、マークアップと分離コードの両方を使用して実装されます。A typical WPF application definition is implemented using both markup and code-behind. これにより、マークアップを使用して、アプリケーションのプロパティやリソースを宣言によって設定したり、イベントを登録したりでき、分離コードでイベントを処理し、アプリケーション固有の動作を実装することができます。This allows you to use markup to declaratively set application properties, resources, and register events, while handling events and implementing application-specific behavior in code-behind.

次の例では、マークアップと分離コードの両方を使用してアプリケーション定義を実装する方法を示します。The following example shows how to implement an application definition using both markup and code-behind:

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

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

Imports System.Windows

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

マークアップ ファイルと分離コード ファイルを連携させるには、次のようにする必要があります。To allow a markup file and code-behind file to work together, the following needs to happen:

  • マークアップでは、Application 要素に x:Class 属性を含める必要があります。In markup, the Application element must include the x:Class attribute. アプリケーションのビルド時にマークアップ ファイルに x:Class が含まれていると、MSBuild により、x:Class 属性で指定された名前を持つ、Application から派生した partial クラスが作成されます。When the application is built, the existence of x:Class in the markup file causes MSBuild to create a partial class that derives from Application and has the name that is specified by the x:Class attribute. そのためには、XAML スキーマ (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml") に XML 名前空間宣言を追加する必要があります。This requires the addition of an XML namespace declaration for the XAML schema (xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml").

  • 分離コードでは、クラスは、マークアップ内の x:Class 属性で指定されている名前を持つ partial クラスでなければなりません。また、Application から派生する必要があります。In code-behind, the class must be a partial class with the same name that is specified by the x:Class attribute in markup and must derive from Application. これによって、分離コード ファイルと、アプリケーションのビルド時にマークアップ ファイル用に生成される partial クラスとが関連付けられます (「WPF アプリケーションのビルド」を参照)。This allows the code-behind file to be associated with the partial class that is generated for the markup file when the application is built (see Building a WPF Application).

注意

Visual Studio を使用して新しい WPF アプリケーション プロジェクトまたは WPF ブラウザー アプリケーション プロジェクトを作成すると、アプリケーション定義が既定で含まれ、マークアップと分離コードの両方を使用して定義されます。When you create a new WPF Application project or WPF Browser Application project using Visual Studio, an application definition is included by default and is defined using both markup and code-behind.

このコードは、アプリケーション定義を実装するために最低限必要です。This code is the minimum that is required to implement an application definition. ただし、アプリケーションをビルドして実行する前に、アプリケーション定義に対して MSBuild の追加構成を行う必要があります。However, an additional MSBuild configuration needs to be made to the application definition before building and running the application.

MSBuild 用のアプリケーション定義の構成Configuring the Application Definition for MSBuild

スタンドアロン アプリケーションや XAML ブラウザー アプリケーション (XBAP) を実行できるようにするには、一定レベルのインフラストラクチャの実装が必要です。Standalone applications and XAML browser applications (XBAPs) require the implementation of a certain level of infrastructure before they can run. このインフラストラクチャの最も重要な部分は、エントリ ポイントです。The most important part of this infrastructure is the entry point. ユーザーがアプリケーションを起動するとき、オペレーティング システムはエントリ ポイントを呼び出します。これは、アプリケーションを起動するための、よく知られている機能です。When an application is launched by a user, the operating system calls the entry point, which is a well-known function for starting applications.

従来、開発者は、テクノロジに応じて、このコードの一部または全部を自分で記述する必要がありました。Traditionally, developers have needed to write some or all of this code for themselves, depending on the technology. しかし、WPF では、次の MSBuild プロジェクト ファイルに示されているように、アプリケーション定義のマークアップ ファイルが MSBuild の ApplicationDefinition 項目として構成されると、このコードが自動生成されます。However, WPF generates this code for you when the markup file of your application definition is configured as an MSBuild ApplicationDefinition item, as shown in the following MSBuild project file:

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

分離コード ファイルはコードを含んでいるため、通常どおり、MSBuild の Compile 項目としてマークされます。Because the code-behind file contains code, it is marked as an MSBuild Compile item, as is normal.

これらの MSBuild 構成をアプリケーション定義のマークアップ ファイルと分離コード ファイルに適用すると、MSBuild によって次のようなコードが生成されます。The application of these MSBuild configurations to the markup and code-behind files of an application definition causes MSBuild to generate code like the following:

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

生成されるコードにより、アプリケーション定義に追加のインフラストラクチャのコードが追加され、そこに Main というエントリ ポイント メソッドが含まれます。The resulting code augments your application definition with additional infrastructure code, which includes the entry-point method Main. STAThreadAttribute 属性が Main メソッドに適用されて、WPF アプリケーションのメイン UI スレッドが、WPF アプリケーションに必須の STA スレッドであることが示されます。The STAThreadAttribute attribute is applied to the Main method to indicate that the main UI thread for the WPF application is an STA thread, which is required for WPF applications. 呼び出されると、Main では、App の新しいインスタンスが作成されてから、InitializeComponent メソッドが呼び出されて、イベントが登録され、マークアップで実装されるプロパティが設定されます。When called, Main creates a new instance of App before calling the InitializeComponent method to register the events and set the properties that are implemented in markup. InitializeComponent は自動的に生成されるので、PageWindow の実装のように、アプリケーション定義から InitializeComponent を明示的に呼び出す必要はありません。Because InitializeComponent is generated for you, you don't need to explicitly call InitializeComponent from an application definition like you do for Page and Window implementations. 最後に、Run メソッドが呼び出されて、アプリケーションが起動されます。Finally, the Run method is called to start the application.

現在のアプリケーションの取得Getting the Current Application

Application クラスの機能はアプリケーション間で共有されるため、Application クラスのインスタンスは、AppDomain ごとに 1 つだけです。Because the functionality of the Application class are shared across an application, there can be only one instance of the Application class per AppDomain. これを強制するため、Application クラスはシングルトン クラスとして実装されます (「C# でのシングルトンの実装」を参照)。つまり、インスタンスが 1 つだけ作成され、static Current プロパティを使用して、インスタンスへの共有アクセスが提供されます。To enforce this, the Application class is implemented as a singleton class (see Implementing Singleton in C#), which creates a single instance of itself and provides shared access to it with the staticCurrent property.

次のコードでは、現在の AppDomainApplication オブジェクトへの参照を取得する方法を示します。The following code shows how to acquire a reference to the Application object for the current AppDomain.

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

Current では、Application クラスのインスタンスへの参照が返されます。Current returns a reference to an instance of the Application class. Application 派生クラスへの参照が必要な場合は、次の例で示すように、Current プロパティの値をキャストする必要があります。If you want a reference to your Application derived class you must cast the value of the Current property, as shown in the following example.

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

Current の値は、Application オブジェクトの有効期間中はいつでも調べることができます。You can inspect the value of Current at any point in the lifetime of an Application object. ただし、注意が必要です。However, you should be careful. Application クラスがインスタンス化された後、Application オブジェクトの状態の一貫性が失われる期間があります。After the Application class is instantiated, there is a period during which the state of the Application object is inconsistent. この期間中、Application では、アプリケーション インフラストラクチャの確立、プロパティの設定、イベントの登録など、コードの実行に必要なさまざまな初期化タスクが実行されます。During this period, Application is performing the various initialization tasks that are required by your code to run, including establishing application infrastructure, setting properties, and registering events. この期間中に Application オブジェクトを使用しようとすると、コードが予期しない結果になることがあります (特に設定中のさまざまな Application プロパティに依存している場合)。If you try to use the Application object during this period, your code may have unexpected results, particularly if it depends on the various Application properties being set.

Application での初期化作業を完了すると、実質的な有効期間が始まります。When Application completes its initialization work, its lifetime truly begins.

アプリケーションの有効期間Application Lifetime

WPF アプリケーションの有効期間は、アプリケーションが起動されたこと、アクティブになったこと、非アクティブになったこと、シャットダウンされたことなどを通知するために、Application によって発生させられるいくつかのイベントによってマークされます。The lifetime of a WPF application is marked by several events that are raised by Application to let you know when your application has started, has been activated and deactivated, and has been shut down.

スプラッシュ スクリーンSplash Screen

.NET Framework 3.5 SP1 以降では、スタートアップ ウィンドウ ("スプラッシュ スクリーン") で使用する画像を指定できます。Starting in the .NET Framework 3.5 SP1, you can specify an image to be used in a startup window, or splash screen. SplashScreen クラスを使用すると、アプリケーションを読み込んでいるときに、スタートアップ ウィンドウを簡単に表示できます。The SplashScreen class makes it easy to display a startup window while your application is loading. SplashScreen ウィンドウは、Run が呼び出される前に作成されて表示されます。The SplashScreen window is created and shown before Run is called. 詳細については、「アプリケーションの起動時間」および「スプラッシュ スクリーンを WPF アプリケーションに追加する」を参照してください。For more information, see Application Startup Time and Add a Splash Screen to a WPF Application.

アプリケーションの起動Starting an Application

Run が呼び出され、アプリケーションが初期化されると、アプリケーションの実行準備が整います。After Run is called and the application is initialized, the application is ready to run. このタイミングは、Startup イベントが発生したときに通知されます。This moment is signified when the Startup event is raised:

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>

アプリケーションの有効期間中のこの時点で最も一般的に行われるのは、UI の表示です。At this point in an application's lifetime, the most common thing to do is to show a UI.

ユーザー インターフェイスの表示Showing a User Interface

ほとんどのスタンドアロン Windows アプリケーションでは、実行を開始するとき、Window が開かれます。Most standalone Windows applications open a Window when they begin running. 次のコードに示されているように、Startup イベント ハンドラーは、これを行うことができる場所の 1 つです。The Startup event handler is one location from which you can do this, as demonstrated by the following code.

<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

注意

スタンドアロン アプリケーションではインスタンス化された最初の Window が、既定でメイン アプリケーション ウィンドウになります。The first Window to be instantiated in a standalone application becomes the main application window by default. この Window オブジェクトは、Application.MainWindow プロパティによって参照されます。This Window object is referenced by the Application.MainWindow property. 最初にインスタンス化された Window 以外のウィンドウをメイン ウィンドウにする必要がある場合は、MainWindow プロパティの値をプログラムで変更できます。The value of the MainWindow property can be changed programmatically if a different window than the first instantiated Window should be the main window.

通常、XBAP は起動すると最初に、Page にナビゲートします。When an XBAP first starts, it will most likely navigate to a Page. これを次のコードに示します。This is shown in the following code.

<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

Startup の処理目的が Window を開くことか、Page にナビゲートすることのみの場合は、代わりに、マークアップで StartupUri 属性を設定できます。If you handle Startup to only open a Window or navigate to a Page, you can set the StartupUri attribute in markup instead.

次の例では、スタンドアロン アプリケーションから StartupUri を使用して Window を開く方法を示します。The following example shows how to use the StartupUri from a standalone application to open a Window.

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

次の例では、XBAP から StartupUri を使用して Page にナビゲートする方法を示します。The following example shows how to use StartupUri from an XBAP to navigate to a Page.

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

このマークアップは、ウィンドウを開くことについて、前のコードと同じ効果があります。This markup has the same effect as the previous code for opening a window.

注意

ナビゲーションの詳細については、「ナビゲーションの概要」を参照してください。For more information on navigation, see Navigation Overview.

パラメーターなしではないコンストラクターを使用してウィンドウをインスタンス化する必要がある場合、またはウィンドウを表示する前にウィンドウのプロパティを設定するか、イベントをサブスクライブする必要がある場合、またはアプリケーションの起動時に指定されたコマンド ライン引数を処理する必要がある場合、Window を開くには、Startup イベントを処理する必要があります。You need to handle the Startup event to open a Window if you need to instantiate it using a non-parameterless constructor, or you need to set its properties or subscribe to its events before showing it, or you need to process any command-line arguments that were supplied when the application was launched.

コマンド ライン引数の処理Processing Command-Line Arguments

Windows では、スタンドアロン アプリケーションは、コマンド プロンプトまたはデスクトップから起動できます。In Windows, standalone applications can be launched from either a command prompt or the desktop. どちらの場合も、コマンド ライン引数をアプリケーションに渡すことができます。In both cases, command-line arguments can be passed to the application. 次の例は、1 つのコマンド ライン引数 "/StartMinimized" を指定して起動されるアプリケーションを示しています。The following example shows an application that is launched with a single command-line argument, "/StartMinimized":

wpfapplication.exe /StartMinimized

アプリケーションの初期化中に、WPF によってオペレーティング システムからコマンド ライン引数が取得され、StartupEventArgs パラメーターの Args プロパティを介して Startup イベント ハンドラーに渡されます。During application initialization, WPF retrieves the command-line arguments from the operating system and passes them to the Startup event handler via the Args property of the StartupEventArgs parameter. 次のようなコードを使用して、コマンド ライン引数を取得し、格納することができます。You can retrieve and store the command-line arguments using code like the following.

<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

このコードでは、Startup が処理されて、 /StartMinimized コマンド ライン引数が指定されたかどうかが確認されます。指定されている場合は、WindowStateMinimized にしてメイン ウィンドウが開かれます。The code handles Startup to check whether the /StartMinimized command-line argument was provided; if so, it opens the main window with a WindowState of Minimized. WindowState プロパティはプログラムで設定する必要があるため、メイン Window をコードで明示的に開く必要があることに注意してください。Note that because the WindowState property must be set programmatically, the main Window must be opened explicitly in code.

XBAP は、ClickOnce 配置を使用して起動されるため、コマンド ライン引数を処理できません (「WPF アプリケーションの配置」を参照)。XBAPs cannot retrieve and process command-line arguments because they are launched using ClickOnce deployment (see Deploying a WPF Application). ただし、起動に使用される URL のクエリ文字列パラメーターを取得して処理することはできます。However, they can retrieve and process query string parameters from the URLs that are used to launch them.

アプリケーションのアクティブ化と非アクティブ化Application Activation and Deactivation

Windows では、ユーザーがアプリケーションを切り替えることができます。Windows allows users to switch between applications. 最も一般的な方法は、Alt キーを押しながら Tab キーを押す方法です。The most common way is to use the ALT+TAB key combination. アプリケーションを切り替えることができるのは、ユーザーが選択できる可視の Window がある場合だけです。An application can only be switched to if it has a visible Window that a user can select. 現在選択されている Window は、"アクティブ ウィンドウ" であり ("フォアグラウンド ウィンドウ" とも呼ばれます)、ユーザー入力を受け取る Window です。The currently selected Window is the active window (also known as the foreground window) and is the Window that receives user input. アクティブ ウィンドウを持つアプリケーションは、"アクティブ アプリケーション" (または "フォア グラウンド アプリケーション") です。The application with the active window is the active application (or foreground application). アプリケーションは、次の状況でアクティブ アプリケーションになります。An application becomes the active application in the following circumstances:

  • 起動され、Window を表示している。It is launched and shows a Window.

  • ユーザーがアプリケーションの Window を選択することによって、別のアプリケーションから切り替えた。A user switches from another application by selecting a Window in the application.

アプリケーションがアクティブになったことは、Application.Activated イベントを処理することによって検出できます。You can detect when an application becomes active by handling the Application.Activated event.

同様に、アプリケーションは、次の状況で非アクティブになります。Likewise, an application can become inactive in the following circumstances:

  • ユーザーが現在のアプリケーションから別のアプリケーションに切り替えた。A user switches to another application from the current one.

  • アプリケーションがシャットダウンされた。When the application shuts down.

アプリケーションが非アクティブになったことは、Application.Deactivated イベントを処理することによって検出できます。You can detect when an application becomes inactive by handling the Application.Deactivated event.

次のコードでは、Activated および Deactivated イベントを処理して、アプリケーションがアクティブかどうかを確認する方法を示します。The following code shows how to handle the Activated and Deactivated events to determine whether an application is active.

<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

Window もアクティブまたは非アクティブにできます。A Window can also be activated and deactivated. 詳細については、「Window.Activated」および「Window.Deactivated」を参照してください。See Window.Activated and Window.Deactivated for more information.

注意

Application.ActivatedApplication.Deactivated も、XBAP については発生しません。Neither Application.Activated nor Application.Deactivated is raised for XBAPs.

アプリケーションのシャットダウンApplication Shutdown

アプリケーションの有効期間は、シャット ダウンされると終了します。シャットダウンは、次の理由で発生します。The life of an application ends when it is shut down, which can occur for the following reasons:

  • ユーザーがすべての Window を閉じた。A user closes every Window.

  • ユーザーがメイン Window を閉じた。A user closes the main Window.

  • ユーザーがログオフまたはシャットダウンして、Windows セッションを終了した。A user ends the Windows session by logging off or shutting down.

  • アプリケーション固有の条件が満たされた。An application-specific condition has been met.

アプリケーションのシャット ダウンの管理を支援するために、Application には、Shutdown メソッド、ShutdownMode プロパティ、SessionEnding イベント、Exit イベントが用意されています。To help you manage application shutdown, Application provides the Shutdown method, the ShutdownMode property, and the SessionEnding and Exit events.

注意

Shutdown は、UIPermission を持つアプリケーションからのみ呼び出すことができます。Shutdown can only be called from applications that have UIPermission. スタンドアロン WPF アプリケーションには、常にこのアクセス許可があります。Standalone WPF applications always have this permission. 一方、インターネット ゾーン部分信頼セキュリティ サンド ボックスで実行される XBAP には、このアクセス許可がありません。However, XBAPs running in the Internet zone partial-trust security sandbox do not.

シャットダウン モードShutdown Mode

ほとんどのアプリケーションは、すべてのウィンドウが閉じられるか、メイン ウィンドウが閉じられたときにシャットダウンします。Most applications shut down either when all the windows are closed or when the main window is closed. ただし、場合によっては、他のアプリケーションに固有の条件によって、アプリケーションがシャット ダウンするタイミングに影響します。Sometimes, however, other application-specific conditions may determine when an application shuts down. ShutdownMode に次のいずれかの ShutdownMode 列挙値を設定することによって、アプリケーションがシャットダウンする条件を指定できます。You can specify the conditions under which your application will shut down by setting ShutdownMode with one of the following ShutdownMode enumeration values:

ShutdownMode の既定値は OnLastWindowClose であり、アプリケーションの最後のウィンドウがユーザーによって閉じられたときにアプリケーションが自動的にシャットダウンすることを意味します。The default value of ShutdownMode is OnLastWindowClose, which means that an application automatically shuts down when the last window in the application is closed by the user. 一方、メイン ウィンドウが閉じられたときにアプリケーションがシャットダウンするようにする必要がある場合は、ShutdownModeOnMainWindowClose に設定すると、WPF は自動的にシャットダウンします。However, if your application should be shut down when the main window is closed, WPF automatically does that if you set ShutdownMode to OnMainWindowClose. これを次の例に示します。This is shown in the following example.

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

アプリケーション固有のシャットダウン条件があるときは、ShutdownModeOnExplicitShutdown に設定します。When you have application-specific shutdown conditions, you set ShutdownMode to OnExplicitShutdown. この場合、明示的に Shutdown メソッドを呼び出すことによってアプリケーションをシャット ダウンする必要があります。そうしないと、すべてのウィンドウが閉じられた場合でも、アプリケーションは実効を続けます。In this case, it is your responsibility to shut an application down by explicitly calling the Shutdown method; otherwise, your application will continue running even if all the windows are closed. Shutdown は、ShutdownModeOnLastWindowClose または OnMainWindowClose のときに暗黙的に呼び出されることに注意してください。Note that Shutdown is called implicitly when the ShutdownMode is either OnLastWindowClose or OnMainWindowClose.

注意

ShutdownMode は、XBAP から設定できますが、無視されます。XBAP は、ブラウザーで他にナビゲートされたか、または XBAP をホストするブラウザーが閉じられると、必ずシャットダウンします。ShutdownMode can be set from an XBAP, but it is ignored; an XBAP is always shut down when it is navigated away from in a browser or when the browser that hosts the XBAP is closed. 詳細については、「ナビゲーションの概要」を参照してください。For more information, see Navigation Overview.

セッションの終了Session Ending

ShutdownMode プロパティによって記述されるシャットダウン条件は、アプリケーションに固有です。The shutdown conditions that are described by the ShutdownMode property are specific to an application. ただし、場合によっては、アプリケーションは、外部条件の結果としてシャットダウンすることもあります。In some cases, though, an application may shut down as a result of an external condition. 最も一般的な外部条件は、ユーザーが次の操作によって Windows セッションを終了した場合です。The most common external condition occurs when a user ends the Windows session by the following actions:

  • ログオフLogging off

  • シャット ダウンShutting down

  • 再起動Restarting

  • 休止Hibernating

Windows セッションの終了を検出するには、次の例に示されているように、SessionEnding イベントを処理します。To detect when a Windows session ends, you can handle the SessionEnding event, as illustrated in the following example.

<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

この例のコードでは、ReasonSessionEnding プロパティを調べて、Windows セッションの終了方法を決定します。In this example, the code inspects the ReasonSessionEnding property to determine how the Windows session is ending. この値を使用して、ユーザーに確認メッセージを表示します。It uses this value to display a confirmation message to the user. ユーザーがセッションの終了を意図していない場合、コードでは Canceltrue に設定して、Windows セッションが終了しないようにします。If the user does not want the session to end, the code sets Cancel to true to prevent the Windows session from ending.

注意

SessionEnding は、XBAP に対しては発生しません。SessionEnding is not raised for XBAPs.

終了Exit

アプリケーションがシャット ダウンするときには、アプリケーション状態の保存など、いくつかの最終処理を実行しなければならない場合があります。When an application shuts down, it may need to perform some final processing, such as persisting application state. このような状況では、次の例の App_Exit イベント ハンドラーで行われているように、Exit イベントを処理できます。For these situations, you can handle the Exit event, as the App_Exit event handler does in the following example. これは、App.xaml ファイル内でイベント ハンドラーとして定義されています。It is defined as an event handler in the App.xaml file. その実装は、App.xaml.cs ファイルと Application.xaml.vb ファイルで強調表示されています。Its implementation is highlighted in the App.xaml.cs and Application.xaml.vb files.

<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

完全な例については、「アプリケーション セッション全体でアプリケーション スコープのプロパティを永続化および復元する」を参照してください。For the complete example, see Persist and Restore Application-Scope Properties Across Application Sessions.

Exit は、スタンドアロン アプリケーションと XBAP の両方によって処理できます。Exit can be handled by both standalone applications and XBAPs. XBAP では、次の状況で Exit が発生します。For XBAPs, Exit is raised when in the following circumstances:

  • XBAP から外部にナビゲートされた。An XBAP is navigated away from.

  • Internet Explorer で、XBAP をホストしているタブが閉じられた。In Internet Explorer, when the tab that is hosting the XBAP is closed.

  • ブラウザーが閉じられた。When the browser is closed.

終了コードExit Code

ほとんどのアプリケーションは、ユーザー要求に応じてオペレーティング システムから起動されます。Applications are mostly launched by the operating system in response to a user request. ただし、アプリケーションは、特定のタスクを実行するために、別のアプリケーションに起動されることもあります。However, an application can be launched by another application to perform some specific task. 起動されたアプリケーションがシャット ダウンするとき、起動元のアプリケーションは、起動されたアプリケーションのシャット ダウン条件を知ならなければならないことがあります。When the launched application shuts down, the launching application may want to know the condition under which the launched application shut down. このような場合、Windows では、アプリケーションは終了時にアプリケーション終了コードを返すことができます。In these situations, Windows allows applications to return an application exit code on shutdown. 既定では、WPF アプリケーションは 0 の終了コード値を返します。By default, WPF applications return an exit code value of 0.

注意

Visual Studio からデバッグする場合、アプリケーション終了コードは、アプリケーションのシャットダウン時に、 [出力] ウィンドウに次のようなメッセージで表示されます。When you debug from Visual Studio, the application exit code is displayed in the Output window when the application shuts down, in a message that looks like the following:

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

[出力] ウィンドウを開くには、 [表示] メニューの [出力] をクリックします。You open the Output window by clicking Output on the View menu.

終了コードを変更するには、Shutdown(Int32) オーバーロードを呼び出します。これは、終了コードとして整数引数を受け入れます。To change the exit code, you can call the Shutdown(Int32) overload, which accepts an integer argument to be the exit code:

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

Exit イベントを処理することによって、終了コードの値を検出し、変更できます。You can detect the value of the exit code, and change it, by handling the Exit event. Exit イベント ハンドラーに渡される ExitEventArgs では、ApplicationExitCode プロパティで終了コードへのアクセスが提供されます。The Exit event handler is passed an ExitEventArgs which provides access to the exit code with the ApplicationExitCode property. 詳細については、「Exit」を参照してください。For more information, see Exit.

注意

終了コードは、スタンドアロン アプリケーションと XBAP の両方で設定できます。You can set the exit code in both standalone applications and XBAPs. ただし、XBAP の場合、終了コード値は無視されます。However, the exit code value is ignored for XBAPs.

未処理の例外Unhandled Exceptions

ときには、アプリケーションは、予期しない例外がスローされたときなど、異常な条件下でシャットダウンすることがあります。Sometimes an application may shut down under abnormal conditions, such as when an unanticipated exception is thrown. この場合、アプリケーションには、例外を検出して処理するためのコードがありません。In this case, the application may not have the code to detect and process the exception. この種類の例外は、未処理の例外と呼ばれます。アプリケーションが閉じられる前に、次の図に示されているような通知が表示されます。This type of exception is an unhandled exception; a notification similar to that shown in the following figure is displayed before the application is closed.

ハンドルされない例外通知を示すスクリーンショット。

ユーザー エクスペリエンスの観点から、アプリケーションは、次のいずれか、またはすべてを行うことによって、この既定の動作を回避することをお勧めします。From the user experience perspective, it is better for an application to avoid this default behavior by doing some or all of the following:

  • わかりやすい情報を表示する。Displaying user-friendly information.

  • アプリケーションの続行を試みる。Attempting to keep an application running.

  • 開発者向けの詳細な例外情報を Windows イベント ログに記録する。Recording detailed, developer-friendly exception information in the Windows event log.

このサポートを実装するには、DispatcherUnhandledException イベントが発生した未処理の例外を検出できることが前提になります。Implementing this support depends on being able to detect unhandled exceptions, which is what the DispatcherUnhandledException event is raised for.

<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 イベント ハンドラーには、例外そのもの (DispatcherUnhandledExceptionEventArgs.Exception) も含め、未処理の例外に関するコンテキスト情報を含む DispatcherUnhandledExceptionEventArgs パラメーターが渡されます。The DispatcherUnhandledException event handler is passed a DispatcherUnhandledExceptionEventArgs parameter that contains contextual information regarding the unhandled exception, including the exception itself (DispatcherUnhandledExceptionEventArgs.Exception). この情報を使用して、例外の処理方法を決定できます。You can use this information to determine how to handle the exception.

DispatcherUnhandledException を処理するときには、DispatcherUnhandledExceptionEventArgs.Handled プロパティを true に設定する必要があります。そうしないと、WPF は例外を未処理のままとみなし、前述の既定の動作に戻ります。When you handle DispatcherUnhandledException, you should set the DispatcherUnhandledExceptionEventArgs.Handled property to true; otherwise, WPF still considers the exception to be unhandled and reverts to the default behavior described earlier. ハンドルされない例外が発生し、DispatcherUnhandledException イベントが処理されないか、イベントが処理されても、Handledfalse に設定されていた場合、アプリケーションはただちにシャットダウンします。If an unhandled exception is raised and either the DispatcherUnhandledException event is not handled, or the event is handled and Handled is set to false, the application shuts down immediately. さらに、他の Application イベントは発生しません。Furthermore, no other Application events are raised. 結果として、アプリケーションに、アプリケーションがシャットダウンする前に実行しなければならないコードがある場合は、DispatcherUnhandledException を処理する必要があります。Consequently, you need to handle DispatcherUnhandledException if your application has code that must run before the application shuts down.

アプリケーションは、未処理の例外の結果としてシャットダウンすることがありますが、通常は、次のセクションで説明されているように、ユーザーの要求に応じてシャットダウンします。Although an application may shut down as a result of an unhandled exception, an application usually shuts down in response to a user request, as discussed in the next section.

アプリケーションの有効期間イベントApplication Lifetime Events

スタンドアロン アプリケーションと XBAP の有効期間は、厳密に同じわけではありません。Standalone applications and XBAPs don't have exactly the same lifetimes. 次の図は、スタンドアロン アプリケーションの有効期間中の主なイベントと発生順を示しています。The following figure illustrates the key events in the lifetime of a standalone application and shows the sequence in which they are raised.

スタンドアロン アプリケーション - アプリケーション オブジェクト イベントStandalone Application - Application Object Events

同様に、次の図では、XBAP の有効期間中の主なイベントと発生順を示します。Likewise, the following figure illustrates the key events in the lifetime of an XBAP, and shows the sequence in which they are raised.

XBAP - アプリケーション オブジェクト イベントXBAP - Application Object Events

関連項目See also