mjhjmtu

I have a list of struct allocated from C code. I am returning the pointer of this struct list to C# code. And finally C# code is using this pointer and marshaling it into a corresponding C# struct list. Both C and C# code are bundled together.

I wanted to confirm is there any possibility of memory corruption in this scenario or can there be case in which we lose handle to the memory pointer is pointing. When will the memory allocated from C code be destroyed.

Below is a snippet of the code.

Sample C Code

 typedef struct sampleData 
 int id;
 int sid;
 SampleData; 

 SampleData* func()
 SampleData* pd = (SampleData*) malloc(10 * sizeof(SampleData)) ;
 for(int i=0;i<10;i++)
 pd[i].id=i*10;
 pd[i].sid=i*10;
 
 return pd;

sample C# code

class Test
 
 [StructLayout(LayoutKind.Sequential, Pack=1)]
 public struct TestData

 [MarshalAs(UnmanagedType.I4)]
 public int id;
 [MarshalAs(UnmanagedType.I4)]
 public int sid;
 

 [DllImport("sample.so", EntryPoint = "func")]
 static extern IntPtr func();

 public void collectSampleData()
 
 IntPtr idPtr = IntPtr.Zero;
 IntPtr sidPtr = IntPtr.Zero;
 idPtr = func();

 for(int i=0;i<10;i++)

 TestData TestDataObj=new TestData();

 IntPtr currPtr = new IntPtr(idPtr.ToInt64() + ( i * Marshal.SizeOf(typeof(TestData))));

 TestDataObj = (TestData)Marshal.PtrToStructure(currPtr,typeof(TestData));

 Console.WriteLine(TestDataObj.id+" "TestDataObj.sid);

 
 
 

In the above code is there a possibility to loose the handle of memory allocation done for Sampledata struct list when accessing from C# side. As the above code for now is giving correct values.

As-is there should be no memory corruption coming from the managed code.

However, the unmanaged memory will not be released at all unless you explicitly do something about it.

"Traditional" APIs typically use two ways for dealing with this:

• They accept a pointer (usually along with buffer size information) when calling, and store their data in the memory area the pointer points to. In this case they do not allocate memory as you do with malloc(), and the caller is responsible for providing the buffer and managing the memory. If the buffer is not large enough, the callee should return an error. Most Win32 APIs work this way (file access etc.).




• They provide another call to release the memory. In this case both malloc() and free() are in your external code, and the managed side does not actively manage the memory but it has to notify the external code when the pointer is no longer in use. Note that COM does use a related approach with reference counting; when the counter reaches 0, the object is freed.