How to nicely delete unmanaged memory in C#?

Question

I was reading for this question: Difference between destructor, dispose and finalize method

I've read that the destructor was used to delete unmanaged resources, but after running a little test :

using System;

namespace Tests
{
    class ImABastardException : Exception 
    {
        public ImABastardException() : base() { }
    }

    class Mouarf
    {
        public Mouarf()
        {
            Console.WriteLine("Constructor");
            throw new ImABastardException();
        }

        ~Mouarf()
        {
            Console.WriteLine("Destructor");
        }
    }

    class Program
    {
        private static void Func()
        {
            Console.WriteLine("Before");
            try
            {
                Console.WriteLine("Try");
                Mouarf m = new Mouarf();
            }
            catch (ImABastardException)
            {
                Console.WriteLine("Catch");
            }
            finally
            {
                Console.WriteLine("Finally");
            }
            Console.WriteLine("After");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("MainBefore");
            Func();
            Console.WriteLine("MainAfter");
            Console.ReadKey();  
        }
    }
}

The result was :

MainBefore
Before
Try
Constructor
Catch
Finally
After
MainAfter   
(I push enter or another key)   
Destructor

I'm afraid that the destructor isn't called when I want (at the end of its range)..

I actually want to create a simple class :

public unsafe class StringArray
{
    private sbyte** pointer;
    private int count;

    public StringArray(string[] array)
    {
        count = array.Length;

        pointer = (sbyte**)Memory.Alloc(count * sizeof(sbyte*));
        for (int i = 0; i < count; i++)
        {
            fixed (byte* p = Encoding.ASCII.GetBytes(array[i]))
            {
                pointer[i] = (sbyte*)p;
            }
        }
    }

    ~StringArray()
    {
        Memory.Free(pointer);
    }

    public sbyte** Pointer
    {
        get
        {
            return pointer;
        }
    }

    public int Count
    {
        get
        {
            return count;
        }
    }
}

public unsafe class Memory
{
    // see : https://msdn.microsoft.com/fr-fr/library/aa664786%28v=vs.71%29.aspx
}

But I think it would be better to use Dispose for unmanaged resources, what do you think?

Thanks!

Sylafrs.

---

Edit:

I've had asked that question as an answer to the topic I've given the link above;

Lasse V. Karlsen answered:

"As a quick comment to your actual question, I would implement IDisposable on that type, and have the finalizer call Dispose(false);"

So I've tested:

using System;

namespace Tests
{
    class ImABastardException : Exception 
    {
        public ImABastardException() : base() { }
    }

    class Mouarf: IDisposable
    {
        // Flag: Has Dispose already been called?
        bool disposed = false;

        public Mouarf()
        {
            Console.WriteLine("Constructor");
            throw new ImABastardException();
        }

        ~Mouarf()
        {
            Dispose(false);
        }

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

        // Protected implementation of Dispose pattern.
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                Console.WriteLine("Disposing managed objects");
            }

            Console.WriteLine("Disposing unmanaged objects");
            disposed = true;
        }
    }

    class Program
    {
        private static void Func()
        {
            Console.WriteLine("Before");
            Mouarf m = null;
            try
            {
                Console.WriteLine("Try");
                using (m = new Mouarf())
                {
                    ;
                }
            }
            catch (ImABastardException)
            {
                Console.WriteLine("Catch");
            }
            finally
            {
                Console.WriteLine("Finally");
            }
            Console.WriteLine("After");
        }

        static void Main(string[] args)
        {
            Console.WriteLine("MainBefore");
            Func();
            Console.WriteLine("MainAfter");
            Console.ReadKey();
        }
    }
}

IDisposable doesn't work too.. (the "Disposing unmanaged objects" message was written at the program's end)

I guess the problem comes from the constructor.. Must I use a method to do risky tasks?

Answer 1

The full example should be:

public unsafe sealed class StringArray : IDisposable
{
    private sbyte** pointer;
    private int count;

    public StringArray(string[] array)
    {
        count = array.Length;

        pointer = (sbyte**)Marshal.AllocCoTaskMem(count * sizeof(sbyte*));

        for (int i = 0; i < count; i++)
        {
            fixed (char* p = array[i])
            {
                int len = Encoding.ASCII.GetByteCount(array[i]);
                pointer[i] = (sbyte*)Marshal.AllocCoTaskMem(len + 1); // Zero final byte

                Encoding.ASCII.GetBytes(p, array[i].Length, (byte*)pointer[i], len);
                pointer[i][len] = 0; // Final zero
            }
        }
    }

    ~StringArray()
    {
        Dispose();
    }

    public void Dispose()
    {
        if (pointer != null)
        {
            for (int i = 0; i < count; i++)
            {
                Marshal.FreeCoTaskMem((IntPtr)pointer[i]);
            }

            Marshal.FreeCoTaskMem((IntPtr)pointer);
            pointer = null;
            count = 0;
        }
    }

    public sbyte** Pointer
    {
        get
        {
            return pointer;
        }
    }

    public int Count
    {
        get
        {
            return count;
        }
    }
}

And to use it "correctly" you should write something like:

using (var sa = new StringArray(new[] { "a", "ab", "abc" }))
{

}

Note that the class is sealed, so you don't need to implement the full IDisposable "pattern".

You can't directly use the memory returned by GetBytes, because that is memory handled by the GC. You would need to pin it with GCHandle or write/copy it to a buffer you manually allocated (like I did).

In general the byte is preferred to the sbyte.

I'm adding a zero terminator to the strings, because C strings are built that way. Often in C, "things" like the StringArray are implemented without a Count "property" and the array is terminated with a NULL pointer at the last element, like

public StringArray(string[] array)
{
    pointer = (sbyte**)Marshal.AllocCoTaskMem((array.Length + 1) * sizeof(sbyte*));
    pointer[array.Length] = null;

    for (int i = 0; i < array.Length; i++)
    {
        fixed (char* p = array[i])
        {
            int len = Encoding.ASCII.GetByteCount(array[i]);
            pointer[i] = (sbyte*)Marshal.AllocCoTaskMem(len + 1); // Zero final byte

            Encoding.ASCII.GetBytes(p, array[i].Length, (byte*)pointer[i], len);
            pointer[i][len] = 0; // Final zero
        }
    }
}

Then the Count can be implemented like:

public int Count
{
    get
    {
        if (pointer == null)
        {
            return 0;
        }

        int count = 0;

        sbyte** pointer2 = pointer;

        while (*pointer2 != null)
        {
            count++;
            pointer2++;
        }

        return count;
    }
}

I'll add that every memory allocation is "expensive" (both in terms of space, because there is bookkeeping) and in terms of time. If all the strings in the StringArray have the same lifetime, then you could allocate a single block of memory. Clearly this is much more complex to write... But the Dispose() is much easier!

public StringArray(string[] array)
{
    int indexLength = (array.Length + 1) * sizeof(sbyte*);

    // space for null terminator at end of array
    int totalLen = indexLength;

    for (int i = 0; i < array.Length; i++)
    {
        fixed (char* p = array[i])
        {
            int len = Encoding.ASCII.GetByteCount(array[i]);
            totalLen += len + 1; // zero byte at end of string
        }
    }

    pointer = (sbyte**)Marshal.AllocCoTaskMem(totalLen);

    // last element at null
    pointer[array.Length] = null;

    // Memory at the end of the "index" space
    sbyte* pointer2 = (sbyte*)pointer + indexLength;

    // remaining space starting from pointer2
    int remainingLen = totalLen - indexLength;

    for (int i = 0; i < array.Length; i++)
    {
        fixed (char* p = array[i])
        {
            pointer[i] = pointer2;

            int len = Encoding.ASCII.GetBytes(p, array[i].Length, (byte*)pointer2, remainingLen);
            pointer2[len] = 0;

            len++; // Zero terminator

            pointer2 += len;
            remainingLen -= len;
        }
    }
}

public void Dispose()
{
    if (pointer != null)
    {
        Marshal.FreeCoTaskMem((IntPtr)pointer);
        pointer = null;
        count = 0;
    }
}