Feature Request: LibraryImport Support for Marshalling structs with Multiple Pinnable Items

[davidmatson]

Consider the following native code:

#include <cstdio>
#include <cstdint>

struct log_record
{
    const char16_t* message;
    const char16_t* file;
    std::int32_t line;
    std::int32_t padding;
};

extern "C" __declspec(dllexport) void log_v2(const log_record* record)
{
    if (record == nullptr || record->message == nullptr || record->file == nullptr)
    {
        return;
    }

    wprintf(L"%s(%i): %s\n", reinterpret_cast<const wchar_t*>(record->file), record->line,
        reinterpret_cast<const wchar_t*>(record->message));
}

extern "C" __declspec(dllexport) void log_v1(const char16_t* message, const char16_t* file, std::int32_t line)
{
    log_record record
    {
        message,
        file,
        line
    };

    log_v2(&record);
}

Calling log_v1 from C# using LibraryImport works nicely:

using System.Runtime.InteropServices;

static class Program
{
    static void Main()
    {
        NativeMethods.log_v1("Hello, World!", "file.cs", 123);
    }
}

static partial class NativeMethods
{
    const string libraryName = "PInvokeExampleNative.dll";

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v1(string? message, string? file, int line);
}

and generates interop code that pins both strings:

// <auto-generated/>
static unsafe partial class NativeMethods
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Interop.LibraryImportGenerator", "8.0.11.10305")]
    [global::System.Runtime.CompilerServices.SkipLocalsInitAttribute]
    public static partial void log_v1(string message, string file, int line)
    {
        // Pin - Pin data in preparation for calling the P/Invoke.
        fixed (void* __file_native = &global::System.Runtime.InteropServices.Marshalling.Utf16StringMarshaller.GetPinnableReference(file))
        fixed (void* __message_native = &global::System.Runtime.InteropServices.Marshalling.Utf16StringMarshaller.GetPinnableReference(message))
        {
            __PInvoke((ushort*)__message_native, (ushort*)__file_native, line);
        }

        // Local P/Invoke
        [global::System.Runtime.InteropServices.DllImportAttribute("PInvokeExampleNative.dll", EntryPoint = "log_v1", ExactSpelling = true)]
        static extern unsafe void __PInvoke(ushort* __message_native, ushort* __file_native, int __line_native);
    }
}

But there does not appear to be any way to call log_v2 while pinning both strings:

using System.Runtime.InteropServices;

static class Program
{
    static void Main()
    {
        NativeMethods.log_v1("Hello, World!", "file.cs", 123);
        NativeLogRecord record = new("Hello, World!", "file2.cs", 456);
        NativeMethods.log_v2(ref record);
    }
}

readonly struct NativeLogRecord(string? message, string? file, int line)
{
    public readonly string? Message = message;
    public readonly string? File = file;
    public readonly int? Line = line;
}

static partial class NativeMethods
{
    const string libraryName = "PInvokeExampleNative.dll";

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v1(string? message, string? file, int line);

    // Does not compile:
    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v2(ref NativeLogRecord record);
}

Even when using a custom marshaller for NativeLogRecord, the only option appears to be to allocate new copies of both strings in ConvertManagedToNative and then free them in Free.

For log_v2 to pin both strings like log_v1 does, the only option appears to be to use a wrapper function that handles that pinning explicitly - it's not possible to do this via a custom marshaller, as far as I can tell:

using System.Runtime.InteropServices;

static class Program
{
    static void Main()
    {
        NativeMethods.log_v1("Hello, World!", "file.cs", 123);
        NativeLogRecordNeedsManagedWrapper record = new("Hello, World!", "file2.cs", 456);
        NativeMethods.LogV2NeedsWrapperMethod(ref record);
    }
}

readonly struct NativeLogRecordNeedsManagedWrapper(string? message, string? file, int line)
{
    public readonly string? Message = message;
    public readonly string? File = file;
    public readonly int Line = line;
}

unsafe readonly struct NativeLogRecord(char* message, char* file, int line)
{
    public readonly char* Message = message;
    public readonly char* File = file;
    public readonly int Line = line;
}

static partial class NativeMethods
{
    const string libraryName = "PInvokeExampleNative.dll";

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v1(string? message, string? file, int line);

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v2(ref NativeLogRecord record);

    public static unsafe void LogV2NeedsWrapperMethod(ref NativeLogRecordNeedsManagedWrapper record)
    {
        fixed (char* message = record.Message)
        fixed (char* file = record.File)
        {
            NativeLogRecord nativeRecord = new(message, file, record.Line);
            log_v2(ref nativeRecord);
        }
    }
}

The request here is for some way to write a custom marshaller such that the generated interop code pins both strings (and the wrapper struct), without needing additional heap allocation. The goal would to be have the generated code look something like this:

```c#
// <auto-generated/>
static unsafe partial class NativeMethods
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Interop.LibraryImportGenerator", "8.0.11.10305")]
    [global::System.Runtime.CompilerServices.SkipLocalsInitAttribute]
    public static partial void log_v1(string message, string file, int line)
    {
        // Pin - Pin data in preparation for calling the P/Invoke.
        fixed (void* __file_native = &global::System.Runtime.InteropServices.Marshalling.Utf16StringMarshaller.GetPinnableReference(file))
        fixed (void* __message_native = &global::System.Runtime.InteropServices.Marshalling.Utf16StringMarshaller.GetPinnableReference(message))
        {
            __PInvoke((ushort*)__message_native, (ushort*)__file_native, line);
        }

        // Local P/Invoke
        [global::System.Runtime.InteropServices.DllImportAttribute("PInvokeExampleNative.dll", EntryPoint = "log_v1", ExactSpelling = true)]
        static extern unsafe void __PInvoke(ushort* __message_native, ushort* __file_native, int __line_native);
    }
}
static unsafe partial class NativeMethods
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Interop.LibraryImportGenerator", "8.0.11.10305")]
    [global::System.Runtime.CompilerServices.SkipLocalsInitAttribute]
    public static partial void log_v2(ref global::LogRecord record)
    {
        // Pin - Pin data in preparation for calling the P/Invoke.
        fixed (char* __record_native_pin1 = &global::LogRecordMarshaller::GetPinnableReference1(record))
        fixed (char* __record_native_pin2 = &global::LogRecordMarshaller::GetPinnableReference2(record))
        {
            global::NativeLogRecord nativeRecord = ::global::LogRecordMarshaller::ManagedToNative(record, __record_native_pin1, __record_native_pin2);

            fixed (global::NativeLogRecord* __record_native = &nativeRecord)
            {
                __PInvoke(__record_native);
            }
        }

        // Local P/Invoke
        [global::System.Runtime.InteropServices.DllImportAttribute("PInvokeExampleNative.dll", EntryPoint = "log_v2", ExactSpelling = true)]
        static extern unsafe void __PInvoke(global::NativeLogRecord* __record_native);
    }
}

From source that looks something like this (details could vary; as long as the generated code is in the shape shown above and pins both strings):

using System;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.Marshalling;

static class Program
{
    static void Main()
    {
        NativeMethods.log_v1("Hello, World!", "file.cs", 123);
        LogRecord record = new("Hello, World!", "file2.cs", 456);
        NativeMethods.log_v2(ref record);
    }
}

[NativeMarshalling(typeof(LogRecordMarshaller))]
struct LogRecord(string? message, string? file, int line)
{
    public string? Message = message;
    public string? File = file;
    public int Line = line;
}

static partial class NativeMethods
{
    const string libraryName = "PInvokeExampleNative.dll";

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v1(string? message, string? file, int line);

    [LibraryImport(libraryName, StringMarshalling = StringMarshalling.Utf16)]
    public static partial void log_v2(ref LogRecord record);
}

[CustomMarshaller(typeof(LogRecord), MarshalMode.ManagedToUnmanagedIn, typeof(LogRecordMarshaller))]
static class LogRecordMarshaller
{
    public static ref string? GetPinnableReference1(ref LogRecord managed) => ref managed.Message;

    public static ref string? GetPinnableReference2(ref LogRecord managed) => ref managed.File;

    public unsafe static LogRecord ConvertToManaged(LogRecordNative) => throw new NotImplementedException();

    public unsafe static LogRecordNative ConvertToUnmanaged(ref LogRecord managed, char* pin1, char* pin2)
    {
        return new LogRecordNative(pin1, pin2, managed.Line);
    }

    public static void Free(LogRecordNative unmanaged) { }

    public unsafe readonly struct LogRecordNative(char* message, char* file, int line)
    {
        public readonly char* Message = message;
        public readonly char* File = file;
        public readonly int Line = line;
    }
}

(Note that solving the scenario above might also open the possibility of writing a custom marshaller for a struct that includes other marshalled structs as fields, since it could provide pinnable references for each field inside.)

Overall, log_v1 works really easily today, pinning multiple strings used by the native function, but there doesn't appear to be any way to that when there's a wrapper struct, and supporting this capability in LibraryImport would be a significant improvement.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/interop-contrib
See info in area-owners.md if you want to be subscribed.

[jkoritzinsky]

This is something I'm generally interested in, but we're still trying to figure out a good pattern for.