C# p/invoke: marshaling class between C# and C++ class
Jin
Tu
Blog:
http://www.inblogs.net/havdone
1.0 Abstraction
This article provides basic information to realize how pass c# function pointer and class object to a c++ function as parameters.
2.0 Mechanism
The c++ function parameters could be an object pointer or a function pointer. Passing c# class object or a function as parameter to c++ function actually is passing a C# reference or a function pointer. To realize this mechanism properly, first should make sense of the basic knowledge in its scope.
3.0 Basic knowledge
3.1 C# pointer (*)
The c# unsafe code can use pointer directive
(*). However, c# pointer has many constraints. As stated in MSDN, “C# pointer types do not
inherit from object and no conversions exist between pointer types and object.
Also, boxing and unboxing do not support pointers. However, you can convert
between different pointer types and between pointer types and integral types.”
“Any of the following types may be a pointer type:
- sbyte, byte, short, ushort, int, uint, long, ulong,
char, float, double, decimal, or bool.
- Any enum type.
- Any pointer type.
- Any user-defined struct type that contains fields of
unmanaged types only.”
That means c# cannot make conversion
from class object reference to pointer type (*). Using “&” operator on a
reference, will cause a compiling error “Cannot take the address of, get the
size of, or declare a pointer to a managed type”.
3.2 Reference parameters in C#
While
reference object, such as a class object, is pass to function as a parameter,
actually the address of object is passed, as reference is a pointer type.
3.3 Class
data type in memory
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
class Class1
{
public int
i;
private int
_i;
public System.Collections.ArrayList arr = new
System.Collections.ArrayList();
public void
test()
{
Console.WriteLine("hello world!");
}
public Class1()
{
_i = 400;
}
};
The above graph shows how a Class1 object is allocated memory.
3.4 Delegate
in C#
“The delegate
keyword is used to declare a reference type that can be used to encapsulate a
named or an anonymous method.”(MSDN)
4.0 Marshaling Example
This example passes class object that mentioned in chapter 3.3, to a c++ dll. C++ code use a class type object to accept the fields values of c# object and use a function pointer parameter to accept c# object function.
/////////////////////////////////////////////////////////
//C# Code
///////////////////////////////////////////////////////////
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Runtime.InteropServices;
namespace
interoperation
{
class Program
{
//////////////////////////////////////////////////////////
//P/Invoke a c++ function declare
///////////////////////////////////////////////////////////
//if do not explcit point out entrypoint
//the c# function name must be the same with
c++ code
[System.Runtime.InteropServices.DllImport("..\\..\\..\\debug\\sort.dll")]
public static
extern void
func(Class1 arrays, Program.delgFunc func);
//////////////////////////////////////////////////////////
//C# function pointer declare
///////////////////////////////////////////////////////////
public delegate
void delgFunc();
static void
Main(string[] args)
{
Class1
obj = new Class1();
Program.delgFunc delg = obj.test;
//pass a
class reference and a function pointer to c++ function
func(obj, delg);
}
};
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
class Class1
{
public void
test()
{
Console.WriteLine("c# function is called");
Console.WriteLine("_i="+this._i.ToString());
}
public System.Collections.ArrayList arr = new
System.Collections.ArrayList();
private int
_i;
public int
i;
public Class1()
{
_i = 400;
i = 333;
}
};
}
/////////////////////////////////////////////////////////
//C++ Code
///////////////////////////////////////////////////////////
// Sort.cpp : Defines the
exported functions for the DLL application.
//
#include "stdafx.h"
#include <iostream>
using namespace std;
extern "C"
{
//////////////////////////////////////////////////////////////////////
//To accept C# class object,
//remember c++ fileds are allocated memory sequentially
///////////////////////////////////////////////////////////////////////
class Class1
{
public :
void * unknow;//accept arr
of c# object
int _i;//accept _i of c#
object
int i; //accept i of c# object
};
__declspec(dllexport) void
func(Class1* class1,void (* test)())
{
cout<<"(C# object is passed !) The value of private field '_i': "<<class1->_i<<"\n";
cout<<"(C# object is passed !) The value of public field 'i': "<<class1->i<<"\n";
test();
}
}
The output like this:
