C ++ / CLI - C＃Interop - 字符串转换内存泄漏

Question

I need to expose some existing .NET logic (ie assembly MyManaged.dll) to native code, so I've decided to create C++/CLI bridge . I've created C++/CLI project and added an reference to MyManaged.dll. Long story in short - it works - I've succeeded to access everything that should be accessible form native code.

But big issue is that my implementation leaks memory. After days of testing and researching I've narrowed problem down to System::String <-> const wchar_t conversion. Finally I've created a trivial C++/CLI project that demonstrates (reproduces) the issue:

#define EXPORTED __declspec(dllexport)

System::String^ ToManaged(const wchar_t* unmanagedString)
{
    return gcnew System::String(unmanagedString);
}

const wchar_t* ToUnmanaged(System::String^ managedString)
{
    return (wchar_t*) System::Runtime::InteropServices::Marshal::StringToHGlobalUni(managedString).ToPointer();
}

EXPORTED const wchar_t* __stdcall GetString(const wchar_t* dummy)
{
    return ToUnmanaged(ToManaged(dummy));
}

(If it isn't obvious from the previous code - I'm pretty new in C++/CLI)

As I've mentioned the code works but accumulates memory consumption so there's definitely a leak in System::String <-> const wchar_t conversion.

My question is obvious: how to implement string conversion without the leak.

Thanks!

Answer 1

You need to free the pointer from StringToHGlobalUni after you've used it. Use Marshal.FreeHGlobal or LocalFree .

Answer 2

While not built to your exact api, I think this addresses the memory

HRESULT GetString(BSTR* p_bstrResult, unsigned long* ulErrCode)
{
    HRESULT hr = S_OK;

    try
    {
        System::String ^systemstring = gcnew System::String("");
                    DotNetObject::o = gcnew  DotNetObject:: DotNetObjectComponent();
        *ulErrCode = (unsigned long)o->GetString(systemstring); 
        pin_ptr<const wchar_t> wch = PtrToStringChars(systemstring);
        _bstr_t bstrt(wch);
        *p_bstrResult = bstrt.GetBSTR(); // native client babysits
        delete systemstring;        
    }
    catch(Exception ^ ex)
    {

    }   
    return hr;

}

Answer 3

UPDATE : Please ignore negative voter - as you can see he even refused to explain what is wrong here. Different people have different motives... One thing is for sure: solution provided here works perfectly, without any memory leak.

I've found the solution (based on Overview of Marshaling in C++ and marshal_context::marshal_as ). So the following should be changed:

#include <msclr\marshal.h>

System::String^ ToManaged(const wchar_t* unmanagedString)
{
    return msclr::interop::marshal_as<System::String^>(unmanagedString);
}

gcroot<msclr::interop::marshal_context^> context;

const wchar_t* ToUnmanaged(System::String^ managedString)
{        
    msclr::interop::marshal_context^ unpacked = context;

    if (unpacked != nullptr)
        delete unpacked;

    context = gcnew msclr::interop::marshal_context();

    return context->marshal_as<const wchar_t*>(managedString);
}

NOTE: Here I've implemented very clumsy handling of marshal_context instance - when the next call arrives, the result from the previous call is deleted. This implementation would fall apart in multi-threading scenario, so you should implement a better one having the following in mind:

• marshal_context instance can be used for multiple calls, but it should be deleted every now and then (to free the memory from previously marshaled strings);
• As soon as marshal_context is deleted - all const wchar_t* crated by using it are also deleted. It means that you should not delete context immediately after using it, but you need to provide enough time for calling code to actually get the resulting string.