Welcome to the Lounge

1. it avoids memory / resource leaks regardless of whoever use your API. i.e. it makes garbage collection collect your resources, isn't that nice?
2. it has no performance impact if you call Dispose explicitly
3. it's 3 line of code to implement properly...

codewitch honey crisis wrote:

I just don't have a good enough justification to use because it doesn't prevent resource leaks - win32 does that, as I said.

public class Class : IDisposable
{
    IntPtr unmanaged;

    public Class()
    {
        unmanaged = Marshal.AllocHGlobal(10);
    }

    public void Dispose()
    {
        Marshal.FreeHGlobal(unmanaged);
        unmanaged = IntPtr.Zero;
    }
}

public class Class : IDisposable
{
    IntPtr unmanaged;

    public Class()
    {
        unmanaged = Marshal.AllocHGlobal(10);
    }
    ~Class() { Dispose(false); }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected void Dispose(bool disposing)
    {
        Marshal.FreeHGlobal(unmanaged);
        unmanaged = IntPtr.Zero;
    }

public class Class : IDisposable
{
    IntPtr unmanaged;

    public Class()
    {
        unmanaged = Marshal.AllocHGlobal(10);
        GC.AddMemoryPressure(10);
    }
    ~Class() { Dispose(false); }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected void Dispose(bool disposing)
    {
        if (unmanaged != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(unmanaged);
            GC.RemoveMemoryPressure(10);
            unmanaged = IntPtr.Zero;
        }
    }
}

• for the record memory management, and even dispose, is indeed totally useless if all you have is short running processes. the issue is all about singular long running process running as long as possible. which you seem to dismiss so casually for some mysterious reason
• you were asking for a sample that show if finalizer are even ever called. well run the winform app below as a console app (to see the Console.WriteLine() output), press the button a few times, tab out and in, do it again. you will see that finalizer are indeed called sometimes.

    class Program
    {
        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MyForm());
        }
    }
    public class MyForm : Form
    {
        public MyForm()
        {
            var b = new Button
            {
                Text = "Click",
                Dock = System.Windows.Forms.DockStyle.Fill,
            };
            b.Click += (o, e) => { new Foo(); };
            this.Controls.Add(b);
        }
    }
    public class Foo
    {
        const int N = 100_000;

<pre>
    IntPtr unmanaged;
    public Foo()
    {
        unmanaged = Marshal.AllocHGlobal(N);
        GC.AddMemoryPressure(N);
    }
    ~Foo()
    {
        Console.WriteLine("in finalizer");
        // not freeing any memory on purpose
        //Marshal.FreeHGlobal(unmanaged);
        //GC.RemoveMemoryPressure(N);
    }
}</pre>

Super Lloyd wrote:

If your code is using other precious system resource, like a Window handle, or a brush handle or a socket... you might be out of luck. You might run out those without the system realizing a system GC is needed.