وقتی شما یک برنامه می‌نویسید، مثلاً در C#، برنامه‌تان نیاز به فضایی در حافظه (RAM) دارد تا داده‌ها رو ذخیره کند.
دات‌نت دو نوع حافظه اصلی دارد:

• Stack: برای داده‌های کوچک و موقت (مثل متغیرهای محلی)
• Heap: برای داده‌های بزرگ و طولانی‌مدت (مثل اشیا و آرایه‌ها)

                
                    int number = 10; // روی Stack ذخیره می‌شود
                    Person person = new Person(); // شیء جدید در Heap ساخته می‌شود
                
            

وقتی شما یک شیء جدید در Heap می‌سازید، حافظه اختصاص داده می‌شود. اما اگر این شیء دیگر مورد نیاز نباشد، باید حافظه آزاد شود. اینجا GC وارد عمل می‌شود!
GC مثل یک خدمتکار هوشمند است که:

• حافظه‌ی استفاده‌نشده را خودکار آزاد می‌کند.
• از Memory Leak (نشت حافظه) جلوگیری می‌کند.
• برنامه‌نویس را درگیر مدیریت دستی حافظه نمی‌کند (برخلاف زبان‌هایی مثل C++).

GC در سه مرحله اصلی کار می‌کند:

• Mark (علامت‌گذاری)
  • GC تمام اشیاء موجود در Heap را بررسی می‌کند.
  • هر شیء که در حال استفاده است (مثلاً توسط متغیرهای فعال ارجاع داده شده) را Mark می‌کند.
  • اشیاء بدون ارجاع (Unreferenced) به عنوان زباله در نظر گرفته می‌شوند.
• Sweep (حذف زباله‌ها)
  • اشیاء بدون استفاده (Unreferenced) از حافظه پاک می‌شوند.
• Compact (فشرده‌سازی)
  • حافظه‌ی آزاد شده را منظم می‌کند تا فضای خالی به هم پیوسته باشد.

برای بهینه‌سازی، GC از سه نسل (Generation) استفاده می‌کند:

• Gen 0: اشیاء جدید و موقت (مثل متغیرهای داخل یک متد).
• Gen 1: اشیایی که از Gen 0 جان سالم به در برده‌اند.
• Gen 2: اشیاء قدیمی و طولانی‌مدت (مثل Singletonها).

✅ هرچه نسل بالاتر باشد، دفعات پاک‌سازی کمتر است (چون احتمالاً مهم هستند).
✅ Gen 0 بیشترین پاک‌سازی را دارد (چون اشیاء موقت زیادی دارد).

• دیگر نیازی به delete یا free نیست (برخلاف C++).
• حافظه به‌صورت خودکار مدیریت می‌شود.
• از Memory Leak جلوگیری می‌کند.

اما یک نکته:
⚠️ GC همیشه فوراً حافظه را آزاد نمی‌کند (مگر وقتی واقعاً نیاز باشد یا حافظه کم شود).

                
                    void CreateObjects()
                    {
                        // شیء جدید در هیپ ساخته می‌شود
                        Person person1 = new Person(); 
                        
                        // ارجاع جدید به همان شیء
                        Person person2 = person1;
                        
                        // حالا person1 را null می‌کنیم، اما شیء هنوز در حافظه است (چون person2 ارجاع دارد)
                        person1 = null;
                        
                        // حالا person2 هم null می‌شود، شیء دیگر ارجاعی ندارد
                        person2 = null;
                        
                        // حالا GC می‌تواند این شیء را پاک کند (البته نه لزوماً بلافاصله!)
                    }
                
            

• وقتی حافظه هیپ پر شود.
• وقتی برنامه در حالت Idle (بیکار) باشد.
• وقتی به صورت دستی فراخوانی شود (GC.Collect).

⚠️ استفاده از GC.Collect معمولاً توصیه نمی‌شود، مگر در موارد خاص!

• Managed Resources: اشیایی که دات‌نت مدیریت می‌کند (مثل List<>، string، کلاس‌های معمولی).
  • اینها را GC خودکار پاک می‌کند و نیازی به کار خاصی ندارید.
• Unmanaged Resources: منابعی که خارج از کنترل دات‌نت هستند (مثل فایل‌ها، دیتابیس اتصالات، Socketها).
  • اینها باید دستی آزاد شوند، در غیر این صورت باعث نشت حافظه (Memory Leak) می‌شوند.

وقتی از منابع غیرمدیریت‌شده استفاده می‌کنید، باید حتماً آن‌ها را بسته (Release) کنید، وگرنه:
❌ حافظه مصرف شده آزاد نمی‌شود (Memory Leak).
❌ ممکن است فایل‌ها قفل شوند و برنامه‌های دیگر نتوانند از آن‌ها استفاده کنند.
❌ اتصالات دیتابیس باز می‌مانند و پس از مدتی سرور دیتابیس از کار می‌افتد!
✅ راه‌حل: استفاده از IDisposable و الگوی Dispose.

این یک اینترفیس است که فقط یک متد دارد:

                
                    public interface IDisposable
                    {
                        void Dispose();
                    }
                
            

هر کلاسی که این اینترفیس را پیاده‌سازی کند، باید منابع غیرمدیریت‌شده را در Dispose آزاد کند.
مثال: کلاس FileStream (استفاده از Dispose)

                
                    using (FileStream file = File.Open("test.txt", FileMode.Open))
                    {
                        // کار با فایل
                    } // اینجا به طور خودکار file.Dispose() فراخوانی می‌شود، حتی اگر خطایی رخ دهد!
                
            

یا به صورت دستی:

                
                    FileStream file = null;
                    try
                    {
                        file = File.Open("test.txt", FileMode.Open);
                        // کار با فایل
                    }
                    finally
                    {
                        file?.Dispose(); // مطمئن می‌شویم فایل حتما بسته می‌شود
                    }
                
            

وقتی شما کدی مثل این می‌نویسید:

                
                    using (var resource = new SomeDisposableResource())
                    {
                        // کار با resource
                    } // اینجا Dispose() به صورت خودکار فراخوانی می‌شود                    
                
            

کامپایلر C# آن را به این شکل تبدیل می‌کند:

                
                    var resource = new SomeDisposableResource();
                    try
                    {
                        // کار با resource
                    }
                    finally
                    {
                        resource.Dispose(); // حتی اگر خطا رخ دهد، Dispose فراخوانی می‌شود
                    }                
                
            

نکات کلیدی درباره using:

• فقط برای اشیاء IDisposable کار می‌کند (مثل FileStream, SqlConnection, StreamReader).
• حتی اگر داخل بلوک using خطا (Exception) رخ دهد، Dispose() فراخوانی می‌شود.
• معادل try-finally است، اما کد را تمیزتر و خوانا‌تر می‌کند.

مثال: استفاده با چند IDisposable

                
                    using (var file = File.OpenRead("data.txt"))
                    using (var reader = new StreamReader(file))
                    {
                        string content = reader.ReadToEnd();
                    } // اول reader.Dispose() و سپس file.Dispose() فراخوانی می‌شود