Interop C＃/ C问题：AccessViolationException

Question

and thanks in advice for any help.

i have this trivial function in C:

__declspec(dllexport)  Point* createPoint (int x, int y) {
    Point *p;

    p = (Point*) malloc(sizeof(Point)); 
    p->x = x;
    p->y=y;

    return p;       
}

Point is a very simple struct with two int fields, x and y.

I would like calling this function from C#.

I use this code:

[DllImport("simpleC.dll", EntryPoint = "createPoint", CallingConvention = CallingConvention.Cdecl, SetLastError = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.LPStruct)]
public static extern Point createPoint(int x, int y);

Point p = Wrapper.createPoint(1, 2);

But at runtime I have an AccessViolationException . Watching exception in detail, I found that exception is thrown from Marshal.CoTaskMemFree(IntPtr) method.

It seems that this method is unable to free memory allocated by C malloc.

What am i doing wrong?

Really thanks.

Answer 1

CoTaskMemFree cannot be used to free memory allocated by malloc (because they use different allocators). According to MSDN , "The runtime always uses the CoTaskMemFree method to free memory. If the memory you are working with was not allocated with the CoTaskMemAlloc method, you must use an IntPtr and free the memory manually using the appropriate method."

Additionally, Adam Nathan notes that "UnmanagedType.LPStruct is only supported for one specific case: treating a System.Guid value type as an unmanaged GUID with an extra level of indirection. ... You should probably just stay away from UnmanagedType.LPStruct."

There are two possible solutions:

1. Declare the return type of the method as IntPtr and use Marshal.ReadInt32 to read the fields of the struct, or use Marshal.PtrToStructure to copy the data to a managed struct, or use unsafe code to cast the IntPtr value to a Point * . The C library will need to expose a destroyPoint(Point *) method that frees the memory.
2. Change the C method signature to void getPoint(int x, int y, Point *) . This lets C# allocate the struct, and the C method simply fills in the data values. (Most of the Win32 APIs are defined this way).

One final note: Unless your method uses the SetLastError Win32 API, you don't need to specify SetLastError = true on your P/Invoke attribute.

Answer 2

Since you don't have the code that frees "p", it is hard to say. However it is likely that the way malloc() and free() work together is completely different to the way C# manages memory. Since C# has garbage collection (I believe) it is likely that it uses a completely different memory management system.

In any case, the correct solution is that if you use your library to create an object, you should also use it to destroy it. Implement a "destroyPoint" function that frees the memory in your C library, import it to the C# code, and call it from there to destroy the objects created by your C library.

As a general design/coding rule, every "create" function should have a matching "free/destroy/delete" function. Apart from nothing else, it makes it easy to ensure that all created items get properly destroyed.

Answer 3

How is the Point type defined on the C# side?
It has to be unsafe, or you need to return a void pointer (IntPtr). The GC is not able to count references from outside (here the allocated memory), thus your code can not expect to manage externally allocated memory via the GC.
One alternative is to keep a static reference to avoid a Garbage collection, if you need to keep the object persistently during the runtime of your application.