ApplicationContext 類別

定義

命名空間:

System.Windows.Forms

組件:

System.Windows.Forms.dll

來源:

ApplicationContext.cs

指定應用程式執行緒的內容資訊。

C#

public class ApplicationContext : IDisposable

繼承

Object

ApplicationContext

實作

IDisposable

範例

下列程式碼範例會顯示兩個表單，並在兩個表單關閉時結束應用程式。 當應用程式啟動和結束時，會記住每個表單的位置。 此範例示範如何使用 ApplicationContext ，以及 Application.Run(context) 方法，在應用程式啟動時顯示多個表單。

類別 MyApplicationContext 繼承自 ApplicationContext ，並追蹤每個表單關閉的時間，並在兩者都是時結束目前的執行緒。 類別會儲存使用者每個表單的位置。 表單位置資料會儲存在標題 Appdata.txt 為 的檔案中，該檔案會建立在 所 UserAppDataPath 決定的位置中。

方法會 Main 呼叫 Application.Run(context) 以啟動應用程式，並指定 ApplicationContext 。

C#

using System;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;
using System.Text;
using System.IO;

namespace MyApplication
{
    // A simple form that represents a window in our application
    public class AppForm2 : System.Windows.Forms.Form
    {
        public AppForm2()
        {
            this.Size = new System.Drawing.Size(300, 300);
            this.Text = "AppForm2";
        }
    }

    // A simple form that represents a window in our application
    public class AppForm1 : System.Windows.Forms.Form
    {
        public AppForm1()
        {
            this.Size = new System.Drawing.Size(300, 300);
            this.Text = "AppForm1";
        }
    }

    // The class that handles the creation of the application windows
    class MyApplicationContext : ApplicationContext
    {

        private int _formCount;
        private AppForm1 _form1;
        private AppForm2 _form2;

        private Rectangle _form1Position;
        private Rectangle _form2Position;

        private FileStream _userData;

        private MyApplicationContext()
        {
            _formCount = 0;

            // Handle the ApplicationExit event to know when the application is exiting.
            Application.ApplicationExit += new EventHandler(this.OnApplicationExit);

            try
            {
                // Create a file that the application will store user specific data in.
                _userData = new FileStream(Application.UserAppDataPath + "\\appdata.txt", FileMode.OpenOrCreate);
            }
            catch (IOException e)
            {
                // Inform the user that an error occurred.
                MessageBox.Show("An error occurred while attempting to show the application." +
                                "The error is:" + e.ToString());

                // Exit the current thread instead of showing the windows.
                ExitThread();
            }

            // Create both application forms and handle the Closed event
            // to know when both forms are closed.
            _form1 = new AppForm1();
            _form1.Closed += new EventHandler(OnFormClosed);
            _form1.Closing += new CancelEventHandler(OnFormClosing);
            _formCount++;

            _form2 = new AppForm2();
            _form2.Closed += new EventHandler(OnFormClosed);
            _form2.Closing += new CancelEventHandler(OnFormClosing);
            _formCount++;

            // Get the form positions based upon the user specific data.
            if (ReadFormDataFromFile())
            {
                // If the data was read from the file, set the form
                // positions manually.
                _form1.StartPosition = FormStartPosition.Manual;
                _form2.StartPosition = FormStartPosition.Manual;

                _form1.Bounds = _form1Position;
                _form2.Bounds = _form2Position;
            }

            // Show both forms.
            _form1.Show();
            _form2.Show();
        }

        private void OnApplicationExit(object sender, EventArgs e)
        {
            // When the application is exiting, write the application data to the
            // user file and close it.
            WriteFormDataToFile();

            try
            {
                // Ignore any errors that might occur while closing the file handle.
                _userData.Close();
            }
            catch { }
        }

        private void OnFormClosing(object sender, CancelEventArgs e)
        {
            // When a form is closing, remember the form position so it
            // can be saved in the user data file.
            if (sender is AppForm1)
                _form1Position = ((Form)sender).Bounds;
            else if (sender is AppForm2)
                _form2Position = ((Form)sender).Bounds;
        }

        private void OnFormClosed(object sender, EventArgs e)
        {
            // When a form is closed, decrement the count of open forms.

            // When the count gets to 0, exit the app by calling
            // ExitThread().
            _formCount--;
            if (_formCount == 0)
            {
                ExitThread();
            }
        }

        private bool WriteFormDataToFile()
        {
            // Write the form positions to the file.
            UTF8Encoding encoding = new UTF8Encoding();

            RectangleConverter rectConv = new RectangleConverter();
            string form1pos = rectConv.ConvertToString(_form1Position);
            string form2pos = rectConv.ConvertToString(_form2Position);

            byte[] dataToWrite = encoding.GetBytes("~" + form1pos + "~" + form2pos);

            try
            {
                // Set the write position to the start of the file and write
                _userData.Seek(0, SeekOrigin.Begin);
                _userData.Write(dataToWrite, 0, dataToWrite.Length);
                _userData.Flush();

                _userData.SetLength(dataToWrite.Length);
                return true;
            }
            catch
            {
                // An error occurred while attempting to write, return false.
                return false;
            }
        }

        private bool ReadFormDataFromFile()
        {
            // Read the form positions from the file.
            UTF8Encoding encoding = new UTF8Encoding();
            string data;

            if (_userData.Length != 0)
            {
                byte[] dataToRead = new byte[_userData.Length];

                try
                {
                    // Set the read position to the start of the file and read.
                    _userData.Seek(0, SeekOrigin.Begin);
                    _userData.Read(dataToRead, 0, dataToRead.Length);
                }
                catch (IOException e)
                {
                    string errorInfo = e.ToString();
                    // An error occurred while attempt to read, return false.
                    return false;
                }

                // Parse out the data to get the window rectangles
                data = encoding.GetString(dataToRead);

                try
                {
                    // Convert the string data to rectangles
                    RectangleConverter rectConv = new RectangleConverter();
                    string form1pos = data.Substring(1, data.IndexOf("~", 1) - 1);

                    _form1Position = (Rectangle)rectConv.ConvertFromString(form1pos);

                    string form2pos = data.Substring(data.IndexOf("~", 1) + 1);
                    _form2Position = (Rectangle)rectConv.ConvertFromString(form2pos);

                    return true;
                }
                catch
                {
                    // Error occurred while attempting to convert the rectangle data.
                    // Return false to use default values.
                    return false;
                }
            }
            else
            {
                // No data in the file, return false to use default values.
                return false;
            }
        }

        [STAThread]
        static void Main(string[] args)
        {

            // Create the MyApplicationContext, that derives from ApplicationContext,
            // that manages when the application should exit.

            MyApplicationContext context = new MyApplicationContext();

            // Run the application with the specific context. It will exit when
            // all forms are closed.
            Application.Run(context);
        }
    }
}

備註

您可以使用 類別 ApplicationContext 來重新定義導致訊息迴圈結束的情況。 根據預設，會 ApplicationContext 接 Closed 聽應用程式主要 Form 上的 事件，然後結束執行緒的訊息迴圈。

建構函式

ApplicationContext()	使用無內容的方式，初始化 ApplicationContext 類別的新執行個體。
ApplicationContext(Form)	使用指定的 ApplicationContext 初始化 Form 類別的新執行個體。

屬性

MainForm	取得或設定要當做內容使用的 Form。
Tag	取得或設定包含控制項相關資料的物件。

方法

Dispose()	釋放 ApplicationContext 所使用的所有資源。
Dispose(Boolean)	釋放 ApplicationContext 所使用的 Unmanaged 資源，並選擇性地釋放 Managed 資源。
ExitThread()	結束執行緒的訊息迴圈。
ExitThreadCore()	結束執行緒的訊息迴圈。
Finalize()	嘗試在應用程式內容經由記憶體回收之前，釋放資源和執行其他的清除作業。
OnMainFormClosed(Object, EventArgs)	呼叫會引發 ExitThreadCore() 事件的 ThreadExit。

事件

ThreadExit

發生在執行緒的訊息迴圈應該藉著呼叫 ExitThread() 時結束。

適用於