how Marshal.FreeHGlobal() works?

Question

I have a C# based UI which uses C++ based DLL. My requirement was to pass a big chunk of memory from C# to DLL. DLL will write into this memory buffer and pass it back to C#. I have used IntPtr & global memory functions to do this. Everything works fine.

The question is, How to verify if the Marshal.FreeHGlobal() has cleaned the memory? I am using big chunk of memory, usually in terms of MBs. So I want to make sure that the memory is cleaned instantly.

Your use of "cleaned" suggests you're concerned with security, but I think you really want to know whether the memory has been freed. Am I correct? — Rob Kennedy, Feb 09 '11 at 19:36
The docs say that AllocHGlobal() and FreeHGlobal() are just wrappers around the Win32 LocalAlloc() and LocalFree() functions. As long as you are using the same allocator on both ends you should be ok. — Luke, Feb 09 '11 at 19:47
It doesn't make sense to check, nor is it at all easy to do so. The wrapper already bombs if the native Window call fails, good enough. — Hans Passant, Feb 09 '11 at 21:31

score 5 · Accepted Answer · answered Feb 09 '11 at 19:59

If you pass a valid handle to Marshal.FreeHGlobal, it will be freed. But since the method doesn't return a value, you can't say for sure whether it was cleaned up.

If you have some doubt as to whether you're passing the right thing to FreeHGlobal, then I suggest that your code probably isn't as clean as it should be. But if you really want to make sure, then you could call the LocalFree Windows API function, passing it the handle that you would have passed to FreeHGlobal:

[DllImport("kernel32", SetLastError=true)]
static extern IntPtr LocalFree(IntPtr mem);

// Now, to free a block of memory allocated with Marshal.AllocHGlobal
IntPtr rslt = LocalFree(memPtr);
if (rslt == IntPtr.Zero)
{
    // success!
}
else
{
    int err = Marshal.GetLastWin32Error();
    // do something with the error.
}

I would suggest, however, that if you do this, that you call LocalAlloc to allocate the memory rather than calling Marshal.AllocHGlobal, as it's possible (although probably unlikely) that future versions of .NET could use something other than LocalAlloc to allocate unmanaged memory. If that happened, then your code that depends on LocalFree would break.

`Marshal.FreeHGlobal` contractually calls `LocalFree` https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.freehglobal(v=vs.110).aspx — Mark Sowul, Jul 09 '17 at 19:35

score 0 · Answer 2 · answered Jul 09 '17 at 19:41

You can probably also allocate the array in managed memory, and then create a GCHandle to allow it to be accessed from unmanaged memory.

For example, here I call PowerReadACValue; the Win32 API function takes in an LPBYTE buffer (which equates to BYTE*).

First I call it with a "null pointer" (IntPtr.Zero), so that it will tell me what size buffer I need (this gets output into bufferSize). Then I allocate the buffer, and pass in the pointer via GCHandle's AddrOfPinnedObject.

uint type;
uint bufferSize = 0;

if (SafeNativeMethods.PowerReadACValue(IntPtr.Zero, this.m_planHandle, ref subGroupOfPowerSettingsGuid, ref powerSettingGuid, out type, IntPtr.Zero, ref bufferSize) != 0)
{
    throw new Win32Exception();
}

byte[] buffer = new byte[bufferSize];
GCHandle bufferPointer = default(GCHandle);
try
{
    bufferPointer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    if (SafeNativeMethods.PowerReadACValue(IntPtr.Zero, this.m_planHandle, ref subGroupOfPowerSettingsGuid, ref powerSettingGuid, out type, bufferPointer.AddrOfPinnedObject(), ref bufferSize) != 0)
        throw new Win32Exception();
}
finally
{
    if (bufferPointer.IsAllocated)
        bufferPointer.Free();
}

Alternatively, I could have allocated the buffer with Marshal.AllocHGlobal, which also returns me an IntPtr, and then afterwards free it with Marshal.FreeGlobal, but in this case I need to use the data in the array from managed code. If I were simply going to pass the array pointer to another unmanaged function without ever touching it from managed code, this would be a better way to go (while the GCHandle is active, the memory is locked into place in memory which affects the garbage collector).

how Marshal.FreeHGlobal() works?

2 Answers2

Linked