Should I use a reference or an instance of C# objects in a C++/CLI class?

Question

In a managed c++ class, should I be using a reference or an instance of a C# class that I've implemented in another library?

Consider this example:

// MyManagedClass.h
#pragma once

using namespace System::Collections::Generic;
using namespace My::Namespace::MyCSharpLib;

namespace My::Namespace::MyManagedLib
{
    public ref class MyManagedClass
    {
    public:
        MyCSharpClass myInst; // i have an instance!
        MyCSharpClass ^myRef; // need to do gcnew

        List<MyCSharpClass ^> listInst; // i have an instance!
        List<MyCSharpClass ^> ^listRef; // need to do gcnew
    };
}

And then the managed class is called from C# code:

// driver.cs
using My.Namespace.MyCSharpLib;
using My.Namespace.MyManagedLib;

public class Driver
{
    private static void Main(string[] args)
    {
        MyManagedClass mmc = new MyManagedClass();
        DoStuff(mmc);
    }
}

My gut tells me I should be using myRef and listRef because that's what I'd be doing if this was implemented in C#. But why am I allowed to directly instantiate an instance of MyCSharpClass? What are the repercussions of doing this? If my class only ever has one collection of MyCSharpClass objects, is there harm is directly initializing the collection?

Answer 1

C++/CLI has a feature called stack semantics, which you are using when you declare a reference type member as though it were a value type (MyCSharpClass myInst;).

gcnew is still being called, but you don't see this code because the compiler will inject it automatically into your default constructor. Beware that it will also generate code to dispose myInst!

Below is a (pseudo) C++/CLI code equivalent of the MSIL that the compiler will emit for your class:

Constructor:

MyManagedClass()
{
    myInst = gcnew MyCSharpClass();
}

Dispose:

void Dispose(bool dispose)
{
    if (dispose)
    {
        try
        {
            this->~MyManagedClass();
        }
        finally
        {
            delete myInst;
        }
    }
}

EDIT:

Regarding your question about repercussions: manually allocating with gcnew means that when your MyManagedClass objects die, the object pointed to by myRef will still hang around until the garbage collector cleans it up; whereas by using stack semantics you have a more deterministic means of controlling object lifetimes without having to write a Dispose method yourself.

It also means that when using stack semantics you must be careful who you share the objects with...