When/how is IDisposable.Dispose called?

问题

Given the following class which implements both Dispose and IDisposable.Dispose:

internal class DisposableClass : IDisposable
{
    public void Dispose()
    {
    }
    void IDisposable.Dispose()
    {
    }
}

When I make a call to DisposeableClass.Dispose (through an instance of the class), the public void Dispose is called:

DisposableClass newClass = new DisposableClass();
try
{
}
finally
{
    newClass.Dispose();
}

If you change the try-finally to a using statement, IDisposable.Dispose is called.

using (DisposableClass newClass = new DisposableClass())
{
}

But NOT the IDisposable.Dispose which I defined.

The compiler translates the using-statement to ((IDisposable)newClass).Dispose(). The full methodname shows it to be from System.IDisposable.Dispose.

IL_0014: callvirt instance void [mscorlib]System.IDisposable::Dispose()

When will my custom implementation of IDisposable.Dispose be called?

Note that I am not using this actual implementation and I get that this should not be used. But I am still curious as to which implementation gets called when.

If I'd have a different implementation for each of the Dispose methods; which implementation would be called when?

回答1:

Your approach to disposing is wrong. You should look at The Dispose Pattern to understand how to do this properly.

However... To answer your question how / why are they called...

Your public void Dispose() is being called when you say newClass.Dispose(); because it is the best "match" for what you have asked. By that (and without getting too complicated) it is because it is the highest in the hierarchy and therefore the one the compiler expects you to mean because it is the most specific. If you hadn't created your own it would have gone through hierarchy to find a Dispose method.

When you wrap with using the compiler produces code similar to this:

DisposableClass newClass = new DisposableClass();
try
{
}
finally
{
    ((IDisposable)newClass).Dispose();
}

This will therefore call the IDiposable version explicitly.

UPDATE

Full working sample below that will give this output:

Manually calling newClass.Dispose();
public void Dispose() being called.

Now wrapped in using...
void IDisposable.Dispose() being called.

Manually calling IDisposable.Dispose();
void IDisposable.Dispose() being called.

Full working code (paste this inside a console app and run):

using System;

namespace zPlayGround
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Manually calling newClass.Dispose();");
            var newClass = new DisposableClass();
            try
            {
            }
            finally
            {
                newClass.Dispose();
            }

            Console.WriteLine("Now wrapped in using...");
            using (var usingClass = new DisposableClass())
            {

            }

            Console.WriteLine("Manually calling IDisposable.Dispose();");
            var demoClass = new DisposableClass();
            try
            {
            }
            finally
            {
                ((IDisposable)newClass).Dispose();
            }
            Console.ReadKey();
        }
    }

    internal class DisposableClass : IDisposable
    {
        public void Dispose()
        {
            Console.WriteLine("public void Dispose() being called.\r\n");
        }
        void IDisposable.Dispose()
        {
            Console.WriteLine("void IDisposable.Dispose() being called.\r\n");
        }
    }
}

来源：https://stackoverflow.com/questions/25183474/when-how-is-idisposable-dispose-called

标签

idisposable