使用c ++ / cli interop管理内存

Question

Most of the code I have seen deletes the pointer in the finalizer/destructor:

public ref class CPPObjectWrapper
{
private:
    CPPObject *_cppObject;
public:
    CPPObjectWrapper()
    {
        _cppObject = new CPPObject();
    }

    CPPObjectWrapper(IntPtr ^ptr)
    {
        _cppObject = ptr->ToPointer();
    }

    ~CPPObjectWrapper()
    {
        delete _cppObject;
        _cppObject = 0;
    }

    !CPPObjectWrapper()
    {
        if (_cppObject != 0) delete _cppObject;
    }

    IntPtr^ GetPointer()
    {
        return gcnew IntPtr(_cppObject);
    }
}

My question is what would be standard practice if the library your wrapping does something like this:

void AddObject(CPPObject *cppObject)
{
    // adds to a std::list
}

CPPObject* FindObject(/* criteria */)
{
    // return reference to std::list item based on criteria
}

If your c# wrapper does this:

void AddObject(CPPObjectWrapper ^cppObject)
{
    _internal->addObject(cppObject->GetPointer()->ToPointer());
}

CPPObjectWrapper^ FindObject(/* criteria */)
{
    CPPObject *cppObject = _internal->findObject(/* criteria */);

    return gcnew CPPObjectWrapper(gcnew IntPtr(cppObjet));
}

You run into a memory issue because your managed object should not delete the pointer because its referenced in another object. The same is true when returning. Would you simply add functionality to tell your managed wrapper not to free the memory when ownership is transferred?

Answer 1

A classic situation when dealing with mixed mode projects, and your suggestion is OK!

It would make sense to have a bool in the constructor that tells it not to destroy the pointer if the same object is used in another non-wrapped object. The ideal case is that every object was wrapped, and the destruction would be done by the CLR.

You can make a generic base class out of this (using the code you already have there), setting the bool by default by the subclass. You are guaranteed to have this functionality many times over. Another tip is to have a virtual OnFinalize() method that is called from the CLR destructor (!) that can do special operations in the subclass, like calling some special free function provided by the native library.