Calling a C DLL from a C# Program

Question

I need to pass a pointer to a structure to my DLL, any ideas how would I go about doing that?

In my C DLL:

typedef struct
{
    int length;
    unsigned char *value;
} Sample;


__declspec(dllexport) void __stdcall helloWorld( Sample *sample );

In my C# code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace CSharpConsole
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct Sample
        {
            public Int32 length;
// What Should I Declare Here?
        }

        [DllImport("C:\\CTestDLL.dll")]
        private static extern void helloWorld( Sample sample ); // How would I make this a pointer?

        void HelloWorld()
        {
            Sample sample = new Sample();
            sample .length = 20;
            // How can I fill up the values of value?
            helloWorld( sample ); // How should I pass it inside here
            return;
        }

        static void Main(string[] args)
        {
            Program program = new Program();
            program.HelloWorld();
        }
    }
}

Answer 1

To pass a pointer to a value type into a P/Invoke function just declare the parameter as a ref or out. This implicitly takes a reference to the parameter and passes that:

[DllImport("C:\\CTestDLL.dll")]
private static extern void helloWorld(ref Sample sample);

Since your structure has an array in it, you'll have to take care to declare it properly for this to work. I strongly recommend, if possible, that you turn it into a fixed-length array, as it will make the marshaler much, much happier:

typedef struct
{
    int length;
    unsigned char value[MAX_LENGTH];
} Sample;

This becomes:

public struct Sample
{
  int length;
  [MarshalAs(UnmanagedType.LPArray, SizeConst = MAX_LENGTH)] byte[] value;
}

If that is not possible, then the runtime has no way of knowing how much data to marshal back; in that case, you probably will have to resort to manual marshaling of your data:

public struct Sample
{
  int length;
  IntPtr value;
}

var sample = new Sample();
helloWorld(ref sample);

byte[] value = new byte[sample.length];
Marshal.Copy(sample.value, value, 0, sample.Length);

---

However, based on your comment to another answer, it looks like you just need to get a block of bytes out of the C DLL into C#. For that you don't really need a structure at all, and eliminating it would simplify things a lot. If you just want to pass in an array and have it filled in and returned to you, try something like this:

(This assumes you have control over both C and C# code bases; if not then the ref suggestion is the way to accomplish what you need.)

// In C# code:
[DllImport(@"C:\CTestDll.dll")]
private static extern void helloWorld(
  int length,
  [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] byte[] buffer);

byte[] buffer = new byte[1024 * 8];
helloWorld(1024 * 8, buffer);


// In C:
__declspec(dllexport) void __stdcall helloWorld(int, unsigned char *);

void helloWorld(int cb, unsigned char *buf)
{
  memcpy(buf, DATASRC, cb);
}

In C, an unsigned char is, by definition, the same size as a C# byte - 8 bits, no sign. In C#, a char is actually two bytes. The runtime will automatically "convert" an unsigned char * to a byte[] for you. (There's not really a conversion at all; they are just different names for the same type.)

Answer 2

Default Marshaling for Value Types - gives some information on marshalling structs.
Calling Win32 DLLs in C# with P/Invoke - a little over half way down the page there's a table showing the type conversions between the standard unmanaged and managed types.

There are a few ways to pass around and convert the types.
As Michael Edenfield pointed out you can generally just use the ref keyword to indicate that a parameter should by passed by reference which is basically a pointer.

However sometimes things don't cooperate, particularly when it comes to strings or complex data types so this is where the IntPtr type comes in. You have a couple of options for using IntPtrs.
You can create an IntPtr to a block of unmanaged memory of a specified size using:

IntPtr pointer = Marshal.AllocHGlobal(sizeOfBufferInBytes);  
//Do stuff with the pointer
Marshal.FreeHGlobal(pointer); //Don't forget to release the memory

This is obviously a bit dangerous because you're manually allocating unmanaged memory.
You'll need to Marshal the data from the buffer back into a managed type, using something like Marshal.Copy(), Marshal.PtrToStructure(), Buffer.BlockCopy(), etc.

Alternatively you can create a managed object and pin it in memory while you need to, get a pointer to it and pass that to your method.

MyObject instance = new MyObject();
GCHandle gch = GCHandle.Alloc(instance, GCHandleType.Pinned);
importedMethod(gch.AddrOfPinnedObject()); //AddrOfPinnedObject() gives you an IntPtr 
gch.Free(); //Release the pinned memory so the garbage collector can deal with it

This avoids the necessity for manually marshalling back to the correct data type but this is not always an option depending on the type of MyObject and whether it's blittable.

Answer 3

This works for me:

DLL:

typedef struct
{
    int length;
    unsigned char *value;
} Sample;

extern "C" __declspec(dllexport) void __stdcall helloWorld( Sample *sample )
{
    MessageBoxA(NULL, (LPCSTR) sample->value, (LPCSTR) sample->value, 0);
}

C#:

class Program
{
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private class Sample
    {
        public Int32 length;
        public String value;
    }

    [DllImport("C:\\Users\\Kep\\Documents\\Visual Studio 2010\\Projects\\SODLL\\Debug\\DLL.dll")]
    private static extern void helloWorld(Sample sample); 

    static void Main(string[] args)
    {
        Sample s = new Sample();
        s.length = 10;
        s.value = "Huhu";
        helloWorld(s);
    }
}

Important thing is to mark it as a class, not a struct in C#.

With this, you could also use constructors etc. in C#:

class Program
{
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    private class Sample
    {
        public Int32 length;
        public String value;

        public Sample(String s)
        {
            length = s.Length;
            value = s;
        }
    }

    [DllImport("C:\\Users\\Kep\\Documents\\Visual Studio 2010\\Projects\\SODLL\\Debug\\DLL.dll")]
    private static extern void helloWorld(Sample sample); 

    static void Main(string[] args)
    {
        Sample s = new Sample("Huhu");
        helloWorld(s);
    }
}