Extended NativeAOT library tooling

[Danielku15]

With the Native AOT landing in .net 7 I was wondering about the plans around providing a reverse C++/CLI experience.

The https://github.com/dotnet/samples/tree/main/core/nativeaot/NativeLibrary shows a very (very) basic example how to expose functionality written in .net to the Native world but realistically it is not really feasable to write some advanced libraries in .net.

As a library author you need to:

1. Write a C-style layer on top of your OOP library
2. Write a C++ style layer hiding away the complexity of interacting with the C-style layer and providing an OOP experience.

Instantly my code-generation bells were ringing and I concluded: This has to be automatable in some tooling. Just like https://github.com/mono/CppSharp is doing this from the C++ world to the .net world it would be amazing to have a certain tooling which allows you to expose selected classes/namespaces "simply" to the native world with an OOP experience.I started with a very hacky PoC for my library to use a Source Generator for generating the C-style layer and beside some aspects like generics I made quickly some good progress.

Of course quite some complexities have to be solved to ensure correct memory management (GCHandle pinning) and marshalling of types to avoid unexpected side effects.

Have there been any discussions towards such a tooling?

[kevingosse]

If that can help, this is an approach I experimented with: https://www.youtube.com/watch?v=eE0AbO5_XSw&ab_channel=Dotnetos
https://github.com/kevingosse/Dotnetos2022/tree/master/NativeObjectsSourceGenerator

Is it the kind of thing you had in mind?

[Danielku15]

From a first glance your experiment looks like a mechanism to host/wrap C++ objects in the .net world so that it will play well together with AOT. Still need to watch the video though to grasp the details 😁

My usecase would be to expose the C# classes into the C++ world for usage. I am working currently on a PoC where you write a lib like this:

namespace MyLib;

public class Person
{
    public string FirstName {get;set;}
    public string LastName {get;set;}
    public DateTime Birthday { get;set;}
    
    public int GetAge(DateTime now) 
    {
        return (int)(now - Birthday).TotalYears;
    }
}

Then the source generator adds something like:

namespace MyLib;

public class PersonNativeApi
{
    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_get_FirstName")]
    public static IntPtr get_FirstName(IntPtr thisPtr)
    {
        var returnValue = ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).FirstName;
        return System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(returnValue);
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_set_FirstName")]
    public static void set_FirstName(IntPtr thisPtr, IntPtr value)
    {
        ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).FirstName = System.Runtime.InteropServices.Marshal.PtrToStringUni(value);
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_get_LastName")]
    public static IntPtr get_LastName(IntPtr thisPtr)
    {
        var returnValue = ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).LastName;
        return System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(returnValue);
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_set_LastName")]
    public static void set_LastName(IntPtr thisPtr, IntPtr value)
    {
        ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).LastName = System.Runtime.InteropServices.Marshal.PtrToStringUni(value);
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_get_Birthday")]
    public static long get_Birthday(IntPtr thisPtr)
    {
        var returnValue = ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).Birthday;
        return returnValue.ToBinary();
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_set_Birthday")]
    public static void set_Birthday(IntPtr thisPtr, long value)
    {
        ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).Birthday = DateTime.FromBinary(value);
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_GetAge")]
    public static int GetAge(IntPtr thisPtr, long now)
    {
        var returnValue = ((MyLib.Person)GCHandle.FromIntPtr(thisPtr).Target).GetAge(DateTime.FromBinary(now));
        return returnValue;
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_Constructor")]
    public static IntPtr Constructor()
    {
        var instance = new MyLib.Person();
        return GCHandle.ToIntPtr(GCHandle.Alloc(instance));
    }

    [UnmanagedCallersOnly(EntryPoint = "MyLib_Person_Destructor")]
    public static IntPtr Destructor(IntPtr thisPtr)
    {
        GCHandle.FromIntPtr(thisPtr).Free();
    }
}

And ultimately a C++ layer needs to be generated. With a code comparable to:

// Person.h
#include "dotnet/system/DateTime.h"
#include "dotnet/system/String.h"

namespace MyLib
{
    class Person
    {
    public:
        Person();
        Person(void* gcHandle);
        ~Person();
        
        std::shared_ptr<System::String> getFirstName();
        void setFirstName(std::shared_ptr<System::String> value);
        
        std::shared_ptr<System::String> getLastName();
        void getLastName(std::shared_ptr<System::String> value);
        
        std::shared_ptr<System::String> getBirthDay();
        void getBirthDay(std::shared_ptr<System::String> value);
        
        int GetAge(DateTime now);
    private:
        void* m_gcHandle;
    };
};

// Person.cpp
#include "Person.h"

void* MyLib_Person_Constructor();
void MyLib_Person_Destructor(void* thisPtr);
void* MyLib_Person_getFirstName(void* thisPtr);

MyLib::Person::Person() : this(MyLib_Person_Constructor()) {}
MyLib::Person::Person(void* gcHandle) : m_gcHandle(gcHandle) {}
MyLib::Person::~Person() { MyLib_Person_Destructor(m_gcHandle); m_gcHandle = nullptr; }
std::shared_ptr<System::String> MyLib::Person::getFirstName() { return std::make_shared<System::String>(MyLib_Person_getFirstName(m_gcHandle)); }

Then someone could use the native library written in C# using

std::unique_ptr<Person> person = std::make_unique<Person>();
person->setBirthday(DateTime(1990, 01, 01))
int age = person->GetAge(DateTime::Now);

[kevingosse]

Got it. My source generator works both ways (consuming C++ object from C#, but also exposing C# objects to C++), but yours goes one step further since you also handle the mashalling of the arguments.