Managed C++/CLI

// CnvBuffLib.h

#pragma once

#include <memory.h>;
#include <string.h>;

using namespace System;

namespace CnvBuffLib
{
    public __gc class ConvertBuffer
    {
        const char __nogc * const _buffer;
        static const int bsize = 256;
        
        public:
        ConvertBuffer()
        : _buffer(new char __nogc [bsize])
        {
        }
        
        ~ConvertBuffer()
        {
            delete [] _buffer;
        }
        
        int GetPacket()
        {
            // sample of source data
            char tmp[] = {'t', 'e', 's', 't'};
            int tmplen = sizeof(tmp);
            
            // clear buffer
            char __nogc * _bp = const_cast<char*>(_buffer);
            _bp = static_cast<char*>(memset(_bp, 0, bsize));

            // copy data to buffer
            memcpy(_bp, tmp, tmplen);
            
            return tmplen;
        }

        // this function copies native buffer to managed buffer (C# side)
        SByte GetData() __gc []
        {
            int rlen = strlen(_buffer);
            if(rlen == 0)
            return 0;
            
            SByte result[] = new SByte[rlen];
            char __pin * presult = &result[0];
            
            memcpy(presult, _buffer, rlen);
            
            return result;
        }
    };
}

_bstr_t text = signedData->Sign(signer,true,CAPICOM_ENCODE_BASE64);

-signer: 0xhexvalue
 -m_pInterface: 0xhexvalue
  -IDispatch: {...}
   -IUnknown: {...}
    -__vfptr: 0xhexvalue
     [0]: values
     [1]: values
     [2]: values

- pSigner: 0xhexvalue
  -IDispatch: {...}
   -IUnknown: {...}
    -Children could not be evaluated

UserNameless wrote:

Do you think its failing because of the "Children could not be evaluated" part?

Richard Andrew x64 wrote:

That's where my suspicions would fall. Unfortunately, COM is not my strength.

Richard Andrew x64 wrote:

I'm interested to know why the "children" CAN be evaluated when the debugger is stopped on the outside of the function call, but once we go inside the function, then the children can no longer be evaluated.

Shadowsoal wrote:

looking for are instructions on what I need to do to convince a VC++ program and a VB program to talk to MyLib.dll.

$ cl /nologo /clr /LD /FeMyLib.dll MyLib.cpp UnmanagedLib.lib
$ mt /nologo /manifest MyLib.dll.manifest /outputresource:MyLib.dll;2

Shadowsoal wrote:

So I suppose the real question now is what other .NET languages are widely used, such that I should provide some example code.

KawiRider wrote:

int retval = CFunction("Dummy path", Marshal::GetFunctionPointerForDelegate(FuncDelegate).ToPointer()); // THIS LINE FAILS

delegate void FuncCallbackDelegate(String^ str, int status);

[DllImport("My_C_Dll.dll", CharSet = CharSet::Ansi, CallingConvention = CallingConvention::StdCall)]
extern "C" int CFunction(String ^src_path, FuncCallbackDelegate ^del);

    ...		

    public: void funcCallback(String^ str, int status)
    {
        printf("Passed in string: %s\n", str);	
    }	
	
    private: System::Void btnStartTest_Click(System::Object^  sender, System::EventArgs^  e) 
    {
        FuncCallbackDelegate^ FuncDelegate = gcnew FuncCallbackDelegate(this, &Form1::funcCallback);	
        int retval = CFunction("Dummy path", FuncDelegate);
    }

    ...

Mark Salsbery
Microsoft MVP - Visual C++

<br />
An unhandled exception of type 'System.Runtime.InteropServices.SEHException' occurred in driver.exe<br />
<br />
Additional information: External component has thrown an exception.<br />

int retval = CFunction("Dummy path", FuncDelegate);

#include "My_C_Dll.h"

__declspec(dllexport) int __cdecl CFunction(char *src_path,void (*func)(const char *, int))
{	
    if (func != NULL)
    {
		func("Test String", 1);
    }
    
    return 1;
}

<code>
#ifdef __cplusplus
extern "C" {
#endif
</code>
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>

	__declspec(dllexport) int __cdecl CFunction(char *src_path,void (*func)(const char *,int ));
<code>
#ifdef __cplusplus
}
#endif
</code>

delegate void FuncCallbackDelegate(String^ str, int status);
		
[DllImport("My_C_Dll.dll", CharSet = CharSet::Ansi, CallingConvention = CallingConvention::StdCall)]
extern "C" int CFunction(String ^src_path, FuncCallbackDelegate ^del);

KawiRider wrote:

I forgot to specify that we are actually using a .lib instead

delegate void FuncCallbackDelegate(String^ str, int status);

    ...

    public: void funcCallback(String^ str, int status)
    {
        printf("Passed in string: %s\n", str);	
    }	
	
    private: System::Void btnStartTest_Click(System::Object^  sender, System::EventArgs^  e) 
    {
        FuncCallbackDelegate^ FuncDelegate = gcnew FuncCallbackDelegate(this, &Form1::funcCallback);	
        int retval = CFunction("Dummy path", (void (__stdcall *)(const char *, int))Marshal::GetFunctionPointerForDelegate(FuncDelegate).ToPointer());
    }

    ...

Mark Salsbery
Microsoft MVP - Visual C++

The delegate d is converted to a function pointer that can be passed to unmanaged code using the __stdcall calling convention.
You must manually keep the delegate from being collected by the garbage collector from managed code. The garbage collector does not track reference to unmanaged code.