Marshalling Output Arrays

I recently ran into an issue getting values out of a function that you pass an int* to get an array out. The C function looks like this: 

int __stdcall UP_GetProgList(int prog_type, int *sn_list, int count, int *count_returned)

Naively, I wrote the following P/Invoke call:

[DllImport(@"the.dll")]
private static extern int UP_GetProgList(int prog_type, out int[] sn_list, int count, out int count_returned);

Turns out that when I called that, I got an access violation.

I tried searching for the solution, I even asked on StackOverflow, but no one seemed to have the answer in an easy-to-digest format.

So I did some digging. My first attempt used out int instead of the array. That didn't give me an exception, but it would only allow me to get one value out.

I eventually found the IntPtr type. My first attempt at using it looked something like this:

void Main()
{
	var listP = Marshal.AllocHGlobal(20);
	UP_GetProgList(2, listP, 20, out int countReturned);
	
	for (int i = 0; i < countReturned; i++)
	{
		unsafe
		{
			Console.Out.WriteLine(*(int*)(listP + i));
		}
	}
}

[DllImport(@"the.dll", CallingConvention = CallingConvention.StdCall)]
private static extern int UP_GetProgList(int prog_type, IntPtr sn_list, int count, out int count_returned);

That worked, and gave me the results I was expecting. There were two problems: 1. It used unsafe which I didn't like the look of, and, as a StackOverflow user pointed out, it had a memory leak.

More digging was required. The solution was Marshal.Copy, which I had looked at, but rejected because I'd only seen the version for copying an array into a pointer. Turns out there's an overload that does the opposite. Adding a try and finally block fixed the memory leak, so I ended up with the following code, which works, and shouldn't leak memory: 
void Main()
{
	Console.Out.WriteLine(GetSerialNumbers());
}

int[] GetSerialNumbers()
{
	IntPtr listPtr = IntPtr.Zero;

	try
	{
		listPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * 20);
		var result = UP_GetProgList(PROG_FORTE, listPtr, 20, out int countReturned);
		var sns = new int[countReturned];
		Marshal.Copy(listPtr, sns, 0, countReturned);
		return sns;
	}
	finally
	{
		Marshal.FreeHGlobal(listPtr);
	}
}

This gave me the expected results, shouldn't leak memory, and also doesn't use unsafe. I hope this can serve as a template for someone else who encounters this problem.

Comments

Post a Comment

Popular posts from this blog

Radio nets for the non-amateur

Image
I recently gave some training to the Ottawa County Medical Reserve Corp  on radio use. Part of the training I was asked to provide is on a principle called radio nets.  If you're familiar with working with a dispatcher, you'll be used to how radio nets function. You can see the presentation here .  In a normal radio setup, everyone can talk to everyone else.  There's no control except self-control. Under a net, that changes.  All communications go through a Net Control station:   Why?  Three main reasons: It's clearer who is talking to who There's less talking over each other There's less confusion This ultimately results in a better response to emergencies. A net might seem slower than free-for-all, but it actually works out to be more efficient in the long run;  like how a four-way stop works: if everyone treated it as a free-for-all, there wouldd be chaos and collisions.  Instead, with the rules in place, everyone knows when to take their ...
Read more

Disaster Assets Net Exercise

Following on from the training I spoke about in my last post , we ran an exercise to put the newly learned skills to practice. We split everyone into teams, leaving myself and one other person as Net Control.  The teams dispersed into separate rooms, each taking a radio with them.  They also took an information sheet and three cards, each naming an "asset" they might have that someone else will need.   For instance, the First Aid station had a card saying "Patient report", which was needed by Incident Command.  Using the Net format, each team had to ask over the radio for the items that they needed, deliver the assets they had as directed by Net Control, and report back when an asset was delivered to them. The information sheets each had a description of the scenario, a personalized example of how to request a specific asset, and a list of "haves" and "needs". Who had What We had five teams, not counting Net Control, and each team had three asset...
Read more