dotnet interop: Struct w/ VARIANT Marshalling -- dotnet interop

You're in the

dotnet interop

group:

Struct w/ VARIANT Marshalling

Michael
4/23/2008 6:53:03 PM

dotnet interop:

Hi, I've been banging my head against this one and now I'm about to scream. Any suggestions appreciated. I've scoured the net too and for some reason all suggestions don't work.

I've got a C++ app that takes a function pointer from a C# application (it's for a callback). The callback signature looks like this.
void callbackSignature( SpecialType *st );

The SpecialType is a struct that looks like the following (in C++).
struct SpecialType{
VARIANT a;
VARIANT b;
}

Now, what I'm trying to do is fire the callback from C++ and catch it and process the SpecialType in C#.

I've implemented a struct in my C# application that mirrors the C++ one that looks like
public struct SpecialCSharpType{
Object a;
Object b;
}

The actual callback in C# that gets implemented has a signature that looks like the following.
static void CSharpCallback( IntPtr special );
When I get the special type, I know that it's an instance of my SpecialType, so I marshal it over using Marshal.PtrToStructure.
SpecialCSharpType scs = Marshal.PtrToStructure( special, typeof( SpecialCSharpType ) );

The funny thing is that when the previous line executes, the application just totally crashes. I can wrap it in exception handling but to no avail.
My question is, does the marshalling of a struct that contains VARIANTs require some sort of special handling?
Any help is appreciated. Thanks,
mj

From http://www.developmentnow.com/g/21_2003_9_8_0_0/dotnet-framework-interop.htm

Posted via DevelopmentNow.com Groups

Re: Struct w/ VARIANT Marshalling

Willy Denoyette [MVP]
4/24/2008 12:00:00 AM

[quoted text, click to view]

The reason is that the PInvoke marshaler has no idea what object refers to,
you have to custom marshal the structure yourself.
Her is a complete sample to get you started.

// C# file using n1.dll
using System;
using System.Runtime.InteropServices;
using System.Security;

struct stn1
{
internal object a;
internal object b;
}

public class Test
{
static CallBackDelegate cb;
public static void Main(string[] args)
{
cb = new CallBackDelegate(Test.Target1);
NativeFunc(cb);
}
static void Target1(IntPtr pst)
{
stn1 st = new stn1();
st.a = Marshal.GetObjectForNativeVariant(Marshal.ReadIntPtr(pst));
st.b = Marshal.GetObjectForNativeVariant(Marshal.ReadIntPtr(new
IntPtr(pst.ToInt32() + offSet)));
Console.WriteLine("{0} {1}", st.a, st.b);
}

public delegate void CallBackDelegate(IntPtr pst);
[DllImport("n1.dll"), SuppressUnmanagedCodeSecurity]
internal static extern void NativeFunc(CallBackDelegate callback);
}

// file: n1.cpp
// Compile with cl /EHsc /LD n1.cpp
#include <windows.h>
#include <cstdio>
#include <comdef.h>
#include <comutil.h>
struct SpecialType{
VARIANT *a;
VARIANT *b;
};

typedef void (__stdcall *RunTest)(SpecialType *st);
extern "C" void __declspec(dllexport) __stdcall NativeFunc(RunTest test)
{
SpecialType *st = new SpecialType();
BSTR bstr1 = SysAllocString(L"This is a BSTR in a VARIANT.");
VARIANT v1;
v1.vt = VT_BSTR;
v1.bstrVal = bstr1;
int i = 42;
VARIANT v2;
v2.vt = VT_I4;
v2.lVal = i;
st->a = &v1;
st->b = &v2;
test(st);
}

Willy.