使用非托管DLL中的非托管结构而不在C＃中复制

Question

I have a DLL written in unmanaged language that returns a pointer to a C structure. AC# program must fill in some details into the structure. Next the same pointer (not a copy) must be given to another method from the same DLL Now the C# program collects the data from the C structure.

The datatype:

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1, Size = 18 * 2 + 24 * 256)]
public class Context {
    public UInt16 Magic;
    public UInt16 Method;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2*16)]
    public UInt16[] Status;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8*256)]
    public Field[]  InputFields;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8*256)]
    public Field[]  OutputFields;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8*256)]
    public Field[]  MetaData;
}

[StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode,Pack=1,Size=256)]
public class Field {
    public UInt16 Kind;
    public UInt16 Status;
    public UInt16 Length;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 125)]
    public string Data;
}

Methods:

[DllImport("x.dll")]
//[return: MarshalAs(UnmanagedType.LPStruct)]
public static extern IntPtr  CreateContext    ( UInt16 ContextKind );
[DllImport("x.dll")]
public static extern UInt16  DestroyContext   ( IntPtr Context );
[DllImport("x.dll")]
public static extern UInt16  Execute          ( [In, MarshalAs(UnmanagedType.LPStruct)] Context Context );

How can I fill in / read out the memory that is mananged by the DLL (not C#) in my C# program?

I tried:

• Using

   [return: MarshalAs(UnmanagedType.LPStruct)] 

  instead of IntPtr . But memory needs to be managed by C# for that which it is not.

• Use IntPtr and Marshal.PtrToStructure but it tries to copy the memory to another location:

   IntPtr C = CreateContext(1); if (C == null) return; Context Ctx = (Context)Marshal.PtrToStructure(C, typeof( Context ) ); Ctx.Method = 2; 

(fails on the PtrToStructure call with an ExecutionEngineException ).

Answer 1

Try fixing your declarations - eg remove the Size parameter (but not SizeConst ), and make sure the C code actually provides inline, byval arrays of values that have exactly the right number of entries in them (which is the requirement for UnmanagedType.ByValArray, SizeConst ). Eg this works for me:

// Init array fields (required; supposed to happen on the C side)
ctx.Status = new UInt16[2 * 16];
ctx.InputFields = new Field[8 * 256];
ctx.OutputFields = new Field[8 * 256];
ctx.MetaData = new Field[8 * 256];

// Test data to survive the roundtrip (also supposed to happen on the C side)
ctx.Method = 42;
ctx.InputFields[42] = new Field() { Data = "Hi." };
ctx.OutputFields[42] = new Field() { Data = "Also hi." };


IntPtr buf = Marshal.AllocCoTaskMem(1024 * 100);

Marshal.StructureToPtr(ctx, buf, false);

var ctx_new = new Context();
Marshal.PtrToStructure(buf, ctx_new);

Marshal.FreeCoTaskMem(buf);


Console.WriteLine(ctx_new.Method);
Console.WriteLine(ctx_new.InputFields[42].Data);
Console.WriteLine(ctx_new.OutputFields[42].Data);

---

Failing that, try using the Marshal.Write* methods to write to the memory directly if PtrToStructure does not work for you. You can then create a wrapper class that would hold the IntPtr and provide properties that would trigger the Marshal.Write - eg

public UInt16 Status {
    get { return unchecked((ushort)Marshal.ReadInt16(m_Ptr, 2)); }
    set { Marshal.WriteInt16(m_Ptr, 2, unchecked((short)value)); }
}