Destructors and the Dispose Pattern in CSharp

بنقول عليه الهادمين او اللي بيكسروا اللي هما الـ Destructors

What are Destructors in C#?

الـ Destructors اللي بيتسموا برضه Finalizers في C# بيُستخدموا عشان ننظف الكلاس بتاعنا لما class instance معين بيتجمع في الـ garbage collector.

الـ Destructor هو برضه method خاصة موجودة في الـ class، زي الـ constructor بالظبط، وليها نفس اسم الـ class لكن قبلها علامة ~ (tilde).

• الـ Constructor في C# بيتندهله صراحةً (Explicitly) لما بنعمل object من الـ class.
• الـ Destructor في C# بيتندهله ضمنيًا (Implicitly) لما الـ object بيتدمر.

عشان نفرق بين الـ Constructor والـ Destructor بما إن ليهم نفس الاسم، بنستخدم علامة الـ (~) قبل اسم الـ destructor method. الـ syntax بتاعه كالتالي:

class MyClass
{
    // Destructor
    ~MyClass()
    {
        // Cleanup code
    }
}

ملحوظة: أهم نقطة لازم تفتكرها هي إن الـ destructor method مينفعش يكون ليها أي parameters ولا ينفع نطبق عليها أي modifiers. وبما إنها من غير parameters، فمش ممكن نعملها overloading.

When is a Destructor method Called in C#?

الـ Destructor method بيتندهلها تلقائيًا بواسطة الـ garbage collector لما الـ object بتاع الـ class بيتدمر. فالنقطة اللي لازم تفتكرها هي إن الـ destructors بتتنده تلقائيًا.

When will the Object of a Class get Destroyed in C#?

الـ object بتاع الـ class في C# بيتدمر وبيتشال من خلال الـ garbage collector في أي حالة من الحالات دي:

1. في نهاية تنفيذ البرنامج، كل object مرتبط بالبرنامج بيتدمر.
2. لما الـ garbage collector يشتغل بشكل ضمني في نص تنفيذ البرنامج لو الذاكرة اتملت، وساعتها بيحدد الـ objects غير المستخدمة ويدمرها.
3. لما المبرمج يستدعي الـ garbage collector بشكل صريح في نص تنفيذ البرنامج باستخدام GC.Collect()، وساعتها أي objects غير مستخدمة بتدمر.

Example to Understand Destructors in C#

using System;
namespace DestructorExample
{
    class DestructorDemo
    {
        public DestructorDemo()
        {
            Console.WriteLine("Constructor Object Created");
        }
        ~DestructorDemo()
        {
            string type = GetType().Name;
            Console.WriteLine($"Object {type} is Destroyed");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DestructorDemo obj1 = new DestructorDemo();
            DestructorDemo obj2 = new DestructorDemo();
            // Making obj1 eligible for Garbage Collection
            obj1 = null;
            Console.ReadKey();
        }
    }
}

في المثال دا، عملنا class اسمه DestructorDemo فيه constructor و destructor. بعدين جوه الـ Main method، عملنا اتنين instances من الـ class ده وخلينا قيمة obj1 بـ null عشان يبقى مؤهل للـ garbage collection.

لما تشغل الكود ده، هتلاقي الناتج كده:

Constructor Object Created
Constructor Object Created

هتلاحظ إن الجمل اللي جوه الـ destructor مطبعتش. ممكن تفتكر إن الـ destructor متنفذش حتى بعد ما خلينا obj1 بـ null. ده مش صح. النقطة اللي لازم تفتكرها هي إن الـ destructor بيتندهله ضمنيًا بواسطة الـ garbage collector، وإحنا مش بنقدر نتوقع امتى هيندهله. عشان كده مش بتشوف جمل الطباعة في الناتج.

لو عايز، تقدر تستدعي الـ garbage collector بشكل صريح عشان يدمر الـ objects غير المستخدمة. عشان نعمل كده، بنستخدم GC.Collect().

// ... inside Main method
obj1 = null;
GC.Collect(); // Force garbage collection
Console.ReadKey();

Output:

Constructor Object Created
Constructor Object Created
Object DestructorDemo is Destroyed

دلوقتي تقدر تشوف إن الـ Destructor اتنفذ مرة واحدة. ده لأننا خلينا قيمة obj1 بس بـ null. لو خلينا الاتنين objects بـ null، الـ destructor هيتنفذ مرة لكل واحد.

// ... inside Main method
obj1 = null;
obj2 = null;
GC.Collect();
Console.ReadKey();

Output:

Constructor Object Created
Constructor Object Created
Object DestructorDemo is Destroyed
Object DestructorDemo is Destroyed

Can you prove the destructor method is Implicitly called by Garbage Collector?

مثال بسيط

using System;
namespace DestructorExample
{
    class DestructorDemo
    {
        public DestructorDemo()
        {
            Console.WriteLine("DestructorDemo Object Created");
        }
        ~DestructorDemo()
        {
            Console.WriteLine("DestructorDemo Object Destroyed");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main Method Execution Started");
            DestructorDemo obj1 = new DestructorDemo();
            
            obj1 = null;
            GC.Collect();
            Console.WriteLine("Some Statement Executed Inside Main Method");
            obj1 = null; // Redundant, already null
            GC.Collect();
            Console.WriteLine("Some More Statement Executed Inside Main Method");
            GC.Collect();
            Console.WriteLine("Main Method Execution End");
            Console.ReadKey();
        }
    }
}

جوه الـ Main method، عملنا instance وبعدين خليناه null واستدعينا GC.Collect() تلات مرات. لاحظ الـ destructor اتنفذ كام مرة وامتى.

Output:

Main Method Execution Started
DestructorDemo Object Created
DestructorDemo Object Destroyed
Some Statement Executed Inside Main Method
Some More Statement Executed Inside Main Method
Main Method Execution End

الـ destructor اتنفذ مرة واحدة بس، بعد أول مرة استدعينا فيها GC.Collect(). وده بيثبت إن الـ GC هو اللي بيدمره لما بيلاقيه غير مستخدم، ومش بيتأثر بالـ Calles الكتير للـ Collect.

Points to Remember while working with Destructors in C#

• الـ Point 1: الـ Destructors (أو Finalizers) مينفعش تتعرف في structs. بتستخدم بس مع الـ classes.
• الـ Point 2: في الـ class الواحد، نقدر نعرّف Destructor واحد بس. يعني مش ممكن نعملهم overloading.
• الـ Point 3: الـ Destructors مينفعش نستدعيها صراحةً. بيتندهلها تلقائيًا بواسطة الـ garbage collector. أقصى حاجة نقدر نعملها هي إننا نطلب من الـ GC ينفذها عن طريق GC.Collect().
• الـ Point 4: الـ Destructor مش بياخد أي modifiers ولا أي parameters.

How Destructors are Implemented in C#?

لما بتكتب destructor في C# بالشكل ده:

~Sample()
{
    // ...
}

الـ compiler بيترجم ده ضمنيًا لـ override للـ Finalize method اللي موجودة في Object class الأساسي. الكود بتاعك بيتحط جوه try...finally بلوك.

protected override void Finalize()
{
    try
    {
        // Your destructor code goes here
    }
    finally
    {
        base.Finalize(); // Calls the parent's Finalize method
    }
}

التصميم ده معناه إن الـ Finalize method بيتندهلها (recursively) لكل الـ instances في سلسلة الوراثة، من أكتر class مشتق (most-derived) لأقل واحد (least-derived). خلينا نفهم ده بمثال.

في المثال اللي تحت، عندنا تلاتة classes بيعملوا سلسلة وراثة. First هو الـ base، و Second بيورث من First، و Third بيورث من Second. والتلاتة فيهم destructors.

using System;
namespace DestructorExample
{
    public class First { ~First() { Console.WriteLine("Destructor of First Called"); } }
    public class Second : First { ~Second() { Console.WriteLine("Destructor of Second Called"); } }
    public class Third : Second { ~Third() { Console.WriteLine("Destructor of Third Called"); } }
 
    class Program
    {
        static void Main(string[] args)
        {
            Third obj = new Third();
            obj = null;
            GC.Collect();
            Console.ReadKey();
        }
    }
}

graph TD
    A[First] --> B[Second]
    B --> C[Third]
    subgraph Destruction Order
        direction BT
        D[First Destroyed] --> E[Second Destroyed]
        E --> F[Third Destroyed]
    end

Output:

Destructor of Third Called
Destructor of Second Called
Destructor of First Called

ملحوظة 1: الـ Destructors الفاضية المفروض منتستخدمهاش. لما class يكون فيه destructor، بيدخل في Finalize queue. الـ queue ده هو اللي الـ garbage collector بيتعامل معاه. وجود destructors غير ضرورية بيسبب أداء مش كويس.

ملحوظة 2: كمطورين، معندناش تحكم في امتى الـ destructor بيتندهله. الـ GC هو اللي بيقرر. ممكن نجبره يشتغل باستخدام GC.Collect، لكن في معظم الأوقات المفروض نتجنب ده لأنه ممكن يأثر على الأداء.

When to use Destructor in C#?

ممكن تسأل نفسك، لو Memory Management بتتم تلقائيًا، امتى بنحتاج نستخدم Destructor؟ بشكل عام، كمطورين C#.NET، مش محتاجين نقلق أوي من Memory Management.

لكن، لما التطبيق بتاعنا بيتعامل مع unmanaged resources (موارد غير مُدارة)، زي Files، وNetwork، المفروض نستخدم destructor عشان نفضي الميموري للموارد دي.

using System;
namespace FileHandlingDemo
{
    public class UnmanagedResource
    {
        public UnmanagedResource()
        {
            // Creating Unmanaged Resources  
            Console.WriteLine("Unmanaged Resource Created");
        }
        ~UnmanagedResource()
        {
            // Clean up Unmanaged Resources  
            Console.WriteLine("Unmanaged Resource Destroyed");
        }
    }
    class Program
    {
        static void Main()
        {
            UnmanagedResource resource = new UnmanagedResource();
            Console.WriteLine("Using Unmanaged Resource");
            resource = null;
            GC.Collect();
            
            Console.ReadKey();
        }
    }
}

Output:

Unmanaged Resource Created
Using Unmanaged Resource
Unmanaged Resource Destroyed

Explicit Release of Resources using Dispose Pattern in C#

لو تطبيقك بيستخدم resource خارجي تقيل، بينصح بإنك توفر طريقة صريحة عشان تفضيها او تقفلها الـ resource ده قبل ما الـ garbage collector يفضيها هو الـ object.

عشان نعمل كده، بنطبق Dispose method من الـ IDisposable interface. الـ class بتاعنا بيورث من الـ interface ده وبنوفر تنفيذ للـ Dispose method.

لما بتعمل Implement Interface with Dispose Pattern، هتلاقي الكود ده اتعملك:

using System;
public class UnmanagedResource : IDisposable
{
    #region IDisposable Support
    private bool disposedValue = false; // To detect redundant calls
    protected virtual void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                // TODO: dispose managed state (managed objects).
            }
            // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
            // TODO: set large fields to null.
            disposedValue = true;
        }
    }
    // ~UnmanagedResource() {
    //   Dispose(false);
    // }
    public void Dispose()
    {
        Dispose(true);
        // GC.SuppressFinalize(this);
    }
    #endregion
}

Understanding Dispose Pattern in C#

• الـ disposedValue: هو variable عشان نكتشف الاستدعاءات المتكررة.
• الـ Dispose(bool disposing): هنا بنكتب الـ logic الفعلي عشان نعمل Destroy الموارد الـ managed والـ unmanaged.
• الـ ~UnmanagedResource() (الـ Finalizer): ده بيكون كود احتياطي. لو عايز ت Destroy الموارد من خلاله، بتشيل الكومنت وتستدعي Dispose(false).
• الـ Dispose(): دي الـ method اللي بنستدعيها من الكود بتاعنا عشان ننضف Resources. بتعمل Call لـ Dispose(true)، ولو فيه finalizer، بتعمل Call لـ GC.SuppressFinalize(this) عشان تقول للـ GC يتجاهل الـ destructor.

الـ dispose pattern ده بيحسن أداء التطبيق بشكل كبير. وحتى مع التحكم الصريح ده، الـ finalizer بيبقى كضمان لتنظيف الموارد لو حصل وفشل استدعاء الـ Dispose method.

خلينا نشوف الناتج.

using System;
namespace DestructorDemo
{
    public class UnmanagedResource : IDisposable
    {
        #region IDisposable Support
        private bool disposedValue = false;
        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    Console.WriteLine("Managed Resources Destroyed by Dispose Method");
                }
                Console.WriteLine("Unmanaged Resources Destroyed by Dispose Method");
                disposedValue = true;
            }
            else
            {
                Console.WriteLine("Resources are Already Destroyed by Dispose Method");
            }
        }
        ~UnmanagedResource()
        {
            Console.WriteLine("Request Comes to Destructor to Destroy the Resources");
            Dispose(false);
        }
        public void Dispose()
        {
            Console.WriteLine("Request Comes to Dispose Method to Destroy the Resources");
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }
    class Program
    {
        static void Main()
        {
            UnmanagedResource resource = null;
            try
            {
                resource = new UnmanagedResource();
                Console.WriteLine("Using Resources");
            }
            finally
            {
                if (resource != null)
                {
                    Console.WriteLine("Calling Dispose Method to Destroy Resources");
                    resource.Dispose();
                }
            }
            Console.WriteLine("\nTrying to Call the Dispose Method Again To Destroy Resources");
            resource.Dispose();
            Console.ReadKey();
        }
    }
}

Output:

Using Resources
Calling Dispose Method to Destroy Resources
Request Comes to Dispose Method to Destroy the Resources
Managed Resources Destroyed by Dispose Method
Unmanaged Resources Destroyed by Dispose Method

Trying to Call the Dispose Method Again To Destroy Resources
Resources are Already Destroyed by Dispose Method