SWIG_csharp_string_callback 在将字符串 (const char*) 从 C++ 传递到 C# 时会导致内存泄漏

Question

I'm facing a memory leak when passing string (const char*) arguments from C++ to C# using swig directors. I found a similar question in swig forums with some valuable advices, however, the set of correct typemaps were missing (the issue is unresolved even in the current swig version 2.0.11).

After spending several days of googling and investigating the swig code I finally wrote a set of typemaps which fixed the problem for me.

I hope this question and posted answer will be helpful.

Answer 1

Here are the set of typemaps for char* which did the job for me.

The idea is to pass char* as an IntPtr to C# then convert it into a C# string using InteropServices.Marshal.StringToHGlobalAnsi() (The C# string will be destroyed by GC). Similarly, when passing a string from C# to C++ we convert it into an IntPtr with InteropServices.Marshal.StringToHGlobalAnsi() method (and ensure that the object will be finally destroyed once the call returns).

// Alternative char * typemaps.
%pragma(csharp) imclasscode=%{
  public class SWIGStringMarshal : IDisposable {
    public readonly HandleRef swigCPtr;
    public SWIGStringMarshal(string str) {
      swigCPtr = new HandleRef(this, System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(str));
    }
    public virtual void Dispose() {
      System.Runtime.InteropServices.Marshal.FreeHGlobal(swigCPtr.Handle);
      GC.SuppressFinalize(this);
    }
    ~SWIGStringMarshal()
    {
        Dispose();
    }
  }
%}

%typemap(ctype) char* "char *"
%typemap(cstype) char* "string"
// Passing char* as an IntPtr to C# and then convert it to a C# string.
%typemap(imtype, out="IntPtr") char *  "HandleRef"

%typemap(in) char* %{$1 = ($1_ltype)$input; %}
%typemap(out) char* %{$result = $1; %}

%typemap(csin) char* "new $imclassname.SWIGStringMarshal($csinput).swigCPtr"
%typemap(csout, excode=SWIGEXCODE) char *{
    string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
    return ret;
}
%typemap(csvarin, excode=SWIGEXCODE2) char * %{
    set {
        $imcall;$excode
} %}

%typemap(csvarout, excode=SWIGEXCODE2) char * %{
    get {
        string ret = System.Runtime.InteropServices.Marshal.PtrToStringAnsi($imcall);$excode
        return ret;
} %}

%typemap(directorout) char* %{$result = ($1_ltype)$input; %}
%typemap(csdirectorout) char * "$cscall"

%typemap(directorin) char * 
%{
    $input = (char*)$1;
%}
%typemap(csdirectorin) char* "System.Runtime.InteropServices.Marshal.PtrToStringAnsi($iminput)";

ps. I tested the typemaps on Windows 32/64 as well as on Linux 64 operating systems.

Answer 2

This is a known bug, an it has been reported years ago in SWIG org, see https://github.com/swig/swig/issues/283 and https://github.com/swig/swig/issues/998

This bug has not been fixed in latest version (until now is version 4.0.2).

The bug of the code is in swig\\Lib\\csharp\\std_string.i. With the bug, when there is callback with string, it generates function like this in C++ in my application:

void SwigDirector_MyCode::LogDebug(std::string const &message) {
  char * jmessage = 0 ;
  if (!swig_callbackLogDebug) {
    throw Swig::DirectorPureVirtualException("SDS::ISDSLogger::LogDebug");
  } else {
    jmessage = SWIG_csharp_string_callback((&message)->c_str());
    swig_callbackLogDebug(jmessage);
  }
}

The LogDebug shall be called from C++ code.

In the code, the jmessage is new allocated memory. You can verify it you change the first char in the jmessage after the call, and you can see the (&message)->c_str() is not changed.

There are ideas saying that the free() or delete shall be called to deallocate the memory created from SWIG_csharp_string_callback().

But this is not working for me. I am using SWIG to generate C# wrapper from C++.

My solution is to define new typemap for the type std::string const & in my project .i file.

%typemap(directorin) const std::string & %{ $input = const_cast<char *>($1.c_str()); %}

So my generated code becomes:

void SwigDirector_MyCode::LogDebug(std::string const &message) {
  char * jmessage = 0 ;

  if (!swig_callbackLogDebug) {
    throw Swig::DirectorPureVirtualException("MyCode::LogDebug");
  } else {
    jmessage = const_cast<char *>((&message)->c_str()); 
    swig_callbackLogDebug(jmessage);
  }
}

In this code, jmessage is not allocated anymore.

It has been tested on Debian 9 mono and Windows 7 with VS2017.