Maybe this is what you are looking for?

// CS file sample program passing callback function pointers through a
structure
using System;
using System.Runtime.InteropServices;

public delegate void CalcDelegate(int arg1, int arg2);
[StructLayout(LayoutKind.Sequential)]
struct FunctionTable
{
 public IntPtr fAdd;    // function pointer pointing to AddMethod
 public IntPtr fMult;    // function ptr pointing to MultMethod
}
class Tester
{
 [DllImport("native.dll")]
 public static extern void NativeCaller(FunctionTable ft);

 [DllImport("msvcrt")]
 public static extern IntPtr strncpy(Delegate pd, IntPtr src, int size);

 static CalcDelegate pd;
 public static void Main()
 {
  FunctionTable ft = new FunctionTable();

  pd = new CalcDelegate(AddMethod);
  ft.fAdd = GetFunctionPtrFromDelegate(pd);
  pd = new CalcDelegate(MultMethod);
  ft.fMult = GetFunctionPtrFromDelegate(pd);
  NativeCaller(ft);
 }
 // here is the trick, we use a msvcrt function to return a pointer from
the delegate
 static IntPtr GetFunctionPtrFromDelegate(Delegate d)
 {
  // strncpy returns the buffer address (the marshaled delegate pointer).
We obviously don't copy anything
  return strncpy(d, IntPtr.Zero, 0);
 }

 static void AddMethod(int arg1, int arg2)
 {
  Console.WriteLine(arg1 + arg2);

 }
 static void MultMethod(int arg1, int arg2)
 {
  Console.WriteLine(arg1 * arg2);
 }
}

//C++ file native.cpp
// compile with: cl /LD native.cpp
struct FunctionTable
{
  void* fAdd;
  void* fMult;
};
  typedef int (__stdcall *FPTRHELPER) (int, int);

extern "C" {
__declspec(dllexport) void  NativeCaller (FunctionTable);
}

void NativeCaller(FunctionTable fptr)
{

(*(FPTRHELPER)fptr.fAdd)(5, 2);
(*(FPTRHELPER)fptr.fMult)(5, 2);

}

Willy.