Using the DllImportGenerator (easily)

[f2bo]

I'm interested in looking at how the DllImportGenerator handles marshaling for certain struct patterns in P/Invoke. I would like to test a few scenarios and it's unclear (to me) how to acquire the source generator only. I assume that cloning this repo and spending some time reading the docs to learn how to set up an environment to build the runtime will get me there but I'm looking for a quick start, at least for the time being.

Is there a NuGet package or any other way to quickly test the source generator?

[danmoseley]

@jkoritzinsky

[jkoritzinsky]

That package is the most recent package we have. We haven't yet set up publishing after moving from the dotnet/runtimelab repository to the dotnet/runtime repository.

Additionally, we have not implemented support for the [GeneratedMarshalling] attribute as per our design doc. I have an experimental branch for that, but I haven't had the time to finish it up and put it up for review.

I was curious to see how the source generated interop handled certain scenarios, for example, a struct with a field member that is a pointer to another struct.

For parity with our built-in interop design, we will likely treat pointer values as blittable and as a result won't marshal the pointed-to struct. That would be something that would need to be implemented with a MarshalUsing attribute and a custom marshaller.

[f2bo]

Thanks! I'm looking forward to the progress being made on this.

For parity with our built-in interop design, we will likely treat pointer values as blittable and as a result won't marshal the pointed-to struct. That would be something that would need to be implemented with a MarshalUsing attribute and a custom marshaller.

I apologize for not being clear. When I mentioned "a struct with a field member that is a pointer to another struct", I was referring to the native side. For example, the native library expects a parameter of type Foo with a pointer to a Bar field.

typedef struct
{
   ...
} Bar;

typedef struct 
{
   Bar* bar;
} Foo;

On the managed side, I would prefer to model the bar field as a reference. For example:

[StructLayout(LayoutKind.Sequential)]
class Bar
{
   ...
}

struct Foo   // or class
{
   public Bar bar;
}

I can see that this could be done manually with the following code and in fact, it's very similar to the way I'm currently doing this.

[NativeMarshalling(typeof(Native))]
public struct Foo
{
    public Bar? bar;

    [BlittableType]
    internal struct Native
    {
        public nint bar = IntPtr.Zero;

        public Native(Foo managed)
        {
            if (managed.bar is not null)
            {
                bar = Marshal.AllocHGlobal(Marshal.SizeOf<Bar>());
                Marshal.StructureToPtr(managed.bar, bar, false);
            }
        }

        public void FreeNative()
        {
            Marshal.FreeHGlobal(bar);
        }
    }
}

However, it seems something that could be automated and when I saw the struct marshaling document, I wanted to see if the source generator could handle it for me. I need to marshal several structs that follow this pattern, some of them containing more than one pointer field. Are there any plans in this regard?

[jkoritzinsky]

We've made an explicit decision to not support "layout-class" handling (automatically generating any marshalling code for user-defined class types without pre-existing rules) implicitly in the new system. Layout-class marshalling in the existing built-in system is a bug-prone area with very-hard-to-discover but easy-to-break corner cases, of which we have had to fix to avoid breaking many customers.

In your scenario, I'd suggest defining a marshaller for Bar (with the NativeMarshalling attribute) that marshals its contents to native memory and passes a pointer to that native memory as the returned value from the Value property. Then, once GeneratedMarshallingAttribute support is implemented, the [GeneratedMarshalling] attribute on your struct Foo would generate a marshaller that uses Bar's marshaller automatically, giving the behavior that you expect.

[f2bo]

I guess this will have to wait until the GeneratedMarshallingAttribute support is ready then. Thank you!

[kasperk81]

I assume that cloning this repo and spending some time reading the docs to learn how to set up an environment to build the runtime will get me there but I'm looking for a quick start, at least for the time being.

normally you can download daily build from https://github.com/dotnet/installer#installers-and-binaries. but for unknown reasons those were stopped publishing after nov. 18: dotnet/installer#12850