After a lot of experimenting, i have still troubles with marshalling
the structures. Precisely, Marshal.PtrToStructure throws an exception
which i don't understand.

Here are the two structures:

       [StructLayout(LayoutKind.Sequential)]
       struct RecordStruct
       {
           public Int32 size;
           public byte []data;
           public Int32 flags;
           public Int32 _flags;
           public Int64 _rid;
       }

       [StructLayout(LayoutKind.Sequential)]
       struct KeyStruct
       {
           public Int16 size;
           public byte[] data;
           public Int32 flags;
           public Int32 _flags;
       }

And here's a function to insert a key/record pair - this works, both
structures are not modified in the native library.

       [DllImport("hamsterdb.dll", EntryPoint = "ham_insert",
          CallingConvention = CallingConvention.Cdecl)]
       static private extern int InsertLow(IntPtr handle, IntPtr
reserved,
               ref KeyStruct key, ref RecordStruct record, int
flags);

And here's the function to look up a value in the database. In that
case, the "record" is actually modified in the native code. Therefore
i had to create an IntPtr from it (passing a normal RecordStruct leads
to a crash).

       [DllImport("hamsterdb.dll", EntryPoint = "ham_find",
          CallingConvention = CallingConvention.Cdecl)]
       static private extern int FindLow(IntPtr handle, IntPtr
reserved,
               ref KeyStruct key, IntPtr record, int flags);

Here is the code which causes the problem. I'm allocating memory and
call FindLow(); if it returns successfully, i convert the memory back
to the RecordStructure with Marshal.PtrToStructure. This throws an
exception (see below).

       static public unsafe byte[] Find(IntPtr handle, byte[] data,
int flags) {
           IntPtr recordPtr = IntPtr.Zero;
           KeyStruct key = new KeyStruct();
           key.flags = 0;  // just to avoid a compiler warning
           key._flags = 0; // "
           key.size = (short)data.GetLength(0);
           key.data = data;
           try {
               RecordStruct record = new RecordStruct();
               record._flags = 0;
               record.flags = 0;
               recordPtr =
Marshal.AllocHGlobal(Marshal.SizeOf(record));
               // initialize struct with zeroes - maybe not needed...
               Marshal.StructureToPtr(record, recordPtr, false);
               int st = FindLow(handle, IntPtr.Zero, ref key,
recordPtr, flags);
               if (st == 0) {  // success
                   record =
(RecordStruct)Marshal.PtrToStructure(recordPtr,
                       record.GetType());
                   return record.data;
               }
               return null;
           }
           finally {
               if (recordPtr != IntPtr.Zero)
                   Marshal.FreeHGlobal(recordPtr);
           }
       }

Here is the exception:

Unittests.DatabaseTest.FindKey :
System.Runtime.InteropServices.SafeArrayRankMismatchException :
SafeArray cannot be marshaled to this array type because it has either
nonzero lower bounds or more than one dimension.
at
at System.Runtime.InteropServices.Marshal.PtrToStructureHelper(IntPtr
ptr, Object structure, Boolean allowValueClasses)
at
at System.Runtime.InteropServices.Marshal.PtrToStructure(IntPtr ptr,
Type structureType)
at
D:\hamster\hamsterdb-dotnet\trunk\hamsterdb-dotnet\LowLevel.cs(126)

I understand that the .NET runtime does not know the size of the
RecordStruct.data array, my guess is that this leads to the problem.
(The size is stored in RecordStruct.size). Any ideas how i can solve
that problem?

Thanks
Christoph

Stephen and Jeroen,

thanks to both of you for the help.

The idea with overloading is great and so simple, and it works fine. I
will follow your suggestion.

There is only one reason that i use structs instead of classes - i
need to use the StructLayout.Sequential attribute for them, and i
don't know if it works for classes.

Regards
Christoph