Will mixed mode assemblies (C++/CLI projects) work on .NET Core?

Question

I have a code base that uses a C++/CLI project which exposes C++ classes to the CLR via thin wrapper classes. For example...

C++ code in a C++ project

class Foo {
    public Foo(bool wat) { /* do the things */ }
};

C++/CLI code in a mixed-mode assembly (C++/CLI project)

public ref class ManagedFoo {
    Foo * foo;
public:
    ManagedFoo (bool wat) { foo = new Foo(wat); }
    !ManagedFoo () { delete foo; }
    ~ManagedFoo () { this->!ManagedFoo (); }
};

As far as I know, mixed-mode assemblies will pretty much only run on Windows .NET. I'm hoping I don't need to re-factor the components and use P/Invoke, which would give me cross-platform support.

Does anyone know if .NET Core will support mixed mode assemblies? Other ideas are welcome.

Answer 1

Unmanaged code in context of C++/CLI is always platform specific and is compiled for a specific OS (Windows) and specific CPU architecture (x86/x64). Unmanaged code in C++/CLI ends up being much like actual C++ code compiled using a C++ compiler. Since mixed mode assemblies can contain native code, they are bound to a specific OS and CPU architecture.

EDIT (March 2019): This answer predates .Net Core and may be out of date in Core context.

Answer 2

Whether or not a mixed mode assembly works with .NET Core is not determined by platform specific code. Support for mixed mode assemblies is being worked on in:

https://github.com/dotnet/coreclr/issues/18013

As far as I understand this will require recompiling C++/CLI projects to target .NET Core.

Of course, a mixed mode assembly with x86 code for Windows will only work as x86 in Windows and so on.