// ? 錯誤做法：每次都new新窗體
private void btnOpen_Click(object sender, EventArgs e)
{
    UserForm userForm = new UserForm(); // 內(nèi)存泄漏源頭！
    userForm.Show();
}

// ? 危險代碼：事件未解除訂閱
public partial class MyForm : Form
{
    private Timer timer = new Timer();

    public MyForm()
    {
        timer.Tick += Timer_Tick; // 訂閱了但從未取消！
        timer.Start();
    }

    private void Timer_Tick(object sender, EventArgs e)
    {
        // 定時處理邏輯
    }
}

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace AppWinFormResourceDemo.Core
{
    /// <summary>
    /// 窗體生命周期管理器 - 解決窗體內(nèi)存泄漏的核心類
    /// </summary>
    publicstaticclass FormLifecycleManager
    {
        // 使用線程安全的并發(fā)字典緩存窗體
        privatestatic readonly ConcurrentDictionary<string, WeakReference> _formCache
            = new ConcurrentDictionary<string, WeakReference>();

        // 跟蹤所有注冊的窗體
        privatestatic readonly List<WeakReference> _allForms = new List<WeakReference>();

        /// <summary>
        /// 注冊窗體到管理器
        /// </summary>
        public static void RegisterForm(Form form)
        {
            var weakRef = new WeakReference(form);
            _allForms.Add(weakRef);

            // ?? 關(guān)鍵：窗體關(guān)閉時自動清理
            form.FormClosed += (s, e) => {
                _allForms.Remove(weakRef);
                if (s is Form closedForm)
                {
                    closedForm.Dispose(); // 確保資源釋放
                }
            };

            CleanupDeadReferences();
        }

        /// <summary>
        /// 獲取或創(chuàng)建單例窗體 - 防止重復(fù)創(chuàng)建的核心方法
        /// </summary>
        publicstatic T GetOrCreateSingletonForm<T>() where T : Form, new()
        {
            string key = typeof(T).FullName;

            // 檢查緩存中是否存在有效窗體
            if (_formCache.TryGetValue(key, out WeakReference weakRef) &&
                weakRef.IsAlive && weakRef.Target is T existingForm)
            {
                // ?? 性能優(yōu)化：復(fù)用現(xiàn)有窗體
                existingForm.WindowState = FormWindowState.Normal;
                existingForm.BringToFront();
                return existingForm;
            }

            // 創(chuàng)建新窗體并緩存
            T newForm = new T();
            _formCache[key] = new WeakReference(newForm);
            RegisterForm(newForm);

            return newForm;
        }

        /// <summary>
        /// 緊急清理所有窗體 - 應(yīng)用退出時的保險機(jī)制
        /// </summary>
        public static void EmergencyCleanup()
        {
            var formsToClose = _allForms
                .Where(wr => wr.IsAlive && wr.Target is Form)
                .Select(wr => wr.Target as Form)
                .Where(f => f != null && !f.IsDisposed)
                .ToList();

            foreach (var form in formsToClose)
            {
                try
                {
                    // ??? 線程安全處理
                    if (form.InvokeRequired)
                    {
                        form.Invoke(new Action(() => form.Close()));
                    }
                    else
                    {
                        form.Close();
                    }
                }
                catch { /* 靜默處理異常，避免程序崩潰 */ }
            }

            // 強(qiáng)制垃圾回收
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }

        /// <summary>
        /// 清理無效引用
        /// </summary>
        private static void CleanupDeadReferences()
        {
            _allForms.RemoveAll(wr => !wr.IsAlive);

            var deadKeys = _formCache
                .Where(kvp => !kvp.Value.IsAlive)
                .Select(kvp => kvp.Key)
                .ToList();

            foreach (var key in deadKeys)
            {
                _formCache.TryRemove(key, out _);
            }
        }

        /// <summary>
        /// 獲取當(dāng)前活動窗體數(shù)量 - 用于監(jiān)控內(nèi)存使用
        /// </summary>
        public static int GetActiveFormCount()
        {
            return _allForms.Count(wr => wr.IsAlive);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Windows.Forms;

namespace AppWinFormResourceDemo.Core
{
    /// <summary>
    /// 自動資源清理基類 - 繼承此類的窗體將自動清理所有資源
    /// </summary>
    publicclass BaseForm : Form
    {
        // 管理需要手動釋放的資源
        private readonly List<IDisposable> _disposables = new List<IDisposable>();

        public BaseForm()
        {
            InitializeBaseStyle();
        }

        /// <summary>
        /// 初始化統(tǒng)一的窗體樣式
        /// </summary>
        private void InitializeBaseStyle()
        {
            this.BackColor = Color.FromArgb(245, 246, 250);
            this.Font = new Font("Microsoft YaHei UI", 9F, FontStyle.Regular);
            this.StartPosition = FormStartPosition.CenterScreen;
            this.FormBorderStyle = FormBorderStyle.FixedSingle;
            this.MaximizeBox = false;
        }

        /// <summary>
        /// 重寫Dispose方法 - 資源清理的核心
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                try
                {
                    // ?? 四步清理法
                    DisposeCustomResources();     // 1. 清理自定義資源
                    ClearAllControlEvents();      // 2. 清理控件事件
                    ClearImageResources();        // 3. 清理圖片資源
                    ClearDataBindings();          // 4. 清理數(shù)據(jù)綁定
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine($"窗體釋放異常: {ex.Message}");
                }
            }
            base.Dispose(disposing);
        }

        /// <summary>
        /// 注冊需要釋放的資源 - 使用此方法管理Timer、數(shù)據(jù)庫連接等
        /// </summary>
        protected void RegisterDisposable(IDisposable disposable)
        {
            if (disposable != null)
                _disposables.Add(disposable);
        }

        /// <summary>
        /// 清理自定義注冊的資源
        /// </summary>
        private void DisposeCustomResources()
        {
            foreach (var disposable in _disposables)
            {
                try
                {
                    disposable?.Dispose();
                }
                catch { /* 靜默處理，避免連鎖異常 */ }
            }
            _disposables.Clear();
        }

        /// <summary>
        /// ?? 核心功能：自動清理所有控件事件
        /// </summary>
        private void ClearAllControlEvents()
        {
            ClearControlEventsRecursive(this);
        }

        private void ClearControlEventsRecursive(Control parent)
        {
            foreach (Control control in parent.Controls)
            {
                ClearControlSpecificEvents(control);

                if (control.HasChildren)
                    ClearControlEventsRecursive(control);
            }
        }

        /// <summary>
        /// 針對不同控件類型的特殊處理
        /// </summary>
        private void ClearControlSpecificEvents(Control control)
        {
            switch (control)
            {
                case DataGridView dgv:
                    dgv.DataSource = null;
                    dgv.Rows.Clear();
                    dgv.Columns.Clear();
                    break;
                case ComboBox cmb:
                    cmb.DataSource = null;
                    cmb.Items.Clear();
                    break;
                case ListBox lst:
                    lst.DataSource = null;
                    lst.Items.Clear();
                    break;
                case ListView lv:
                    lv.Items.Clear();
                    lv.Columns.Clear();
                    break;
                case TreeView tv:
                    tv.Nodes.Clear();
                    break;
                case TextBox txt:
                    txt.DataBindings.Clear();
                    break;
            }

            // ?? 高級技巧：使用反射清理所有事件訂閱
            ClearControlEventsViaReflection(control);
        }

        /// <summary>
        /// 使用反射清理事件 - 高級內(nèi)存管理技巧
        /// </summary>
        private void ClearControlEventsViaReflection(Control control)
        {
            try
            {
                Type controlType = control.GetType();
                FieldInfo[] eventFields = controlType.GetFields(
                    BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);

                foreach (FieldInfo field in eventFields)
                {
                    if (typeof(Delegate).IsAssignableFrom(field.FieldType))
                    {
                        // 將事件字段設(shè)置為null，移除所有訂閱
                        field.SetValue(control, null);
                    }
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"清除控件事件異常: {ex.Message}");
            }
        }

        /// <summary>
        /// 清理圖片資源 - 防止大對象堆積
        /// </summary>
        private void ClearImageResources()
        {
            ClearImageResourcesRecursive(this);
        }

        private void ClearImageResourcesRecursive(Control parent)
        {
            foreach (Control control in parent.Controls)
            {
                try
                {
                    // 處理PictureBox圖片
                    if (control is PictureBox pb && pb.Image != null)
                    {
                        var image = pb.Image;
                        pb.Image = null;
                        image.Dispose();
                    }

                    // 處理Button圖片
                    if (control is Button btn && btn.Image != null)
                    {
                        var image = btn.Image;
                        btn.Image = null;
                        image.Dispose();
                    }

                    // 處理背景圖片
                    if (control.BackgroundImage != null)
                    {
                        var bgImage = control.BackgroundImage;
                        control.BackgroundImage = null;
                        bgImage.Dispose();
                    }

                    if (control.HasChildren)
                        ClearImageResourcesRecursive(control);
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine($"清除圖片資源異常: {ex.Message}");
                }
            }
        }

        /// <summary>
        /// 清理數(shù)據(jù)綁定
        /// </summary>
        private void ClearDataBindings()
        {
            ClearDataBindingsRecursive(this);
        }

        private void ClearDataBindingsRecursive(Control parent)
        {
            foreach (Control control in parent.Controls)
            {
                try
                {
                    control.DataBindings.Clear();

                    if (control.HasChildren)
                        ClearDataBindingsRecursive(control);
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine($"清除數(shù)據(jù)綁定異常: {ex.Message}");
                }
            }
        }
    }
}

public partial class MainForm : BaseForm
{
    public MainForm()
    {
        InitializeComponent();
        InitializeEvents();
    }

    private void InitializeEvents()
    {
        btnOpenUserForm.Click += BtnOpenUserForm_Click;
        btnShowFormCount.Click += BtnShowFormCount_Click;
        btnEmergencyCleanup.Click += BtnEmergencyCleanup_Click;

        // ?? 關(guān)鍵步驟：注冊到生命周期管理器
        FormLifecycleManager.RegisterForm(this);
    }

    /// <summary>
    /// ?? 性能提升：使用單例模式打開窗體
    /// </summary>
    private void BtnOpenUserForm_Click(object sender, EventArgs e)
    {
        // 不再每次new，而是復(fù)用現(xiàn)有窗體
        var userForm = FormLifecycleManager.GetOrCreateSingletonForm<UserManagementForm>();
        userForm.Show();
    }

    /// <summary>
    /// 監(jiān)控內(nèi)存使用情況
    /// </summary>
    private void BtnShowFormCount_Click(object sender, EventArgs e)
    {
        int count = FormLifecycleManager.GetActiveFormCount();
        MessageBox.Show($"當(dāng)前活動窗體數(shù)量: {count}\n" +
                       $"進(jìn)程內(nèi)存使用: {GC.GetTotalMemory(false) / 1024 / 1024}MB", 
                       "內(nèi)存監(jiān)控");
    }

    /// <summary>
    /// 應(yīng)用退出前的清理
    /// </summary>
    private void BtnEmergencyCleanup_Click(object sender, EventArgs e)
    {
        FormLifecycleManager.EmergencyCleanup();
        GC.Collect(); // 手動觸發(fā)垃圾回收
        MessageBox.Show("清理完成！", "操作完成");
    }
}

public partial class UserManagementForm : BaseForm
{
    private DataTable userDataTable;
    private Timer refreshTimer;

    public UserManagementForm()
    {
        InitializeComponent();
        InitializeData();
        InitializeEvents();
    }

    private void InitializeData()
    {
        // 創(chuàng)建數(shù)據(jù)表
        userDataTable = new DataTable();
        // ... 添加數(shù)據(jù)邏輯

        dataGridViewUsers.DataSource = userDataTable;

        // ?? 重要：注冊需要釋放的資源
        RegisterDisposable(userDataTable);
    }

    private void InitializeEvents()
    {
        // 創(chuàng)建定時器
        refreshTimer = new Timer();
        refreshTimer.Interval = 5000;
        refreshTimer.Tick += RefreshTimer_Tick;
        refreshTimer.Start();

        // ?? 重要：注冊定時器到資源管理
        RegisterDisposable(refreshTimer);
    }

    private void RefreshTimer_Tick(object sender, EventArgs e)
    {
        lblLastUpdate.Text = $"最后更新: {DateTime.Now:yyyy-MM-dd HH:mm:ss}";
    }

    // 窗體關(guān)閉時，BaseForm會自動清理所有資源！
}

// ? 錯誤：創(chuàng)建了Timer但沒有注冊
Timer timer = new Timer();

// ? 正確：注冊到資源管理器
Timer timer = new Timer();
RegisterDisposable(timer);

// ? 正確的線程安全處理
if (form.InvokeRequired)
{
    form.Invoke(new Action(() => form.Close()));
}
else
{
    form.Close();
}

public MainForm()
{
    InitializeComponent();
    // ? 必須添加這行！
    FormLifecycleManager.RegisterForm(this);
}

public partial class YourForm : BaseForm
{
    public YourForm()
    {
        InitializeComponent();

        // 注冊資源
        RegisterDisposable(yourTimer);
        RegisterDisposable(yourDataTable);

        // 注冊到生命周期管理器
        FormLifecycleManager.RegisterForm(this);
    }
}

private void OpenForm<T>() where T : Form, new()
{
    var form = FormLifecycleManager.GetOrCreateSingletonForm<T>();
    form.Show();
}

protected override void OnFormClosing(FormClosingEventArgs e)
{
    if (e.CloseReason == CloseReason.UserClosing)
    {
        FormLifecycleManager.EmergencyCleanup();
    }
    base.OnFormClosing(e);
}