Develop Reference

Why using Dispose as a normal method is bad?

Trying to figure it out. Someone told me
Dispose is not just a method - it's equivalent to a destructor in other languages.
Ok. Msdn is also very loud about this.
But then
class Test : IDisposable
{
public string Property { get; set; } = "Test";
public void Dispose() => Console.WriteLine("Disposed, very scary");
}
class Program
{
static void Main(string[] args)
{
var test = new Test();
test.Dispose();
test.Property = "123"; // but it's disposed OMG! do not do this!
test.Dispose();
using (var another = new Test())
for (int i = 0; i < 10; i++)
{
another.Dispose();
GC.Collect(); // or what should I call to make it crash?
}
Console.ReadKey();
}
}
And there are no problems.
What I think about Dispose:
it's a normal public method;
IDisposable is useful in conjunction with using to automatically call Dispose, nothing more;
it's totally fine to put into dispose any code an call it internally at any time if object state properly maintained.
Correct me if I am wrong.
P.S: Downvote means "question is bad/not useful/has problem". If you simply disagree with my thoughts - post comment or answer. It will be useful for people who think as I do right now (because I am wrong? then prove it)

Dispose is just a method, you can call it just like any other method. It is always exposed through the IDisposable interface (yes, obviously you can name a method Dispose without implementing IDisposable, don't do that!).
However, calling it manually is sometimes a code smell, smell of code that should probably be using using instead. By "manually" here I mean calling Dispose outside of the implementation of another Dispose.
Calling it twice should also be safe and is documented:
If an object's Dispose method is called more than once, the object must ignore all calls after the first one. The object must not throw an exception if its Dispose method is called multiple times. Instance methods other than Dispose can throw an ObjectDisposedException when resources are already disposed.
(my emphasis)
Should you be calling Dispose twice? No!. That is also a code smell of code that no longer has control of what it has done and what it has left to do and ends up doing things "just to be sure". Don't do that either!
So if you write code correctly, sure you can call Dispose manually.

You're right, Dispose is just another method, belonging to IDisposable. It just has the added benefit of being able to be automatically called when a using() scope ends - it is not equivalent to a destructor and whoever told you that doesn't truly understand what they're saying.
I'd always use a using() block where possible, but if you're careful you can manually call Dispose instead and it will have the same effect.

Visual Studio 2015 offers up (finally) a suggested pattern for implementation of IDisposable which matches the guidelines.
This is the stub that VS creates for you when selecting to implement the disposable pattern. The TODOs guide us through the implementation.
class Disposable : 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;
}
}
// TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
// ~Disposable() {
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
// Dispose(false);
// }
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
// TODO: uncomment the following line if the finalizer is overridden above.
// GC.SuppressFinalize(this);
}
#endregion
}
Note the use of a flag to indicate if the Dispose has already been called. This flag can be used to throw ObjectDisposedException instances on method calls and properties across the classes implementation.
The intention of Dispose has always been to clean up unmanaged resources. However, the syntactic sugar of the using keyword (requires an IDisposable) lets you create really tidy 'context' pattern classes for managing resource access, even if there are no unmanaged resources used.
As usual, document the usage and the intentions clearly and you can't go wrong but please avoid methods called 'Dispose' if you don't implement the interface.

There is a critical difference between Dispose in .NET versus destructors in other languages: if one has a pointer to an object in another language and the object is deleted, one will have an invalid pointer and there is no way to do anything with it, including determine whether it is still valid, without invoking Undefined Behavior. By contrast, in .NET if one has a reference to an object which gets Disposed, the reference will continue to be a valid reference to the object in question. The object will likely refuse to do much because it's been disposed, but such refusal is affirmatively generated by the object itself. No Undefined Behavior involved.
On the flip side, when a destructor is invoked in other languages like C++ an object can be certain that no valid pointers exist to it anymore, but that is not true of Dispose. Consequently, code should avoid pooling public-facing objects and instead have every request for a new object return a new object (which may be a wrapper to a pooled object). If no reference to the pooled object exists outside the wrapper, and Dispose invalidates that reference before returning the object to the pool, then a future object request can be satisfied by encapsulating the pooled object in a new wrapper which will again hold the only reference to it.

Can we use Dispose method without Implementing IDisposable Interface?

Can we use Dispose method without Implementing IDisposable Interface ?

You can name a method as Dispose and use it as an ordinary method without any restrictions:
public class MyClass {
public void Dispose() {
...
}
}
...
// using() emulation
MyClass m = null;
try {
m = new MyClass();
...
}
finally {
if (m != null)
m.Dispose();
}
but if you want using() syntax you have to implement IDisposable:
public class MyNextClass: IDisposable {
protected virtual void Dispose(Boolean disposing) {
...
}
public void Dispose() {
Dispose(true);
GC.SuppressFinalize(this);
}
}
...
// compare this with the using() emulation in the code above
using (MyNextClass n = new MyNextClass()) {
...
}
Anyway, even it's possible to name a method Dispose it's not a good practice to surprize (and finally irritate) developers (including you) who read your texts; so either implement IDisposable or find some other name for the method.

Nobody will stop you from doing that but it is very poor design because everybody knows about the idisposable interface. If you give a different meaning to this method, you are obfuscating your design to whoever takes a look at your code later. Maybe even yourself in a few years where you don't remember the reason why you did this .

Managed Objects are disposed automatically even if you do not implement IDisposable, IDisposable let you dispose which runtime won't dispose like files, open handles unmanaged code components.
Implementing a Dispose Method
The pattern for disposing an object, referred to as a dispose pattern,
imposes order on the lifetime of an object. The dispose pattern is
used only for objects that access unmanaged resources, such as file
and pipe handles, registry handles, wait handles, or pointers to
blocks of unmanaged memory. This is because the garbage collector is
very efficient at reclaiming unused managed objects, but it is unable
to reclaim unmanaged objects.
If you do not want to use the IDisposable pattern and want to have your own then I believe that is not recommended way as it one would have to discover that could be obvious using IDisposable.

still trying to understand the dispose pattern

i've read msdn and various posts about dispose pattern, and there are still a couple of things i don't understand. I've written the following code to test the dispose pattern. Please note that there aren't unmanged resources, i'm using vs2008 and .net 3.5 :
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void tryDispose()
{
//test 1 : allocate resource and leave manage it to gc
BL.myclass df = new BL.myclass();
//test 2 : try to force garbage collecting
//GC.Collect();
//test 3 : call dispose myself
//using (BL.myclass df = new BL.myclass())
//{
//}
}
private void button1_Click(object sender, EventArgs e)
{
tryDispose();
}
this is my disposable class:
class myclass: IDisposable
{
private StronglyTypedDs myDS;
private bool _disposed;
public myclass()
{
using (myDSTableAdapter docDocadpt = new myDSTableAdapter())
{
myDS = new StronglyTypedDs();
docDocadpt.Fill(myDS.TheTable);
}
}
#region IDisposable Members
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
~myclass()
{
Dispose(false);
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
if (myDS != null)
myDS .Dispose();
myDS = null;
}
}
_disposed = true;
}
#endregion
}
The results are :
test 1a - just instantiating myclass, the destructor is commentend since myclass doesn't contains unmanaged resources : myclass.dispose is not called, even if i close the application (whose dispose is executed instead) . So what's the state of the dataset once i close the application ?
test 1b - uncommenting destructor, it's ok all disposes are called when i close the application.
test 2a and 2b - i do the above test just calling gc.collect : the behaviour is identical to test 1a and 1b respectively
test 3 - everything works fine (of course)
many posts says that, if myclass doesn't contains unmanaged resources, i don't need to add the destructor; yet in my tests , if i don't add the destructor , myclass.dispose doesn't get called when i close the application. I haven't waited for the gc to run by itself (if i remember correctly gc.collect doesn't guarantes the class instance is deallocated) to check if it will call myclass.dispose .
So what's the correct implemention : always define e destructor or avoid it if myclass contains only managed resources ?
If i had filled all generations levels, would had the gc called myclass dispose or not without having implemented a destructor?
Finally i've noticed that if i define a destructor , but don't declare the class as implementing IDisposable, the disposing chain works anyway. This could make sense since the destructor might be translated to finalize in IL. But i find it really confusing : is it some kind of "implicit" interface implementation i don't know? gc can dispose the item but users can't
thank you in advance
Stefano

Trust your Garbage Collector. Managed resources will get cleaned up, eventually. There is no need for a finalizer or implementing IDisposable unless you have some external resource that needs to be released.
This typically means that you only should implement IDisposable when you either:
Are wrapping a native resource. (In this case, you probably also want a finalizer.)
Are encapsulating a class which implements IDisposable. (In this case, you want IDisposable, but don't need to implement a finalizer/destructor.)
Part of the confusion with IDisposable, in my opinion, is that it covers quite a few use cases, and the proper implementation changes depending on what you're doing (ie: wrapping native resources, wrapping other IDisposable classes, or using Factored types). To address this, I've written a multiple part series on IDisposable - it might help clarify some of this for you.

The correct pattern is to only use a finalizer when your class contains unmanaged resources. As to relying on the GC to dispose of your managed objects, don't. The IDisposable contract makes it clear that this object needs to be disposed.

Ok i think i've understood, referring to my example its correct to implement a dispose because the dataset is global to my class and implements IDisposable , while i don't need the finalizer because there aren't unmanaged resources.
Even if i "forget" to dispose some managed resource in my class dispose method, the gc will collect it at some point. The dispose method is just an utility i provide to other classes/developers for managed resources, a must with the finalizer if i wrap unmanaged resources .
i'll read the articles you have provided asap, but in the mean time i've the last question : when gc will free memory owned by my class and its resources ? when someone calls dispose or when it will run (it will free memory instead of moving it to next generation ) ?
thank you everybody for your answers and examples

I wrote a brief seris entitled How to Implement IDisposable and Finalizers: 3 Easy Rules. It describes a much simpler approach that Microsoft themselves have followed since the 2.0 version of the BCL.
The "official" pattern is needlessly complex and needlessly confusing.

Your code is correct, you've implemented it exactly like it is documented in the MSDN library.
You'll need to take a second look though. Reason what happens when the destructor (aka finalizer) runs. The disposing argument will be false, the protected Dispose method does nothing. This is entirely normal, finalizers should only ever release unmanaged resources. You don't have any. It is extraordinary rare to ever have an unmanaged resource in your own code. They belong in the nice wrapper classes available in .NET to turn an unmanaged operating resource into a nice managed class. If you find yourself thinking you need a finalizer, you'll be wrong 99.99% of the time. Even if you do wrap an unmanaged resource, you should use one of the SafeHandle wrappers. And rely on their finalizers.
Okay, you want to get rid of the destructor. It isn't healthy to leave it in, it keeps the object in memory longer than necessary. When you do, you'll cut it down to:
public void Dispose()
{
if (myDS != null) myDS.Dispose();
}
Which is the boiler-plate implementation of most any Dispose() method, just call the Dispose method of members of the class. You can completely omit it if you don't have any members with a Dispose() method.
Next, you do misunderstand how the Dispose() method gets called. It is not automatic. Which is the point of having it in the first place, releasing resources automatically is already taken care of by the garbage collector. The Dispose() method is there for you to call, either with the using statement or calling it directly. So that you can release the resource early instead of waiting for the garbage collector finalizer thread to get around to it. Which can take a while. Call it when you know that your program won't be using the object anymore.
If your DataSet is actively used by the form then you cannot dispose it until the form closes. Call the class' Dispose() method in a FormClosed event handler. Or, better, open the form's Designer.cs file, cut-and-paste the Dispose() method you find in there and move it to the form's source code file. And add the dispose call. I know that's a bit confuzzling, but the only time it's okay to edit the designer file.

The main purpose of IDisposable is to have a consistent standard interface you can dispose of unmanaged resources with, that is if you didn't do something to ensure Dispose() was called these resources would hang around after the app was closed. Also understood by the using() syntax, that is using will implement the following block for you:
DisposableType someDisposable = new DisposableType();
try
{
// Do whatever
}
finally
{
((IDisposable)someDisposable).Dispose();
}
This is all implemented in a nice design like so:
using(DisposableType someDisposable = new DisposableType())
{
// Do whatever
}

Disposing objects in the Destructor

I have an object that has a disposable object as a member.
public class MyClass
{
private MyDisposableMember member;
public DoSomething
{
using (member = new MyDisposableMember())
{
// Blah...
}
}
}
There can be many methods in MyClass, all requiring a using statement. But what if I did this instead?
public class MyClass
{
private MyDisposableMember member = new MyDisposableMember();
public DoSomething
{
// Do things with member :)
}
~MyClass()
{
member.Dispose();
}
}
As you can see, member is being disposed in the destructor. Would this work? Are there any problems with this approach?

Ideally, Dispose() should have already been called prior to finalization. It would be better to follow the typical dispose pattern, and allow the user to Dispose() the object properly, and have the finalizer Dispose of it if dispose has not already been called.
In this case, since you're encapsulating an IDisposable, you really don't need to implement the finalizer at all, though. (At the the point of finalization, your encapsulated member will get finalized, so there's no need to finalize your object - it just adds overhead.) For details, read this blog article I wrote on encapsulating an IDisposable.

You should probably make MyClass implement IDisposable. Inside the Dispose() method, call member.Dispose();. That way the programmer can have control over when the member gets disposed.

DO NOT DO THAT!
The GC will do that for you (indirectly as the object to dispose or another one will contain a destructor)
MyDisposableMember might even be disposed by the GC even before you dispose it - what happens then might not be what you intended to do.
Even worse: Adding a destructor (or finalizer) to a class costs additional time when disposing of the object (much more time as the object will stay in memory for at least one collection cyclus and maybe even promoted to the next generation).
Therfore, it would be completely useless and even backfire.

In your first example the member is not really part of the object's state since you're instantiating it every time it's used and disposing it right after. Since it's not part of the state don't model it as such just use a local variable when needed.
In more general you should put all disposal logic in Dispose() and implement IDisposable then use you class together with using or try-finally

The only thing I see wrong (and it isn't an error) is the fact that in a using statement you explicitly dispose of the object at that point in time (when your function / method is called). The destructor cannot be called they are invoked automatically. So at this point it may take some time for member to be disposed of. Better to implement the IDisposeable interface for MyClass.

Following the Microsoft pattern is your best bet so the users of your class have full control over when it is disposed.
public class MyClass : IDisposable
{
private MyDisposableMember member = new MyDisposableMember();
public DoSomething
{
// Do things with member :)
}
~MyClass()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing) // Release managed resources
{
member.Dispose();
}
// Release unmanaged resources
}
}

When a finalizer runs, one of the following will be true about almost any IDisposable object to which it holds a reference:
The object will have already had its finalizer run, in which case calling Dispose on the object will be at best useless.
The object will not have had its finalizer run, but its finalizer will be scheduled to run, so calling Dispose on the object will be useless.
The object will still be in use by something other than the object being finalized, so calling Dispose on it would be bad.
There are a few situations where calling Dispose in a finalizer might be useful, but most situations fit the cases listed above, which all have a common feature: the finalizer shouldn't call Dispose.

How do you manage deterministic finalization in C#?

I have a C# object with a critical resource that needs to be flushed very specific points in time making it a bad candidate to leave around for the garbage collector to take care of whenever it gets around to it, how should I handle this? Is there something like C++'s delete operator that will let me manually kill the instance of this object when needed?

You are looking for IDisposable. Here is an example class that implements this.
class MyDisposableObject : IDisposable
{
public MyDisposableObject()
{
}
~MyDisposableObject()
{
Dispose(false);
}
private bool disposed;
private void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
// Dispose of your managed resources here.
}
// Dispose of your unmanaged resources here.
this.disposed = true;
}
}
void IDisposable.Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
To use it, you can do something like this:
public void DoingMyThing()
{
using (MyDisposableObject obj = new MyDisposableObject())
{
// Use obj here.
}
}
The using keyword makes sure that the Dispose() method on IDisposable gets called at the end of its scope.

The IDisposable interface exists for deterministic destruction. There's a pattern for implementing it correctly on MSDN.
In tandem, you should also consider using the using statement when your object's lifetime does not span multiple scopes.

This is precisely what the IDiposable interface is for. You release the critical resources in the Dispose() method, and then leave the object around for the garbage disposer to deal with deallocating the memory.

Google for the IDisposable interface. This is the only mechanism available to you. It's tailor made if your critical resource is unmanaged. If it's a managed resource, could you be more specific about what needs to be "flushed".

The IDisposable interface was added to support deterministic destruction in C++/CLI, and you can use it from any .NET language. It's what you want.

If you are talking about a specific managed resource that you feel "MUST" be released at a specific time, you could specifcally call the Garbage Collectors' Collect method, after de-referencing the object, but there are performance considerations to be thought of, as normally the garbage collector knows when to collect items. And in general it is a bad idea.
As others are mentioning above, the IDisposable pattern is helpful for releasing unmanaged resources when needed.
NOTE: I'm going to repeat, you COULD call GC.Collect() but it is NOT a good thing, but a valid answer for the question!