Is IDisposable interface just used for standardization ?

Kg P

Hi, I might be thinking wrong, please correct if I am wrong.

To cleanup memory (Specially for unmanaged resources), we implement IDisposable interface and impelement Dispose method in which we write our custom logic to free memory.

So, my question is that as we are writing our own logic to free memory, can't we do same in any public method of our cass ?

Means actually we don't need IDisposable and Dispose method for this ? May be we use these for this kind of reasons-

1. Just for standardization that they are same across all applications

2. Once we say class implements IDisposable interface, we make sure that we don't miss dispose method implementation as we'll get error

if we forgot to give implementation for dispose method.

OR there is some other reason for using IDisposable. Please share your thoughts.

For example-

public class MyClass{

public void ReleaseMemory(){

ReleaseMemory(true);

GC.SuppressFinalize();

}

public void ReleaseMemory(bool releasing){

//all memory cleanup logic

}

Does this solve the purpose without implementing IDisposable interface ??

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mantu R8y ago
IDisposable interface along with USING block helps us to call the base class dispose method. In other words suppose we are using a Framework class to create a child class on the client side. And the Framework class creates some unmanaged resources.

When we create an instance of child block inside USING block then the base class dipose method is automatically called to free up unmanaged resouce at base class level.

If we don't use IDisposable interface in Framework class and instead expose a public method to FreeUpMemory then the Client side child class developer might forget to call the base class FreeUpMemory method resulting into memory leak.
class Program
{
static void Main(string[] args)
{
using (Framework s = new Client())
{
s.Method1();
}//At the end of execution of using block, the Framework class dispose method will be called.
}
}
public class Framework : IDisposable
{
public void Method1()
{
//creating some unmanaged resources
}
public void Dispose()
{
Console.WriteLine("Clean up unmanaged resources of Framework Object");
}
public void FreeUpMemory()//CHILD CLASS DEVELOPER MAY FORGET TO CALL THIS METHOD.
{
Console.WriteLine("Clean up unmanaged resources of Framework Object");
}
}
public class Client : Framework
{
public void Method1()
{
}
}
Ehsan Sajjad9y ago
yes it sets a standard, so that any type which uses unmanaged resources or wants it's resources to be disposed will implement IDisposable interface, and caller will be able to instantiate that class implementing IDisposable vis using block which itself make sures that as soon as control goes out of it, the resources and memory is released reserved by that object, as using block gets replaced in to try, catch finally block after compilation, it is just a syntactic easiness for developers