Or, if you can move the C#-layer logging functions into a DLL that can be referenced by the C++/CLI code, just call it directly from the Logger class as above, in place of the call to Console::WriteLine.

Yet another option (though it seems needlessly complicated to me) would be to define an interface class with a Log method, pass that to the constructor of Logger (saving it in a field), and call that from within Logger::Log.

I have C# project which uses unmanaged/native C++ project. I have wrapped these managed C# and unmanaged C++ stuff using C++/CLI. That unmanaged dll will send logs asynchronously during procedure and those logs need to be catch on C# side where the “real” logging is.

So first I need to set callback interface RegisterLogger(ILogger *logger) (C# -> C++/CLI -> Unmanaged C++).
Then by using this callback unmanaged C++ will report these logs to upper level (unmanaged C++ -> C++/CLI -> C#). I have already managed to implement this “calling chain” (thanks to you) like this C# -> C++/CLI -> unmanaged C++ -> C++/CLI. So only last step is missing.

ILoggerWrapper is created because that C++/CLI wrapper should provide pure .NET interface to C#.

In C# side it might look something like this:

public class LoggerAdaptation : ILoggerWrapper
{
private ILoggerWrapper loggerWrapper;

public void OnLog(LogEventArgs e)
{
EventHandler handler = this.Log;
if (handler != null)
{
handler(this, e);
}
}
}


Was that any better explanation, do you see my problem?

The point of the code in the example is to allow some existing native code to call up to your “real” logger in the managed code. If you have other C# code that wants to log something, just call your logger directly — you don’t need any of this.

Then this wrapped interface needs to be inherited:

public ref class Logger : ILoggerWrapper
{
public:
Logger()
{
m_Logger = new NativeLogger(gcnew LogDelegate(this, &Logger::Log));
NativeFramework::RegisterLogger(m_Logger);
}
~Logger()
{
this->!Logger();
}
!Logger()
{
delete m_Logger;
m_Logger = NULL;
}

private:
NativeLogger *m_Logger;
};


But now I’m a bit lost since I provide LogWrap function for C# user but native callback calls Log function. How I can handle this in above code?