How to fix memory leak when passing object from C# COM library to a C++ application

Question

I have a C++ MFC application which consumes C# COM wrapper. The issue is whenever I invoke a function inside wrapper, I am experiencing memory leak. Can anyone explain how to clean up the allocations that are made within the C# COM wrapper.

Below code blocks mimic what I was trying to do, can anyone provide me the references/rightway to pass the structure object/ clean up the memory allocation

C# wrapper exposed as COM

using System;
using System.Runtime.InteropServices;


namespace ManagedLib
{
    [ComVisible(true)]
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct comstructure
    {
        
        public string[] m_strName;
         
        public UInt32[] m_nEventCategory;
    }


    [Guid("4BC57FAB-ABB8-4b93-A0BC-2FD3D5312CA8")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    [ComVisible(true)]
    public interface ITest
    {
        
        comstructure  TestBool();

         
    }

    [Guid("A7A5C4C9-F4DA-4CD3-8D01-F7F42512ED04")]
    [ClassInterface(ClassInterfaceType.None)]
    [ComVisible(true)]    
    public class Test : ITest
    {
        public comstructure TestBool( )
        {
            comstructure testvar = new comstructure();

            testvar.m_strName = new string[100000];
            testvar.m_nEventCategory = new UInt32[100000];
            return testvar;
        }
                 
    }
}

C++ code

#include <iostream>
#include <afx.h>
#include <afxwin.h>         
#include <afxext.h>         
#include <afxdtctl.h>   
#include "windows.h"
#include "psapi.h"
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>          
#endif // _AFX_NO_AFXCMN_SUPPORT

#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS  
#include <atlbase.h>
#import "..\comlibrary\bin\Debug\comlibrary.tlb"
comlibrary::ITest* obj;
class mleak
{

public:


   void leakmemory()
   {
       comlibrary::comstructure v2;
       v2 = obj->TestBool();

       
   }
};
   int main()
   {


       CoInitializeEx(nullptr, COINIT_MULTITHREADED);
       CLSID clsid;
       HRESULT hResult = ::CLSIDFromProgID(L"ManagedLib.Test", &clsid);
       hResult = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
           __uuidof(comlibrary::ITest), (void**)&obj);
       std::cout << hResult;
       if (FAILED(hResult))
       {
           std::cout << "COM import failed!\n";
       }
        

       mleak m1;
       for (int i = 0; i < 600; i++)
       {
            
           m1.leakmemory();
           Sleep(100);
       }

       return 0;
   }

Answer 1

You should release memory if it's allocated and no-one else frees it, obviously. Here, the allocated memory is the .NET's string[] and uint[] which are represented as SAFEARRAY* in the native world.

But, long story short: you can't really use structs as return type for COM methods. It's causes not only copy semantics issues (who owns struct's field memory, etc.), but in general, it won't even work depending on struct size, etc. lots of trouble, COM methods should return 32/64 bit-sized variables (or void).

So you can fix this using COM objects instead of structs. For example:

[ComVisible(true)]
public interface IOther
{
    string[] Names { get; set; }
    uint[] EventCategories { get; set; }
}

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
public class Other : IOther
{
    public string[] Names { get; set; }
    public uint[] EventCategories { get; set; }
}

[ComVisible(true)]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface ITest
{
    Other TestOther();
}

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
public class Test : ITest
{
    public Other TestOther()
    {
        var other = new Other();
        other.Names = new string[100000];
        other.EventCategories = new UInt32[100000];
        return other;
    }
}

and in C++ side:

#include "windows.h"
#import "..\ManagedLib\bin\Debug\ManagedLib.tlb"

using namespace ManagedLib;

int main()
{
    CoInitializeEx(nullptr, COINIT_MULTITHREADED);
    {
        ITestPtr test; // see https://stackoverflow.com/a/16382024/403671
        auto hr = test.CreateInstance(__uuidof(Test));
        if (SUCCEEDED(hr))
        {
            IOtherPtr other(test->TestOther());
            auto names = other->Names;

            // do what you want with safe array here
            // but in the end, make sure you destroy it
            SafeArrayDestroy(names);
        }
    }
    CoUninitialize();
    return 0;
}

Note: you can also use CComSafeArray to ease SAFEARRAY programming.