Proper use of destructor c#

The destructor for a class is called when your object gets garbage collected. In a managed programming language like c# you do not have control over when the garbage collector will run and execute your destructor. Garbage collection is taken care of by the CLR (common language run time) when it sees that the object is no longer being referenced or used later in the program. In your example, considering the code

AutomatedTest test1 = new AutomatedTest(TestList._1DayTest); RunAutoTest(test1); 

After executing the RunAutoTest(test1), the 'test1' reference variable is no longer used and will be available for garbage collection. The actual garbage collection process however might not run immediately and there is no way you can ensure it to run at a specific time. If within your AutomatedTest class you are making use of resources like opening a FileStream etc , you would need to free up these resources once you are done using an object of that class. This can be done by having your class implement the IDisposable interface in the following manner

class AutomatedTest:IDisposable { public void Dispose() { //free up any resources } } 

Once your class implements IDisposable, you can use it by wrapping it's creation within an 'using' block

 for (int numTests = 0; numTests < 20; numTests++) { using (AutomatedTest test1 = new AutomatedTest(TestList._1DayTest)) { RunAutoTest(test1); } //as soon as code exits the 'using' block the dispose method on test1 would be called //this is something you cannot guarantee when implementing a destructor using (AutomatedTest test2 = new AutomatedTest(TestList._2DayTest)) { RunAutoTest(test2); } //dispose on test2 will be called here ///rest of code } 

FYI it is possible to implement the destructor in C# using ~ . The method of implementing IDisposable is preferable over creating a destructor

 class AutomatedTest { ~AutomatedTest() { //code will run only on garbage collection } } 

You won't be able to have control over when these objects get garbage collected. As Henk Holterman mentioned you might need to consider implimenting IDisposable, or use the IDisposable pattern. If you don't need to do this, I wouldn't worry using .Dispose() or a finalizer, ~AutomatedTest()

Assuming these test methods might take a while, you could say test1 = null; after you are done using it to let .NET know that this object reference is no longer in use, otherwise once it goes out of scope GC will clean things up.

Your best bet is the IDisposable pattern detailed here. But as others have pointed out, that's only necessary if your object holds onto some expensive resource, like a file handle, stream, DB object, etc. Everything else will just be collected by the GC. trust it.

I believe a fair rule for this is "If any of your objects handle unmanaged resources, or implement IDisposable, you need to dispose them." I don't see anything unmanaged in the code you posted, so you probably don't need to worry. However, there is clearly some code we cannot see, so I cannot be sure.

Please read this MSDN Article for an explanation of proper disposing.

The "destructor" or Finalizer as it's typically called, will not get called until the object is garbage collected.

So if you have resources you need to free up, it's best to implement IDisposable.

One of the ways of handling the disposal of expensive objects is to implement the IDisposable interface and implement the Dispose and Finalize method. This is the recommended pattern when your class has dependencies on unmanaged code and is responsible for cleaning them up. More details here