namespace AppVariableMemory
{
    internal class Program
    {

        static void Main(string[] args)
        {
            // 值類型示例 - 存儲在棧上
            int valueType1 = 10;        // 直接存儲值
            int valueType2 = valueType1; // 復制值
            valueType2 = 20;            // 修改副本，不影響原值

            Console.WriteLine($"valueType1: {valueType1}"); 
            Console.WriteLine($"valueType2: {valueType2}"); 

            // 引用類型示例 - 對象存儲在堆上，引用存儲在棧上
            Person person1 = new Person { Name = "張三", Age = 25 };
            Person person2 = person1;    // 復制引用，指向同一個對象
            person2.Name = "李四";       // 修改對象屬性

            Console.WriteLine($"person1.Name: {person1.Name}"); 
            Console.WriteLine($"person2.Name: {person2.Name}"); 

            // 關鍵差異演示
            DemonstrateMemoryAllocation();
        }

        static void DemonstrateMemoryAllocation()
        {
            // 值類型：每次賦值都創(chuàng)建新的內(nèi)存空間
            int a = 5;
            int b = a;  // 在棧上創(chuàng)建新的內(nèi)存位置
            b = 10;     // 只修改b的值，a不受影響

            // 引用類型：多個變量可以指向同一個對象
            var list1 = new List<int> { 1, 2, 3 };
            var list2 = list1;  // list2和list1指向同一個List對象
            list2.Add(4);       // 通過list2修改，list1也能看到變化

            Console.WriteLine($"list1 count: {list1.Count}"); 
            Console.WriteLine($"list2 count: {list2.Count}");
        }
    }

    // 自定義引用類型
    publicclass Person
    {
        publicstring Name { get; set; }
        publicint Age { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppVariableMemory
{
   publicclass MemoryManager
    {
        // 靜態(tài)字段 - 存儲在方法區(qū)
        privatestaticint staticCounter = 0;

        // 實例字段 - 存儲在堆上（作為對象的一部分）
        privateint instanceCounter = 0;

        public void DemonstrateStackAllocation()
        {
            Console.WriteLine("=== 棧內(nèi)存分配演示 ===");

            // 局部變量 - 存儲在棧上,這里可能是不少人忽略的，要是學習C，就清晰多了
            int localInt = 42;              // 棧上分配4字節(jié)
            double localDouble = 3.14;      // 棧上分配8字節(jié)
            bool localBool = true;          // 棧上分配1字節(jié)
            char localChar = 'A';           // 棧上分配2字節(jié)

            // 結構體 - 整個結構體存儲在棧上
            Point point = new Point(10, 20);

            Console.WriteLine($"棧上變量: {localInt}, {localDouble}, {localBool}, {localChar}");
            Console.WriteLine($"結構體: ({point.X}, {point.Y})");

            // 演示棧的后進先出特性
            DemonstrateStackLifetime();
        }

        public void DemonstrateHeapAllocation()
        {
            Console.WriteLine("\n=== 堆內(nèi)存分配演示 ===");

            // 對象創(chuàng)建 - 在堆上分配內(nèi)存
            Person person = new Person("Alice", 30);

            // 數(shù)組創(chuàng)建 - 數(shù)組對象在堆上
            int[] numbers = newint[5] { 1, 2, 3, 4, 5 };

            // 集合創(chuàng)建 - 集合對象在堆上
            List<string> names = new List<string> { "Tom", "Jerry", "Mickey" };

            // 字符串 - 每個字符串字面量在堆上創(chuàng)建一個對象
            string message = "Hello World";

            Console.WriteLine($"Person對象: {person.Name}, Age: {person.Age}");
            Console.WriteLine($"數(shù)組長度: {numbers.Length}");
            Console.WriteLine($"集合元素數(shù): {names.Count}");
            Console.WriteLine($"字符串: {message}");

            // 演示引用的復制
            DemonstrateReferenceSharing(person, numbers);
        }

        private void DemonstrateStackLifetime()
        {
            // 方法開始時，為局部變量分配棧空間
            int methodVariable = 100;

            {
                // 進入代碼塊，繼續(xù)在棧上分配
                int blockVariable = 200;
                Console.WriteLine($"代碼塊內(nèi): {blockVariable}");

                // blockVariable在代碼塊結束時自動釋放
            }

            Console.WriteLine($"方法內(nèi): {methodVariable}");

            // methodVariable在方法結束時自動釋放
        }

        private void DemonstrateReferenceSharing(Person person, int[] array)
        {
            // 引用類型參數(shù)傳遞：傳遞的是引用的副本
            person.Age = 35;  // 修改原對象
            array[0] = 999;   // 修改原數(shù)組

            // 重新賦值：只影響局部引用，不影響原始引用
            person = new Person("Bob", 25);
            array = newint[] { 7, 8, 9 };

            Console.WriteLine($"方法內(nèi)新對象: {person.Name}");
        }

        public void DemonstrateMemoryPressure()
        {
            Console.WriteLine("\n=== 內(nèi)存壓力測試 ===");

            // 大量對象創(chuàng)建，觀察GC行為
            var largeList = new List<byte[]>();

            for (int i = 0; i < 1000; i++)
            {
                // 每次創(chuàng)建1MB的字節(jié)數(shù)組
                byte[] largeArray = new byte[1024 * 1024];
                largeList.Add(largeArray);

                // 每100次創(chuàng)建后顯示內(nèi)存使用情況
                if (i % 100 == 0)
                {
                    long memoryBefore = GC.GetTotalMemory(false);
                    Console.WriteLine($"創(chuàng)建{i + 1}個對象后，內(nèi)存使用: {memoryBefore / 1024 / 1024} MB");
                }
            }

            // 強制垃圾回收
            Console.WriteLine("執(zhí)行垃圾回收...");
            long memoryBeforeGC = GC.GetTotalMemory(false);
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            long memoryAfterGC = GC.GetTotalMemory(true);

            Console.WriteLine($"GC前內(nèi)存: {memoryBeforeGC / 1024 / 1024} MB");
            Console.WriteLine($"GC后內(nèi)存: {memoryAfterGC / 1024 / 1024} MB");
            Console.WriteLine($"釋放內(nèi)存: {(memoryBeforeGC - memoryAfterGC) / 1024 / 1024} MB");
        }
    }

    // 值類型 - 結構體
    publicstruct Point
    {
        publicint X { get; }
        publicint Y { get; }

        public Point(int x, int y)
        {
            X = x;
            Y = y;
        }
    }

    // 引用類型 - 類
    publicclass Person
    {
        publicstring Name { get; set; }
        publicint Age { get; set; }

        public Person(string name, int age)
        {
            Name = name;
            Age = age;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppVariableMemory
{
   publicclass BoxingManager
    {
        public void DemonstrateBoxingUnboxing()
        {
            Console.WriteLine("=== 裝箱拆箱演示 ===");

            // 裝箱（Boxing）：值類型 → 引用類型
            int value = 42;
            object boxedValue = value;  // 隱式裝箱，在堆上創(chuàng)建新對象

            Console.WriteLine($"原始值: {value}");
            Console.WriteLine($"裝箱后: {boxedValue}");
            Console.WriteLine($"類型對比: {value.GetType()} vs {boxedValue.GetType()}");

            // 拆箱（Unboxing）：引用類型 → 值類型
            int unboxedValue = (int)boxedValue;  // 顯式拆箱

            Console.WriteLine($"拆箱后: {unboxedValue}");

            // 裝箱后的對象是獨立的
            value = 100;
            Console.WriteLine($"修改原值后: value={value}, boxedValue={boxedValue}");

            // 演示性能影響
            DemonstratePerformanceImpact();
        }

        public void DemonstratePerformanceImpact()
        {
            Console.WriteLine("\n=== 裝箱拆箱性能影響 ===");

            constint iterations = 1000000;
            Stopwatch sw = new Stopwatch();

            // 測試1：無裝箱操作
            sw.Start();
            for (int i = 0; i < iterations; i++)
            {
                int temp = i;
                temp = temp + 1;  // 純值類型操作
            }
            sw.Stop();
            long withoutBoxing = sw.ElapsedMilliseconds;
            Console.WriteLine($"無裝箱操作耗時: {withoutBoxing} ms");

            // 測試2：頻繁裝箱操作
            sw.Restart();
            for (int i = 0; i < iterations; i++)
            {
                object boxed = i;      // 裝箱
                int unboxed = (int)boxed;  // 拆箱
            }
            sw.Stop();
            long withBoxing = sw.ElapsedMilliseconds;
            Console.WriteLine($"頻繁裝箱操作耗時: {withBoxing} ms");
            Console.WriteLine($"性能差異: {(double)withBoxing / withoutBoxing:F2}x");

            // 測試3：ArrayList vs List<T>
            CompareCollectionPerformance();
        }

        private void CompareCollectionPerformance()
        {
            Console.WriteLine("\n=== 集合裝箱性能對比 ===");

            constint count = 100000;
            Stopwatch sw = new Stopwatch();

            // ArrayList（會裝箱）
            sw.Start();
            ArrayList arrayList = new ArrayList(count);
            for (int i = 0; i < count; i++)
            {
                arrayList.Add(i);  // 裝箱：int → object
            }

            int sum1 = 0;
            foreach (object item in arrayList)
            {
                sum1 += (int)item;  // 拆箱：object → int
            }
            sw.Stop();
            long arrayListTime = sw.ElapsedMilliseconds;

            // List<int>（無裝箱）
            sw.Restart();
            List<int> list = new List<int>(count);
            for (int i = 0; i < count; i++)
            {
                list.Add(i);  // 無裝箱，直接存儲
            }

            int sum2 = 0;
            foreach (int item in list)
            {
                sum2 += item;  // 無拆箱，直接使用
            }
            sw.Stop();
            long listTime = sw.ElapsedMilliseconds;

            Console.WriteLine($"ArrayList耗時: {arrayListTime} ms (sum: {sum1})");
            Console.WriteLine($"List<int>耗時: {listTime} ms (sum: {sum2})");
            Console.WriteLine($"泛型集合性能提升: {(double)arrayListTime / listTime:F2}x");
        }

        public void DemonstrateCommonBoxingScenarios()
        {
            Console.WriteLine("\n=== 常見裝箱場景 ===");

            // 場景1：字符串格式化
            int number = 42;
            string result1 = string.Format("Number: {0}", number);  // 裝箱
            string result2 = $"Number: {number}";                   // C# 6.0+，編譯器優(yōu)化

            Console.WriteLine($"格式化結果: {result1}");

            // 場景2：方法參數(shù)
            ProcessObject(number);  // 隱式裝箱

            // 場景3：接口轉(zhuǎn)換
            IComparable comparable = number;  // 裝箱
            int comparisonResult = comparable.CompareTo(50);
            Console.WriteLine($"比較結果: {comparisonResult}");

            // 場景4：集合操作
            var hashSet = new HashSet<object>();
            hashSet.Add(1);      // 裝箱
            hashSet.Add(2.5);    // 裝箱
            hashSet.Add("text"); // 字符串，無裝箱

            Console.WriteLine($"HashSet元素數(shù)量: {hashSet.Count}");
        }

        private void ProcessObject(object obj)
        {
            Console.WriteLine($"接收到對象: {obj}, 類型: {obj.GetType()}");
        }

        public void DemonstrateOptimizationTechniques()
        {
            Console.WriteLine("\n=== 裝箱優(yōu)化技巧 ===");

            // 技巧1：使用泛型避免裝箱
            Console.WriteLine("1. 使用泛型集合:");
            var genericList = new List<int> { 1, 2, 3, 4, 5 };
            Console.WriteLine($"泛型集合元素: {string.Join(", ", genericList)}");

            // 技巧2：ToString()方法避免格式化裝箱
            Console.WriteLine("2. 使用ToString():");
            int value = 123;
            string formatted = "Value: " + value.ToString();  // 避免裝箱
            Console.WriteLine(formatted);

            // 技巧3：結構體實現(xiàn)接口時的優(yōu)化
            Console.WriteLine("3. 結構體接口實現(xiàn):");
            var point = new OptimizedPoint(10, 20);
            // 直接調(diào)用不會裝箱
            Console.WriteLine($"Point: {point}");

            // 但是接口引用會裝箱
            IFormattable formattable = point;  // 裝箱
            Console.WriteLine($"Through interface: {formattable}");
        }
    }

    // 優(yōu)化的結構體實現(xiàn)
    publicstruct OptimizedPoint : IFormattable
    {
        publicint X { get; }
        publicint Y { get; }

        public OptimizedPoint(int x, int y)
        {
            X = x;
            Y = y;
        }

        public override string ToString()
        {
            return $"({X}, {Y})";
        }

        public string ToString(string format, IFormatProvider formatProvider)
        {
            return ToString();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppVariableMemory
{
    publicclass MemoryOptimizer
    {
        public void DemonstrateGCGenerations()
        {
            Console.WriteLine("=== 垃圾回收代數(shù)演示 ===");

            // 顯示當前GC信息
            DisplayGCInfo("程序啟動時");

            // 創(chuàng)建大量短生命周期對象（第0代）
            CreateShortLivedObjects();
            DisplayGCInfo("創(chuàng)建短生命周期對象后");

            // 創(chuàng)建中等生命周期對象（可能進入第1代）
            var mediumLivedObjects = CreateMediumLivedObjects();
            GC.Collect();  // 強制回收，觀察代數(shù)變化
            DisplayGCInfo("創(chuàng)建中等生命周期對象并GC后");

            // 創(chuàng)建長生命周期對象（可能進入第2代）
            var longLivedObjects = CreateLongLivedObjects();

            // 多次GC觀察對象代數(shù)提升
            for (int i = 0; i < 3; i++)
            {
                GC.Collect();
                GC.WaitForPendingFinalizers();
                DisplayGCInfo($"第{i + 1}次完整GC后");
            }

            // 保持引用避免被回收
            Console.WriteLine($"保持引用: {mediumLivedObjects.Count} + {longLivedObjects.Count}");
        }

        private void CreateShortLivedObjects()
        {
            // 創(chuàng)建大量臨時對象
            for (int i = 0; i < 10000; i++)
            {
                var temp = new byte[1024];  // 1KB臨時數(shù)組
                var tempString = $"臨時字符串_{i}";
                var tempList = new List<int> { i, i + 1, i + 2 };
            }
            // 方法結束后，這些對象成為垃圾
        }

        private List<DataObject> CreateMediumLivedObjects()
        {
            var objects = new List<DataObject>();
            for (int i = 0; i < 1000; i++)
            {
                objects.Add(new DataObject($"中等對象_{i}", new byte[1024]));
            }
            return objects;
        }

        private List<LargeDataObject> CreateLongLivedObjects()
        {
            var objects = new List<LargeDataObject>();
            for (int i = 0; i < 100; i++)
            {
                objects.Add(new LargeDataObject($"長期對象_{i}", new byte[10240]));
            }
            return objects;
        }

        private void DisplayGCInfo(string stage)
        {
            Console.WriteLine($"\n--- {stage} ---");
            Console.WriteLine($"第0代回收次數(shù): {GC.CollectionCount(0)}");
            Console.WriteLine($"第1代回收次數(shù): {GC.CollectionCount(1)}");
            Console.WriteLine($"第2代回收次數(shù): {GC.CollectionCount(2)}");
            Console.WriteLine($"當前內(nèi)存使用: {GC.GetTotalMemory(false) / 1024} KB");
        }

        public void DemonstrateMemoryLeakPrevention()
        {
            Console.WriteLine("\n=== 內(nèi)存泄漏防范演示 ===");

            // 場景1：事件訂閱泄漏
            Console.WriteLine("1. 事件訂閱內(nèi)存泄漏:");
            DemonstrateEventLeakPrevention();

            // 場景2：大對象處理
            Console.WriteLine("\n2. 大對象內(nèi)存管理:");
            DemonstrateLargeObjectHandling();

            // 場景3：緩存管理
            Console.WriteLine("\n3. 緩存內(nèi)存管理:");
            DemonstrateCacheManagement();
        }

        private void DemonstrateEventLeakPrevention()
        {
            var publisher = new EventPublisher();
            var subscriber1 = new EventSubscriber("訂閱者1");
            var subscriber2 = new EventSubscriber("訂閱者2");

            // 訂閱事件
            publisher.SomeEvent += subscriber1.HandleEvent;
            publisher.SomeEvent += subscriber2.HandleEvent;

            // 觸發(fā)事件
            publisher.TriggerEvent("測試事件");

            // 重要：取消訂閱防止內(nèi)存泄漏
            publisher.SomeEvent -= subscriber1.HandleEvent;
            publisher.SomeEvent -= subscriber2.HandleEvent;

            Console.WriteLine("事件訂閱已清理，防止內(nèi)存泄漏");

            // 使用WeakReference的高級技巧
            DemonstrateWeakReference();
        }

        private void DemonstrateWeakReference()
        {
            Console.WriteLine("\n弱引用演示:");

            // 創(chuàng)建對象并建立弱引用
            var strongRef = new LargeDataObject("強引用對象", new byte[1024]);
            var weakRef = new WeakReference(strongRef);

            Console.WriteLine($"弱引用目標存在: {weakRef.IsAlive}");
            Console.WriteLine($"通過弱引用訪問: {((LargeDataObject)weakRef.Target)?.Name}");

            // 移除強引用
            strongRef = null;

            // 強制垃圾回收
            GC.Collect();
            GC.WaitForPendingFinalizers();

            Console.WriteLine($"GC后弱引用目標存在: {weakRef.IsAlive}");
            if (weakRef.IsAlive)
            {
                Console.WriteLine($"對象仍然存在: {((LargeDataObject)weakRef.Target)?.Name}");
            }
            else
            {
                Console.WriteLine("對象已被垃圾回收");
            }
        }

        private void DemonstrateLargeObjectHandling()
        {
            // 大對象堆(LOH)演示
            Console.WriteLine("創(chuàng)建大對象(>85KB):");

            long memoryBefore = GC.GetTotalMemory(false);

            // 創(chuàng)建大對象（>85KB會進入LOH）
            var largeArray = new byte[100 * 1024]; // 100KB

            long memoryAfter = GC.GetTotalMemory(false);

            Console.WriteLine($"大對象創(chuàng)建前內(nèi)存: {memoryBefore / 1024} KB");
            Console.WriteLine($"大對象創(chuàng)建后內(nèi)存: {memoryAfter / 1024} KB");
            Console.WriteLine($"內(nèi)存增長: {(memoryAfter - memoryBefore) / 1024} KB");

            // 大對象最佳實踐：及時釋放
            largeArray = null;
            GC.Collect();

            long memoryAfterGC = GC.GetTotalMemory(true);
            Console.WriteLine($"釋放后內(nèi)存: {memoryAfterGC / 1024} KB");
        }

        private void DemonstrateCacheManagement()
        {
            var cache = new MemoryEfficientCache<string, DataObject>();

            // 添加緩存項
            for (int i = 0; i < 1000; i++)
            {
                var key = $"key_{i}";
                var value = new DataObject($"緩存對象_{i}", new byte[512]);
                cache.Set(key, value);
            }

            Console.WriteLine($"緩存項數(shù)量: {cache.Count}");

            // 模擬內(nèi)存壓力，觸發(fā)緩存清理
            GC.Collect();
            Console.WriteLine($"GC后緩存項數(shù)量: {cache.Count}");

            // 訪問一些項以防止被清理
            for (int i = 0; i < 100; i++)
            {
                cache.Get($"key_{i}");
            }

            GC.Collect();
            Console.WriteLine($"訪問后GC緩存項數(shù)量: {cache.Count}");
        }
    }

    // 事件發(fā)布者
    publicclass EventPublisher
    {
        public event Action<string> SomeEvent;

        public void TriggerEvent(string message)
        {
            SomeEvent?.Invoke(message);
        }
    }

    // 事件訂閱者
    publicclass EventSubscriber
    {
        privatestring name;

        public EventSubscriber(string name)
        {
            this.name = name;
        }

        public void HandleEvent(string message)
        {
            Console.WriteLine($"{name} 收到事件: {message}");
        }
    }

    // 數(shù)據(jù)對象
    publicclass DataObject
    {
        publicstring Name { get; set; }
        public byte[] Data { get; set; }

        public DataObject(string name, byte[] data)
        {
            Name = name;
            Data = data;
        }
    }

    // 大數(shù)據(jù)對象
    publicclass LargeDataObject
    {
        publicstring Name { get; set; }
        public byte[] LargeData { get; set; }

        public LargeDataObject(string name, byte[] data)
        {
            Name = name;
            LargeData = data;
        }
    }

    // 內(nèi)存高效的緩存實現(xiàn)
    publicclass MemoryEfficientCache<TKey, TValue> where TValue :class
    {
        private readonly Dictionary<TKey, WeakReference> cache = new Dictionary<TKey, WeakReference>();

        public void Set(TKey key, TValue value)
        {
            cache[key] = new WeakReference(value);
        }

        public TValue Get(TKey key)
        {
            if (cache.TryGetValue(key, out var weakRef) && weakRef.IsAlive)
            {
                return (TValue)weakRef.Target;
            }

            // 清理死引用
            if (weakRef != null && !weakRef.IsAlive)
            {
                cache.Remove(key);
            }

            return null;
        }

        publicint Count
        {
            get
            {
                // 清理死引用并返回活躍數(shù)量
                var deadKeys = new List<TKey>();
                foreach (var kvp in cache)
                {
                    if (!kvp.Value.IsAlive)
                    {
                        deadKeys.Add(kvp.Key);
                    }
                }

                foreach (var key in deadKeys)
                {
                    cache.Remove(key);
                }

                return cache.Count;
            }
        }
    }
}

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppVariableMemory
{
    class PerformanceAnalyzer
    {
        public void RunComprehensiveAnalysis()
        {
            Console.WriteLine("=== C# 內(nèi)存性能綜合分析 ===");

            // 1. 基礎性能指標監(jiān)控
            MonitorBasicMetrics();

            // 2. 內(nèi)存分配模式分析
            AnalyzeAllocationPatterns();

            // 3. GC壓力測試
            StressTestGarbageCollection();

            // 4. 實戰(zhàn)優(yōu)化對比
            CompareOptimizationStrategies();
        }

        private void MonitorBasicMetrics()
        {
            Console.WriteLine("\n--- 基礎性能指標監(jiān)控 ---");

            var process = Process.GetCurrentProcess();

            Console.WriteLine($"進程ID: {process.Id}");
            Console.WriteLine($"工作集內(nèi)存: {process.WorkingSet64 / 1024 / 1024} MB");
            Console.WriteLine($"私有內(nèi)存: {process.PrivateMemorySize64 / 1024 / 1024} MB");
            Console.WriteLine($"虛擬內(nèi)存: {process.VirtualMemorySize64 / 1024 / 1024} MB");
            Console.WriteLine($"GC管理內(nèi)存: {GC.GetTotalMemory(false) / 1024 / 1024} MB");

            // CPU使用率監(jiān)控
            var startTime = DateTime.UtcNow;
            var startCpuUsage = process.TotalProcessorTime;

            // 執(zhí)行一些CPU密集操作
            Thread.Sleep(1000);

            var endTime = DateTime.UtcNow;
            var endCpuUsage = process.TotalProcessorTime;

            var cpuUsedMs = (endCpuUsage - startCpuUsage).TotalMilliseconds;
            var totalMsPassed = (endTime - startTime).TotalMilliseconds;
            var cpuUsageTotal = cpuUsedMs / (Environment.ProcessorCount * totalMsPassed);

            Console.WriteLine($"CPU使用率: {cpuUsageTotal:P}");
        }

        private void AnalyzeAllocationPatterns()
        {
            Console.WriteLine("\n--- 內(nèi)存分配模式分析 ---");

            // 模式1：頻繁小對象分配
            AnalyzeSmallObjectPattern();

            // 模式2：大對象分配
            AnalyzeLargeObjectPattern();

            // 模式3：集合擴容模式
            AnalyzeCollectionGrowthPattern();
        }

        private void AnalyzeSmallObjectPattern()
        {
            Console.WriteLine("\n小對象分配模式:");

            var sw = Stopwatch.StartNew();
            long memoryBefore = GC.GetTotalMemory(true);

            // 創(chuàng)建大量小對象
            var objects = new List<SmallObject>();
            for (int i = 0; i < 100000; i++)
            {
                objects.Add(new SmallObject { Id = i, Name = $"Object_{i}" });
            }

            sw.Stop();
            long memoryAfter = GC.GetTotalMemory(false);

            Console.WriteLine($"創(chuàng)建10萬個小對象耗時: {sw.ElapsedMilliseconds} ms");
            Console.WriteLine($"內(nèi)存增長: {(memoryAfter - memoryBefore) / 1024} KB");
            Console.WriteLine($"平均每對象內(nèi)存: {(memoryAfter - memoryBefore) / objects.Count} bytes");

            // 分析GC影響
            int gen0Before = GC.CollectionCount(0);
            int gen1Before = GC.CollectionCount(1);

            // 觸發(fā)更多分配
            for (int i = 0; i < 50000; i++)
            {
                objects.Add(new SmallObject { Id = i + 100000, Name = $"Extra_{i}" });
            }

            int gen0After = GC.CollectionCount(0);
            int gen1After = GC.CollectionCount(1);

            Console.WriteLine($"額外分配觸發(fā)GC - 第0代: {gen0After - gen0Before}次, 第1代: {gen1After - gen1Before}次");
        }

        private void AnalyzeLargeObjectPattern()
        {
            Console.WriteLine("\n大對象分配模式:");

            var sw = Stopwatch.StartNew();
            long memoryBefore = GC.GetTotalMemory(true);

            // 創(chuàng)建大對象（進入LOH）
            var largeObjects = new List<byte[]>();
            for (int i = 0; i < 100; i++)
            {
                largeObjects.Add(new byte[100 * 1024]); // 100KB each
            }

            sw.Stop();
            long memoryAfter = GC.GetTotalMemory(false);

            Console.WriteLine($"創(chuàng)建100個大對象(100KB)耗時: {sw.ElapsedMilliseconds} ms");
            Console.WriteLine($"內(nèi)存增長: {(memoryAfter - memoryBefore) / 1024} KB");

            // 檢查是否觸發(fā)了第2代GC
            int gen2Count = GC.CollectionCount(2);

            // 創(chuàng)建更多大對象
            for (int i = 0; i < 50; i++)
            {
                largeObjects.Add(new byte[200 * 1024]); // 200KB each
            }

            int gen2CountAfter = GC.CollectionCount(2);
            Console.WriteLine($"大對象分配觸發(fā)第2代GC: {gen2CountAfter - gen2Count}次");
        }

        private void AnalyzeCollectionGrowthPattern()
        {
            Console.WriteLine("\n集合擴容模式分析:");

            // 低效方式：未預設容量
            var sw = Stopwatch.StartNew();
            var inefficientList = new List<int>();
            for (int i = 0; i < 100000; i++)
            {
                inefficientList.Add(i);
            }
            sw.Stop();
            long inefficientTime = sw.ElapsedMilliseconds;

            // 高效方式：預設容量
            sw.Restart();
            var efficientList = new List<int>(100000);
            for (int i = 0; i < 100000; i++)
            {
                efficientList.Add(i);
            }
            sw.Stop();
            long efficientTime = sw.ElapsedMilliseconds;

            Console.WriteLine($"未預設容量耗時: {inefficientTime} ms");
            Console.WriteLine($"預設容量耗時: {efficientTime} ms");
            Console.WriteLine($"性能提升: {(double)inefficientTime / efficientTime:F2}x");
        }

        private void StressTestGarbageCollection()
        {
            Console.WriteLine("\n--- GC壓力測試 ---");

            var sw = Stopwatch.StartNew();

            // 記錄初始GC統(tǒng)計
            var initialStats = new GCStats();

            // 執(zhí)行內(nèi)存密集操作
            var results = Parallel.For(0, Environment.ProcessorCount, i =>
            {
                var localObjects = new List<object>();
                for (int j = 0; j < 50000; j++)
                {
                    localObjects.Add(new { Index = j, Data = new byte[1024] });

                    // 偶爾清理一部分
                    if (j % 1000 == 0)
                    {
                        localObjects.Clear();
                    }
                }
            });

            sw.Stop();

            // 記錄最終GC統(tǒng)計
            var finalStats = new GCStats();

            Console.WriteLine($"壓力測試耗時: {sw.ElapsedMilliseconds} ms");
            Console.WriteLine($"第0代GC次數(shù): {finalStats.Gen0Count - initialStats.Gen0Count}");
            Console.WriteLine($"第1代GC次數(shù): {finalStats.Gen1Count - initialStats.Gen1Count}");
            Console.WriteLine($"第2代GC次數(shù): {finalStats.Gen2Count - initialStats.Gen2Count}");
            Console.WriteLine($"內(nèi)存使用峰值: {finalStats.TotalMemory / 1024 / 1024} MB");
        }

        private void CompareOptimizationStrategies()
        {
            Console.WriteLine("\n--- 優(yōu)化策略對比 ---");

            // 策略1：對象池 vs 頻繁創(chuàng)建
            CompareObjectPooling();

            // 策略2：結構體 vs 類
            CompareStructVsClass();

            // 策略3：StringBuilder vs 字符串拼接
            CompareStringBuilding();
        }

        private void CompareObjectPooling()
        {
            Console.WriteLine("\n對象池優(yōu)化對比:");

            constint operations = 100000;

            // 頻繁創(chuàng)建對象
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < operations; i++)
            {
                var obj = new ReusableObject();
                obj.Process(i);
            }
            sw.Stop();
            long withoutPooling = sw.ElapsedMilliseconds;

            // 使用對象池
            var pool = new SimpleObjectPool<ReusableObject>(() => new ReusableObject());
            sw.Restart();
            for (int i = 0; i < operations; i++)
            {
                var obj = pool.Get();
                obj.Process(i);
                pool.Return(obj);
            }
            sw.Stop();
            long withPooling = sw.ElapsedMilliseconds;

            Console.WriteLine($"頻繁創(chuàng)建對象: {withoutPooling} ms");
            Console.WriteLine($"使用對象池: {withPooling} ms");
            Console.WriteLine($"性能提升: {(double)withoutPooling / withPooling:F2}x");
        }

        private void CompareStructVsClass()
        {
            Console.WriteLine("\n結構體vs類性能對比:");

            constint count = 1000000;

            // 使用結構體
            var sw = Stopwatch.StartNew();
            var structArray = new PointStruct[count];
            for (int i = 0; i < count; i++)
            {
                structArray[i] = new PointStruct(i, i + 1);
            }
            sw.Stop();
            long structTime = sw.ElapsedMilliseconds;

            // 使用類
            sw.Restart();
            var classArray = new PointClass[count];
            for (int i = 0; i < count; i++)
            {
                classArray[i] = new PointClass(i, i + 1);
            }
            sw.Stop();
            long classTime = sw.ElapsedMilliseconds;

            Console.WriteLine($"結構體數(shù)組創(chuàng)建: {structTime} ms");
            Console.WriteLine($"類數(shù)組創(chuàng)建: {classTime} ms");
            Console.WriteLine($"結構體性能優(yōu)勢: {(double)classTime / structTime:F2}x");
        }

        private void CompareStringBuilding()
        {
            Console.WriteLine("\n字符串構建性能對比:");

            constint iterations = 10000;

            // 字符串拼接
            var sw = Stopwatch.StartNew();
            string result1 = "";
            for (int i = 0; i < iterations; i++)
            {
                result1 += $"Item_{i}_";
            }
            sw.Stop();
            long concatenationTime = sw.ElapsedMilliseconds;

            // StringBuilder
            sw.Restart();
            var sb = new System.Text.StringBuilder();
            for (int i = 0; i < iterations; i++)
            {
                sb.Append($"Item_{i}_");
            }
            string result2 = sb.ToString();
            sw.Stop();
            long stringBuilderTime = sw.ElapsedMilliseconds;

            Console.WriteLine($"字符串拼接: {concatenationTime} ms");
            Console.WriteLine($"StringBuilder: {stringBuilderTime} ms");
            Console.WriteLine($"StringBuilder性能優(yōu)勢: {(double)concatenationTime / stringBuilderTime:F2}x");
        }
    }

    // 輔助類定義
    publicclass SmallObject
    {
        publicint Id { get; set; }
        publicstring Name { get; set; }
    }

    publicclass ReusableObject
    {
        publicint Value { get; set; }

        public void Process(int input)
        {
            Value = input * 2;
        }

        public void Reset()
        {
            Value = 0;
        }
    }

    publicstruct PointStruct
    {
        publicint X { get; }
        publicint Y { get; }

        public PointStruct(int x, int y)
        {
            X = x;
            Y = y;
        }
    }

    publicclass PointClass
    {
        publicint X { get; }
        publicint Y { get; }

        public PointClass(int x, int y)
        {
            X = x;
            Y = y;
        }
    }

    publicclass GCStats
    {
        publicint Gen0Count { get; }
        publicint Gen1Count { get; }
        publicint Gen2Count { get; }
        publiclong TotalMemory { get; }

        public GCStats()
        {
            Gen0Count = GC.CollectionCount(0);
            Gen1Count = GC.CollectionCount(1);
            Gen2Count = GC.CollectionCount(2);
            TotalMemory = GC.GetTotalMemory(false);
        }
    }

    // 簡單對象池實現(xiàn)
    publicclass SimpleObjectPool<T> where T :class
    {
        private readonly ConcurrentQueue<T> objects = new ConcurrentQueue<T>();
        private readonly Func<T> objectGenerator;

        public SimpleObjectPool(Func<T> objectGenerator)
        {
            this.objectGenerator = objectGenerator;
        }

        public T Get()
        {
            if (objects.TryDequeue(out T item))
            {
                return item;
            }
            return objectGenerator();
        }

        public void Return(T item)
        {
            if (item is ReusableObject reusable)
            {
                reusable.Reset();
            }
            objects.Enqueue(item);
        }
    }
}