Csharp/C Sharp/Class Interface/Destructor

Demonstrate a destructor

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/
// Demonstrate a destructor. 
 
using System; 
 
class Destruct {  
  public int x;  
  
  public Destruct(int i) {  
    x = i;  
  }    
 
  // called when object is recycled 
  ~Destruct() { 
    Console.WriteLine("Destructing " + x); 
  } 
   
  // generates an object that is immediately destroyed 
  public void generator(int i) { 
    Destruct o = new Destruct(i); 
  } 
 
}    
    
public class DestructDemo1 {    
  public static void Main() {    
    int count; 
 
    Destruct ob = new Destruct(0); 
 
    /* Now, generate a large number of objects.  At 
       some point, garbage collection will occur.  
       Note: you might need to increase the number 
       of objects generated in order to force 
       garbage collection. */ 
 
    for(count=1; count < 100000; count++) 
      ob.generator(count);  
 
    Console.WriteLine("Done"); 
  }    
}

Finalizable Disposable Class

 
using System;
using System.Collections.Generic;
using System.Text;
class Program {
    static void Main(string[] args) {
        using (MyResourceWrapper rw = new MyResourceWrapper()) {
        }
        MyResourceWrapper rw2 = new MyResourceWrapper();
        for (int i = 0; i < 10; i++)
            rw2.Dispose();
    }
}
public class MyResourceWrapper : IDisposable {
    public void Dispose() {
        Console.WriteLine("In Dispose() method!");
    }
}

force the GC to invoke Finalize() for finalizable objects created in this AppDomain.

 
using System;
using System.Collections.Generic;
using System.Text;
public class MyResourceWrapper {
    ~MyResourceWrapper() {
        Console.Beep();
    }
}
class Program {
    static void Main(string[] args) {
        MyResourceWrapper rw = new MyResourceWrapper();
    }
}

Illustrates a destructor

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
  Example5_14.cs illustrates a destructor
*/

// declare the Car class
class Car
{
  // define the destructor
  ~Car()
  {
    System.Console.WriteLine("In ~Car() destructor");
    // do any cleaning up here
  }
}

public class Example5_14
{
  public static void Main()
  {
    // create a Car object
    Car myCar = new Car();
    System.Console.WriteLine("At the end of Main()");
  }
}

Shows that stack unwinding in C# does not necessarily call destructors

/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa
Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
// Unwind.cs -- Shows that stack unwinding in C# does not necessarily call
//              destructors.
//              Compile this program with the following command line:
//                  C:>csc Unwind.cs
//
namespace nsStack
{
    using System;
    using System.IO;
    
    public class Unwind
    {
        static public void Main ()
        {
            Unwind main = new Unwind();
            // Set up the try ... catch block
            try
            {
                main.TestStack ();
            }
            catch (FileNotFoundException e)
            {
                // Show the contents of the Message string in each class object
                if (clsFirst.Message == null)
                     Console.WriteLine ("First message is null");
                else
                     Console.WriteLine (clsFirst.Message);
                if (clsFirst.Message == null)
                     Console.WriteLine ("Second message is null");
                else
                     Console.WriteLine (clsSecond.Message);
                if (clsFirst.Message == null)
                     Console.WriteLine ("Third message is null");
                else
                     Console.WriteLine (clsThird.Message);
                // Show the exception object message
                Console.WriteLine (e.Message);
            }
        }
        void TestStack ()
        {
            // Create a new clsFirst object and call a method in it
            clsFirst first = new clsFirst ();
            first.FirstFunc();
        }
    }
    class clsFirst
    {
        ~clsFirst ()
        {
            Message = "clsFirst destructor called";
        }
        static public string Message = null;
        public void FirstFunc()
        {
            // Create a new clsSecond object and call a method in it
            clsSecond second = new clsSecond();
            second.SecondFunc ();
        }
    }
    class clsSecond {
        ~clsSecond () {
            Message = "clsSecond destructor called";
        }
        static public string Message = null;
        public void SecondFunc()
        {
            // Create a new clsThird object and call a method in it
            clsThird third = new clsThird();
            third.ThirdFunc ();
        }
    }
    class clsThird
    {
        ~clsThird () {
            Message = "clsThird destructor called";
        }
        static public string Message = null;
        public void ThirdFunc() {
            ThrowException ();
        }
        // By the time the program gets here, it is five method calls deep.
        // Throw an exception to force a stack unwind.
        private void ThrowException () {
            throw (new FileNotFoundException ());
        }
    }
}

the destructors are called bottom-up, which confirms the sequencing of destructors.

 
using System;

public class Starter {
    public static void Main() {
        XClass obj = new XClass();
    }
}
public class MyClass {
    ~MyClass() {
        Console.WriteLine("MyClass destructor");
    }
}
public class YClass : MyClass {
    ~YClass() {
        Console.WriteLine("YClass destructor");
    }
}
public class XClass : YClass {
    ~XClass() {
        Console.WriteLine("XClass destructor");
    }
}