Skip to main content

NativeObjects by Kevin Gosse

Nuget / site data​

Nuget GitHub last commit GitHub Repo stars

Details​

Info​

info

Name: NativeObjects

Source generator for native interop. Generates implementation for interfaces to expose managed objects as COM-like, or call methods on COM-like native objects.

Author: Kevin Gosse

NuGet: https://www.nuget.org/packages/NativeObjects/

You can find more details at https://github.com/kevingosse/NativeObjects

Source : https://github.com/kevingosse/NativeObjects

Original Readme​

note

NativeObjects

Source-generator for easier native interop.

It provides two core features:

  • Ability to consume COM-like native objects
  • Ability to expose managed objects as COM-like native objects

Usage

Remember to enable unsafe on your project when referencing this source-generator

<PropertyGroup>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>

Declare the interface you want to consume or expose, and decorate it with the [NativeObject] attribute:


[NativeObject]
public interface ICalculator
{
    int Add(int value1, int value2);
}

The order of the methods is used to build the vtable. Therefore you MUST declare the methods in your interface in the same order as the native object.

From there, you can consume a native object that implements this interface:

public int DoSomething(IntPtr nativePtr)
{
    var calc = NativeObjects.ICalculator.Wrap(nativePtr);

    return calc.Add(2, 3);
}

Or implement that interface then expose the managed object to native code:

public class MyCalculator : ICalculator
{
    public int Add(int value1, int value2)
    {
        return value1 + value2;
    }
}

var calculator = new MyCalculator();
using (var nativeCalculator = NativeObjects.ICalculator.Wrap(calculator))
{
    // nativeCalculator can be implicitly cast to IntPtr
    // This is equivalent to calling nativeCalculator.Object
    SomeNativeCode((IntPtr)nativeCalculator);
}

The generated objects have the same visibility as the interface. For instance, if the interface is declared as internal, the generated objects will be internal.

Namespace

By default, the interop types are emitted in the NativeObjects namespace. You can change it by adding an attribute at the assembly level:

[assembly: NativeObjectsNamespace("MyNamespace")]

About​

note

Object to IntPtr and back

How to use​

Example ( source csproj, source files )​

This is the CSharp Project that references NativeObjects

<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    </PropertyGroup>
    <ItemGroup>
      <PackageReference Include="NativeObjects" Version="1.3.0" OutputItemType="Analyzer" ReferenceOutputAssembly="false"  />
    </ItemGroup>
    <PropertyGroup>
        <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
        <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)\GX</CompilerGeneratedFilesOutputPath>
    </PropertyGroup>
</Project>

Generated Files​

Those are taken from $(BaseIntermediateOutputPath)\GX

namespace NativeObjects
{
    
    using System;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;

    public unsafe class ICalculator : IDisposable
    {
        private ICalculator(ICalculator implementation)
        {
            const int delegateCount = 1;

            var vtable = (IntPtr*)NativeMemory.Alloc((nuint)delegateCount, (nuint)IntPtr.Size);

            *(vtable + 0) = (IntPtr)(delegate* unmanaged<IntPtr*, int, int, int>)&Exports.Add;


            var obj = (IntPtr*)NativeMemory.Alloc((nuint)2, (nuint)IntPtr.Size);
            *obj = (IntPtr)vtable;

            var handle = GCHandle.Alloc(implementation);
            *(obj + 1) = GCHandle.ToIntPtr(handle);

            Object = (IntPtr)obj;
        }

        public IntPtr Object { get; private set; }

        public static ICalculator Wrap(ICalculator implementation) => new(implementation);

        public static ICalculatorInvoker Wrap(IntPtr ptr) => new(ptr);

        public static implicit operator IntPtr(ICalculator stub) => stub.Object;

        public void Dispose()
        {
            if (Object != IntPtr.Zero)
            {
                var target = (void**)Object;
                NativeMemory.Free(*target);
                NativeMemory.Free(target);
                Object = IntPtr.Zero;
            }
        }

        private static class Exports
        {
            [UnmanagedCallersOnly]
            public static int Add(IntPtr* self, int __arg0, int __arg1)
            {
                var handle = GCHandle.FromIntPtr(*(self + 1));
                var obj = (ICalculator)handle.Target;
                var result = obj.Add(__arg0, __arg1);
                return result;
            }



        }
    }

    public unsafe struct ICalculatorInvoker
    {
        private readonly IntPtr _implementation;

        public ICalculatorInvoker(IntPtr implementation)
        {
            _implementation = implementation;
        }

        public static implicit operator IntPtr(ICalculatorInvoker invoker) => invoker._implementation;

        private nint* VTable => (nint*)*(nint*)_implementation;

        public  int Add(int value1, int value2)
        {
            var __func__ = (delegate* unmanaged[Stdcall]<IntPtr, int, int,  int>)*(VTable + 0);
            return  __func__(_implementation, value1, value2);
        }
 
    }

}

Usefull​

Download Example (.NET C# )​

tip

Download Example project NativeObjects

Share NativeObjects​

https://ignatandrei.github.io/RSCG_Examples/v2/docs/NativeObjects

In the same category (WinAPI) - 2 other generators​

Com​

Microsoft.Windows.CsWin32​