プロセス

【C#】Application.Runの概要：Windowsフォームアプリのエントリーポイントとライフサイクル

2025-01-18更新日: 2025-01-18

Application.Runは、Windowsフォームアプリケーションのエントリーポイントとして機能し、指定されたフォームを表示してメッセージループを開始します。

これにより、アプリケーションのライフサイクル全体が管理され、ユーザーの入力やシステムメッセージに応答し続けます。

フォームが閉じられるとApplication.Runは終了し、アプリケーションも終了します。

目次から探す

Application.Runの基本
- Application.Runの役割
- 基本的な使用方法
エントリーポイントとしての役割
メッセージループとライフサイクル管理
フォームの起動と終了の流れ
実践的な使用例
まとめ

Application.Runの基本

Application.Runは、C#におけるWindowsフォームアプリケーションの実行を開始するためのメソッドです。

このメソッドは、アプリケーションのエントリーポイントとして機能し、フォームのライフサイクル管理を担います。

Application.Runの役割

Application.Runは、指定されたフォームを起動し、アプリケーションのメッセージループを開始します。

メッセージループは、ユーザーからの入力やシステムからのメッセージを処理し、アプリケーションが応答し続けるために必要です。

基本的な使用方法

以下は、Application.Runを使用した基本的なWindowsフォームアプリケーションの例です。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        /// <summary>
        /// アプリケーションのメインエントリーポイント
        /// </summary>
        [STAThread]
        static void Main()
        {
            // アプリケーションのビジュアルスタイルを有効にする
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを実行する
            Application.Run(new MainForm());
        }
    }
    public class MainForm : Form
    {
        public MainForm()
        {
            // フォームのタイトルを設定
            this.Text = "メインフォーム";
        }
    }
}

この例では、ProgramクラスのMainメソッドがアプリケーションのエントリーポイントとなっています。

Application.Run(new MainForm())によってMainFormが起動され、メッセージループが開始されます。

フォームが表示された状態でアプリケーションは実行され、ユーザーの操作を待機します。

このように、Application.Runはフォームの起動とアプリケーション全体の実行管理を一手に引き受ける重要なメソッドです。

エントリーポイントとしての役割

エントリーポイントとは、アプリケーションが実行を開始する最初のメソッドのことを指します。

C#のWindowsフォームアプリケーションにおいて、Application.Runはこのエントリーポイントとして重要な役割を果たします。

MainメソッドとApplication.Run

C#アプリケーションのエントリーポイントは通常、Mainメソッドです。

このメソッド内でApplication.Runが呼び出されることで、アプリケーションの実行が開始されます。

以下はその基本的な構造です。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        /// <summary>
        /// アプリケーションのメインエントリーポイント
        /// </summary>
        [STAThread]
        static void Main()
        {
            // ビジュアルスタイルを有効にする
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを実行し、メッセージループを開始する
            Application.Run(new MainForm());
        }
    }
    public class MainForm : Form
    {
        public MainForm()
        {
            // フォームのタイトルを設定
            this.Text = "メインフォーム";
        }
    }
}

エントリーポイントとしてのFlow

Mainメソッドの実行: アプリケーションが起動すると、まずMainメソッドが実行されます。
ビジュアルスタイルの設定: Application.EnableVisualStyles()とApplication.SetCompatibleTextRenderingDefault(false)でアプリケーションのビジュアルスタイルやテキストレンダリングの設定を行います。
Application.Runの呼び出し: Application.Run(new MainForm())により、MainFormが起動され、メッセージループが開始されます。

このメッセージループは、ユーザーからの操作やシステムからのメッセージを継続的に処理し、アプリケーションが応答し続けるために不可欠です。

エントリーポイントの重要性

エントリーポイントとしてのMainメソッドとApplication.Runの組み合わせは、アプリケーション全体のライフサイクル管理を担います。

これにより、アプリケーションの初期化、メッセージ処理、終了処理が一元的に管理され、安定した動作が保証されます。

まとめると、Application.Runは単なるメソッド呼び出しではなく、アプリケーションの起動から終了までの全体的な流れを制御する中核的な役割を持っています。

エントリーポイントとしてのこの役割を理解することで、より効果的にWindowsフォームアプリケーションを開発することが可能になります。

メッセージループとライフサイクル管理

メッセージループは、Windowsフォームアプリケーションの中心的な仕組みであり、アプリケーションのライフサイクル管理において重要な役割を果たします。

Application.Runメソッドは、このメッセージループを開始し、アプリケーションが適切に動作し続けるための基盤を提供します。

メッセージループの概要

メッセージループとは、Windowsオペレーティングシステムから送られるさまざまなメッセージ(例：ユーザーの入力、システムからの通知)を順次処理するループのことです。

このループが存在することで、アプリケーションはユーザーの操作に応答し、必要な処理を実行できます。

Application.Runによるメッセージループの開始

Application.Runメソッドは、内部的にメッセージループを開始します。

これにより、アプリケーションは継続的にメッセージを受け取り処理する状態を維持します。

以下のサンプルコードでは、Application.Runがどのようにメッセージループを開始するかを示しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        /// <summary>
        /// アプリケーションのメインエントリーポイント
        /// </summary>
        [STAThread]
        static void Main()
        {
            // ビジュアルスタイルを有効にする
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メッセージループを開始し、MainFormを表示する
            Application.Run(new MainForm());
        }
    }
    public class MainForm : Form
    {
        public MainForm()
        {
            // フォームのタイトルを設定
            this.Text = "メインフォーム";
        }
    }
}

この例では、Application.Run(new MainForm())が呼び出されることで、MainFormが表示され、メッセージループが開始されます。

メッセージループは、フォームが閉じられるまで継続的に動作し、アプリケーションの終了を制御します。

ライフサイクル管理の流れ

アプリケーションの起動: Mainメソッドが実行され、Application.Runによってメッセージループが開始されます。
フォームの表示: 指定されたフォーム(例ではMainForm)がユーザーに表示されます。
メッセージの処理: ユーザーの操作やシステムからのメッセージがメッセージキューに登録され、メッセージループがこれらを順次処理します。
アプリケーションの終了: フォームが閉じられると、メッセージループが終了し、アプリケーション全体が終了します。

メッセージループのカスタマイズ

通常、Application.Runによるメッセージループはデフォルトの動作で十分ですが、特定の要件に応じてメッセージループをカスタマイズすることも可能です。

例えば、カスタムメッセージの処理や特定の条件下でのアプリケーションの終了などが考えられます。

以下は、カスタムメッセージを処理する簡単な例です。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new CustomForm());
        }
    }
    public class CustomForm : Form
    {
        private const int WM_CUSTOM = 0x8001;
        public CustomForm()
        {
            this.Text = "カスタムフォーム";
            // ボタンクリックでカスタムメッセージを送信
            Button button = new Button
            {
                Text = "カスタムメッセージ送信",
                Dock = DockStyle.Fill
            };
            button.Click += (sender, e) => {
                // カスタムメッセージを自フォームに送信
                this.SendMessage(this.Handle, WM_CUSTOM, IntPtr.Zero, IntPtr.Zero);
            };
            this.Controls.Add(button);
        }
        // ウィンドウプロシージャをオーバーライドしてカスタムメッセージを処理
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_CUSTOM)
            {
                MessageBox.Show("カスタムメッセージを受信しました。");
            }
            base.WndProc(ref m);
        }
        // SendMessage APIの宣言
        [System.Runtime.InteropServices.DllImport("user32.dll")]
        private static extern int SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
    }
}

この例では、ボタンをクリックするとカスタムメッセージが送信され、WndProcメソッドでそのメッセージが処理されます。

これにより、メッセージループ内で独自のメッセージをハンドリングする方法が示されています。

メッセージループの重要性

メッセージループは、アプリケーションがユーザーと対話し、システムからの通知に応答するための基盤を提供します。

適切なメッセージループの管理は、アプリケーションの応答性や安定性に直結します。

Application.Runを通じてメッセージループが開始されることで、開発者はフォームやコントロールのイベントに集中し、効率的なアプリケーション開発が可能となります。

メッセージループとライフサイクル管理を理解することで、高度なユーザーインターフェースやカスタマイズされたメッセージ処理を実現し、より信頼性の高いアプリケーションを開発することができます。

フォームの起動と終了の流れ

フォームの起動と終了は、Windowsフォームアプリケーションの基本的な動作フローを理解する上で重要です。

このセクションでは、Application.Runを用いたフォームの起動から終了までの一連の流れについて詳しく解説します。

フォームの起動プロセス

アプリケーションが起動すると、Mainメソッドが実行され、Application.Runによって指定されたフォームが表示されます。

以下のサンプルコードは、メインフォームを起動し、ユーザーがフォームを閉じるまでアプリケーションが実行される基本的な流れを示しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        /// <summary>
        /// アプリケーションのメインエントリーポイント
        /// </summary>
        [STAThread]
        static void Main()
        {
            // アプリケーションのビジュアルスタイルを有効にする
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを実行し、メッセージループを開始する
            Application.Run(new MainForm());
        }
    }
    public class MainForm : Form
    {
        public MainForm()
        {
            // フォームのタイトルを設定
            this.Text = "メインフォーム";
            // フォームのサイズを設定
            this.Width = 800;
            this.Height = 600;
            // フォームのロードイベントにハンドラーを追加
            this.Load += MainForm_Load;
            // フォームのクローズイベントにハンドラーを追加
            this.FormClosing += MainForm_FormClosing;
        }
        private void MainForm_Load(object sender, EventArgs e)
        {
            // フォームがロードされた際の処理
            MessageBox.Show("メインフォームが起動しました。");
        }
        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // フォームが閉じられる直前の処理
            DialogResult result = MessageBox.Show("アプリケーションを終了しますか？", "終了確認", MessageBoxButtons.YesNo);
            if (result == DialogResult.No)
            {
                // アプリケーションの終了をキャンセル
                e.Cancel = true;
            }
        }
    }
}

フォームの終了プロセス

ユーザーがフォームを閉じると、FormClosingイベントが発生します。

このイベントでは、アプリケーションの終了を確認するダイアログを表示し、ユーザーの選択に応じてアプリケーションを終了またはキャンセルする処理を実装しています。

フォームのクローズ要求: ユーザーがフォームの閉じるボタンをクリックすると、FormClosingイベントが発生します。
終了確認ダイアログの表示: MessageBox.Showを使用して、ユーザーにアプリケーションの終了を確認します。
ユーザーの選択に応じた動作:

Yesを選択した場合: アプリケーションは通常通り終了します。
Noを選択した場合: e.Cancelをtrueに設定し、アプリケーションの終了をキャンセルします。

フォーム起動と終了のポイント

エントリーポイントとの連携: MainメソッドとApplication.Runは、フォームの起動とアプリケーションのメッセージループを開始するために密接に連携しています。
イベントハンドリング: フォームのライフサイクルイベントLoadやFormClosingを適切にハンドリングすることで、アプリケーションの動作をカスタマイズできます。
ユーザー体験の向上: 終了確認ダイアログなどの処理を実装することで、ユーザーが意図せずアプリケーションを終了することを防ぎ、より良いユーザー体験を提供できます。

フォームの起動と終了の流れをしっかりと理解することで、Windowsフォームアプリケーションの基本的な動作を把握し、安定したアプリケーション開発が可能になります。

実践的な使用例

Application.Runは、単にフォームを起動するだけでなく、さまざまな実践的なシナリオで活用することができます。

このセクションでは、複数のフォームを管理する方法やカスタムのアプリケーションコンテキストを使用した高度な制御方法など、実践的な使用例をいくつか紹介します。

複数フォームの管理

複数のフォームを持つアプリケーションでは、メインフォームとサブフォームを適切に管理することが重要です。

以下のサンプルコードでは、メインフォームからサブフォームを開き、サブフォームがすべて閉じられるとアプリケーション全体が終了する仕組みを実装しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームのインスタンスを作成
            MainForm mainForm = new MainForm();
            // メインフォームが閉じられたときにアプリケーションを終了する
            mainForm.FormClosed += (sender, e) => Application.Exit();
            // メインフォームを実行し、メッセージループを開始する
            Application.Run(mainForm);
        }
    }
    public class MainForm : Form
    {
        private Button openButton;
        public MainForm()
        {
            this.Text = "メインフォーム";
            this.Width = 400;
            this.Height = 300;
            // サブフォームを開くボタンを作成
            openButton = new Button
            {
                Text = "サブフォームを開く",
                Dock = DockStyle.Fill
            };
            openButton.Click += OpenButton_Click;
            this.Controls.Add(openButton);
        }
        private void OpenButton_Click(object sender, EventArgs e)
        {
            // サブフォームのインスタンスを作成
            SubForm subForm = new SubForm();
            // サブフォームが閉じられたときにアプリケーションを終了する
            subForm.FormClosed += (s, args) => {
                if (Application.OpenForms.Count == 0)
                {
                    Application.Exit();
                }
            };
            // サブフォームを表示する
            subForm.Show();
        }
    }
    public class SubForm : Form
    {
        public SubForm()
        {
            this.Text = "サブフォーム";
            this.Width = 300;
            this.Height = 200;
        }
    }
}

この例では、MainFormからSubFormを開くことができます。

サブフォームがすべて閉じられると、Application.Exit()が呼び出され、アプリケーション全体が終了します。

これにより、複数のフォームを持つアプリケーションでも、適切にライフサイクルを管理することが可能になります。

カスタムApplicationContextの使用

ApplicationContextを継承することで、アプリケーション全体のライフサイクルをより細かく制御することができます。

以下のサンプルでは、複数のフォームを管理し、すべてのフォームが閉じられたときにアプリケーションを終了するカスタムコンテキストを実装しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // カスタムコンテキストを作成
            CustomApplicationContext context = new CustomApplicationContext();
            // Application.Runにカスタムコンテキストを渡して実行
            Application.Run(context);
        }
    }
    // カスタムApplicationContextクラス
    public class CustomApplicationContext : ApplicationContext
    {
        // 開いているフォームのカウント
        private int openForms;
        public CustomApplicationContext()
        {
            // 最初のフォームを作成して開く
            OpenNewForm();
        }
        // 新しいフォームを開くメソッド
        private void OpenNewForm()
        {
            Form form = new Form
            {
                Text = "フォーム " + (openForms + 1),
                Width = 300,
                Height = 200
            };
            // フォームが閉じられたときにカウントを減らす
            form.FormClosed += (sender, e) => {
                openForms--;
                if (openForms == 0)
                {
                    // すべてのフォームが閉じられたらアプリケーションを終了
                    ExitThread();
                }
            };
            openForms++;
            form.Show();
        }
    }
}

この例では、CustomApplicationContextクラスを使用して複数のフォームを管理しています。

フォームが閉じられるたびにカウントが減少し、すべてのフォームが閉じられた時点でExitThread()が呼び出され、アプリケーションが終了します。

これにより、複雑なフォームの管理が必要な場合でも、柔軟に対応することができます。

モーダルダイアログとApplication.Runの併用

モーダルダイアログを使用する際にも、Application.Runを適切に使用することで、スムーズなユーザー体験を提供できます。

以下のサンプルコードでは、メインフォームからモーダルダイアログを開き、ダイアログの結果に応じてアプリケーションの動作を制御しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを作成
            MainForm mainForm = new MainForm();
            // メインフォームを実行する
            Application.Run(mainForm);
        }
    }
    public class MainForm : Form
    {
        private Button openDialogButton;
        public MainForm()
        {
            this.Text = "メインフォーム";
            this.Width = 400;
            this.Height = 300;
            // ダイアログを開くボタンを作成
            openDialogButton = new Button
            {
                Text = "モーダルダイアログを開く",
                Dock = DockStyle.Fill
            };
            openDialogButton.Click += OpenDialogButton_Click;
            this.Controls.Add(openDialogButton);
        }
        private void OpenDialogButton_Click(object sender, EventArgs e)
        {
            // モーダルダイアログを作成
            using (Form dialog = new Form())
            {
                dialog.Text = "モーダルダイアログ";
                dialog.Width = 250;
                dialog.Height = 150;
                // ダイアログ上にOKボタンを配置
                Button okButton = new Button
                {
                    Text = "OK",
                    DialogResult = DialogResult.OK,
                    Dock = DockStyle.Bottom
                };
                dialog.Controls.Add(okButton);
                // ダイアログのボタンをAcceptボタンとして設定
                this.AcceptButton = okButton;
                // ダイアログをモーダル表示
                DialogResult result = dialog.ShowDialog();
                if (result == DialogResult.OK)
                {
                    MessageBox.Show("ダイアログがOKで閉じられました。");
                }
            }
        }
    }
}

この例では、MainFormからモーダルダイアログを開くことができます。

ShowDialog()メソッドを使用してダイアログをモーダル表示し、ユーザーがOKボタンをクリックすると、ダイアログが閉じられ、結果に応じてメッセージボックスが表示されます。

Application.Runはメインフォームのメッセージループを管理しつつ、モーダルダイアログとの連携を円滑に行います。

シングルトンフォームの実装

特定のフォームがアプリケーション内で一つだけ存在するように制御することで、シングルトンパターンを実現できます。

以下のサンプルコードでは、複数回ダイアログを開こうとしても、一つのインスタンスだけが存在するように制御しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを作成
            MainForm mainForm = new MainForm();
            // メインフォームを実行する
            Application.Run(mainForm);
        }
    }
    public class MainForm : Form
    {
        private Button openSingletonButton;
        private SingletonForm singletonForm;
        public MainForm()
        {
            this.Text = "メインフォーム";
            this.Width = 400;
            this.Height = 300;
            // シングルトンフォームを開くボタンを作成
            openSingletonButton = new Button
            {
                Text = "シングルトンフォームを開く",
                Dock = DockStyle.Fill
            };
            openSingletonButton.Click += OpenSingletonButton_Click;
            this.Controls.Add(openSingletonButton);
        }
        private void OpenSingletonButton_Click(object sender, EventArgs e)
        {
            if (singletonForm == null || singletonForm.IsDisposed)
            {
                // シングルトンフォームの新しいインスタンスを作成
                singletonForm = new SingletonForm();
                singletonForm.FormClosed += (s, args) => singletonForm = null;
                singletonForm.Show();
            }
            else
            {
                // 既に開かれている場合はフォーカスを移動
                singletonForm.Focus();
            }
        }
    }
    public class SingletonForm : Form
    {
        public SingletonForm()
        {
            this.Text = "シングルトンフォーム";
            this.Width = 300;
            this.Height = 200;
        }
    }
}

この例では、MainFormからSingletonFormを開く際に、既にインスタンスが存在する場合は新たに作成せず、既存のフォームにフォーカスを移動します。

これにより、アプリケーション内で特定のフォームが一つだけ存在することを保証できます。

非同期処理との併用

非同期処理を行う際にも、Application.Runを適切に活用することで、UIスレッドをブロックせずにアプリケーションを実行し続けることが可能です。

以下のサンプルコードでは、バックグラウンドで長時間の処理を実行しつつ、ユーザーインターフェースの応答性を維持しています。

using System;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // メインフォームを作成
            MainForm mainForm = new MainForm();
            // メインフォームを実行する
            Application.Run(mainForm);
        }
    }
    public class MainForm : Form
    {
        private Button startButton;
        private ProgressBar progressBar;
        private Label statusLabel;
        public MainForm()
        {
            this.Text = "非同期処理の例";
            this.Width = 400;
            this.Height = 200;
            // スタートボタンを作成
            startButton = new Button
            {
                Text = "処理を開始",
                Dock = DockStyle.Top
            };
            startButton.Click += StartButton_Click;
            this.Controls.Add(startButton);
            // プログレスバーを作成
            progressBar = new ProgressBar
            {
                Dock = DockStyle.Top,
                Height = 30
            };
            this.Controls.Add(progressBar);
            // ステータスラベルを作成
            statusLabel = new Label
            {
                Text = "待機中...",
                Dock = DockStyle.Fill,
                TextAlign = System.Drawing.ContentAlignment.MiddleCenter
            };
            this.Controls.Add(statusLabel);
        }
        private async void StartButton_Click(object sender, EventArgs e)
        {
            // UIの状態を更新
            startButton.Enabled = false;
            statusLabel.Text = "処理中...";
            progressBar.Value = 0;
            // 非同期で長時間処理を実行
            await Task.Run(() => LongRunningProcess());
            // 処理完了後のUIを更新
            progressBar.Value = 100;
            statusLabel.Text = "処理完了";
            startButton.Enabled = true;
        }
        private void LongRunningProcess()
        {
            // シミュレーションとして5秒間待機
            for (int i = 1; i <= 5; i++)
            {
                System.Threading.Thread.Sleep(1000);
                // プログレスバーを更新(スレッドセーフではないため実際のアプリケーションではInvokeが必要)
                this.Invoke((Action)(() => progressBar.Value = i * 20));
            }
        }
    }
}

この例では、StartButtonをクリックすると、バックグラウンドでLongRunningProcessが実行されます。

非同期処理により、UIスレッドがブロックされることなく、ユーザーインターフェースが引き続き応答性を保ちます。

Application.Runによってメッセージループが維持されているため、アプリケーション全体がスムーズに動作します。

システムトレイアイコンとApplication.Runの併用

アプリケーションをシステムトレイに常駐させ、メインフォームを非表示にすることで、ユーザーに常時アクセス可能なツールを提供することができます。

以下のサンプルコードでは、NotifyIconを使用してシステムトレイアイコンを実装し、アプリケーションの起動と終了を制御しています。

using System;
using System.Windows.Forms;
namespace SampleApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            // カスタムコンテキストを作成
            CustomApplicationContext context = new CustomApplicationContext();
            // Application.Runにカスタムコンテキストを渡して実行
            Application.Run(context);
        }
    }
    public class CustomApplicationContext : ApplicationContext
    {
        private NotifyIcon trayIcon;
        private Form hiddenForm;
        public CustomApplicationContext()
        {
            // システムトレイアイコンを作成
            trayIcon = new NotifyIcon()
            {
                Icon = System.Drawing.SystemIcons.Application,
                ContextMenu = new ContextMenu(new MenuItem[] {
                    new MenuItem("表示", ShowForm),
                    new MenuItem("終了", Exit)
                }),
                Visible = true,
                Text = "トレイアプリケーション"
            };
            // 隠しフォームを作成
            hiddenForm = new Form()
            {
                Visible = false
            };
            // メニューアイテムのクリックイベントを設定
            trayIcon.DoubleClick += ShowForm;
        }
        private void ShowForm(object sender, EventArgs e)
        {
            // フォームが既に存在していない場合は新規作成
            if (hiddenForm.IsDisposed)
            {
                hiddenForm = new Form()
                {
                    Text = "メインフォーム",
                    Width = 400,
                    Height = 300
                };
                hiddenForm.FormClosed += (s, args) => hiddenForm = null;
            }
            // フォームを表示
            hiddenForm.Show();
            hiddenForm.Focus();
        }
        private void Exit(object sender, EventArgs e)
        {
            // トレイアイコンを非表示にしてアプリケーションを終了
            trayIcon.Visible = false;
            Application.Exit();
        }
    }
}