Support arrays of types with simple custom marshalling #379

jkoritzinsky · 2020-11-23T18:01:56Z

Add support for marshalling arrays of types with simple custom marshalling (no Value property) and gracefully fail when an array of a type with complex custom marshalling (Value property) is introduced.

To do so, we create a new ArrayMarshallingInfo subtype of MarshallingInfo for the default array marshalling case and pre-calculate the element type's marshalling information instead of calculating it in MarshallingGenerator.cs

Snippet example (BoolStruct is defined as in the SharedTypes library)

User-Provided:

            [GeneratedDllImport(nameof(NativeExportsNE), EntryPoint = "and_all_members")]
            [return:MarshalAs(UnmanagedType.U1)]
            public static partial bool AndAllMembers(BoolStruct[] pArray, int length);

Generated:

namespace DllImportGenerator.IntegrationTests
{
    partial class NativeExportsNE
    {
        public partial class Arrays
        {
            public static partial bool AndAllMembers(global::SharedTypes.BoolStruct[] pArray, int length)
            {
                unsafe
                {
                    global::SharedTypes.BoolStructNative*__pArray_gen_native = default;
                    bool __retVal = default;
                    byte __retVal_gen_native = default;
                    //
                    // Setup
                    //
                    bool pArray__allocated = false;
                    try
                    {
                        //
                        // Marshal
                        //
                        if (pArray == null)
                        {
                            __pArray_gen_native = null;
                        }
                        else
                        {
                            int pArray__bytelen = sizeof(global::SharedTypes.BoolStructNative) * pArray.Length;
                            if (pArray__bytelen > 512)
                            {
                                __pArray_gen_native = (global::SharedTypes.BoolStructNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pArray__bytelen);
                                pArray__allocated = true;
                            }
                            else
                            {
                                byte *pArray__stackptr = stackalloc byte[pArray__bytelen];
                                ;
                                __pArray_gen_native = (global::SharedTypes.BoolStructNative*)pArray__stackptr;
                            }
                        }

                        if (pArray != null)
                            for (int __i = 0; __i < pArray.Length; ++__i)
                            {
                                __pArray_gen_native[__i] = new global::SharedTypes.BoolStructNative(pArray[__i]);
                            }

                        //
                        // Invoke
                        //
                        __retVal_gen_native = AndAllMembers__PInvoke__(__pArray_gen_native, length);
                        //
                        // Unmarshal
                        //
                        __retVal = __retVal_gen_native != 0;
                    }
                    finally
                    {
                        //
                        // Cleanup
                        //
                        if (pArray__allocated)
                        {
                            System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pArray_gen_native);
                        }
                    }

                    return __retVal;
                }
            }

            [System.Runtime.InteropServices.DllImportAttribute("NativeExportsNE", EntryPoint = "and_all_members")]
            extern private static unsafe byte AndAllMembers__PInvoke__(global::SharedTypes.BoolStructNative*pArray, int length);
        }
    }
}

By Value, In, Ref, Out, Return Value sample

User provided:

using System.Runtime.InteropServices;
partial class Test
{
    [GeneratedDllImport("DoesNotExist")]
    [return:MarshalAs(UnmanagedType.LPArray, SizeConst=10)]
    public static partial IntStructWrapper[] Method(
        IntStructWrapper[] p,
        in IntStructWrapper[] pIn,
        int pRefSize,
        [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] ref IntStructWrapper[] pRef,
        [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5, SizeConst=4)] out IntStructWrapper[] pOut,
        out int pOutSize
        );
}
[NativeMarshalling(typeof(IntStructWrapperNative))]
public struct IntStructWrapper
{
    public int Value;
}

public struct IntStructWrapperNative
{
    private int value;

    public IntStructWrapperNative(IntStructWrapper managed)
    {
        value = managed.Value;
    }

    public IntStructWrapper ToManaged() => new IntStructWrapper { Value = value };
}

Generated:

partial class Test
{
    public static partial global::IntStructWrapper[] Method(global::IntStructWrapper[] p, in global::IntStructWrapper[] pIn, int pRefSize, ref global::IntStructWrapper[] pRef, out global::IntStructWrapper[] pOut, out int pOutSize)
    {
        unsafe
        {
            global::IntStructWrapperNative*__p_gen_native = default;
            global::IntStructWrapperNative*__pIn_gen_native = default;
            global::IntStructWrapperNative*__pRef_gen_native = default;
            pOut = default;
            global::IntStructWrapperNative*__pOut_gen_native = default;
            pOutSize = default;
            global::IntStructWrapper[] __retVal = default;
            global::IntStructWrapperNative*__retVal_gen_native = default;
            //
            // Setup
            //
            bool p__allocated = false;
            bool pIn__allocated = false;
            try
            {
                //
                // Marshal
                //
                if (p == null)
                {
                    __p_gen_native = null;
                }
                else
                {
                    int p__bytelen = sizeof(global::IntStructWrapperNative) * p.Length;
                    if (p__bytelen > 512)
                    {
                        __p_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(p__bytelen);
                        p__allocated = true;
                    }
                    else
                    {
                        byte *p__stackptr = stackalloc byte[p__bytelen];
                        ;
                        __p_gen_native = (global::IntStructWrapperNative*)p__stackptr;
                    }
                }

                if (p != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__p_gen_native, p.Length).Clear();
                    for (int __i = 0; __i < p.Length; ++__i)
                    {
                        __p_gen_native[__i] = new global::IntStructWrapperNative(p[__i]);
                    }
                }

                if (pIn == null)
                {
                    __pIn_gen_native = null;
                }
                else
                {
                    int pIn__bytelen = sizeof(global::IntStructWrapperNative) * pIn.Length;
                    if (pIn__bytelen > 512)
                    {
                        __pIn_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pIn__bytelen);
                        pIn__allocated = true;
                    }
                    else
                    {
                        byte *pIn__stackptr = stackalloc byte[pIn__bytelen];
                        ;
                        __pIn_gen_native = (global::IntStructWrapperNative*)pIn__stackptr;
                    }
                }

                if (pIn != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__pIn_gen_native, pIn.Length).Clear();
                    for (int __i = 0; __i < pIn.Length; ++__i)
                    {
                        __pIn_gen_native[__i] = new global::IntStructWrapperNative(pIn[__i]);
                    }
                }

                __pRef_gen_native = null;
                if (pRef != null)
                {
                    int pRef__bytelen = sizeof(global::IntStructWrapperNative) * pRef.Length;
                    __pRef_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pRef__bytelen);
                }

                if (pRef != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__pRef_gen_native, pRef.Length).Clear();
                    for (int __i = 0; __i < pRef.Length; ++__i)
                    {
                        __pRef_gen_native[__i] = new global::IntStructWrapperNative(pRef[__i]);
                    }
                }

                //
                // Invoke
                //
                fixed (int *__pOutSize_gen_native = &pOutSize)
                {
                    __retVal_gen_native = Method__PInvoke__(__p_gen_native, &__pIn_gen_native, pRefSize, &__pRef_gen_native, &__pOut_gen_native, __pOutSize_gen_native);
                }

                //
                // Unmarshal
                //
                if (__retVal_gen_native != null)
                {
                    __retVal = new global::IntStructWrapper[10];
                    for (int __i = 0; __i < __retVal.Length; ++__i)
                    {
                        __retVal[__i] = __retVal_gen_native[__i].ToManaged();
                    }
                }
                else
                    __retVal = null;
                if (__pRef_gen_native != null)
                {
                    pRef = new global::IntStructWrapper[checked((int)pRefSize)];
                    for (int __i = 0; __i < pRef.Length; ++__i)
                    {
                        pRef[__i] = __pRef_gen_native[__i].ToManaged();
                    }
                }
                else
                    pRef = null;
                if (__pOut_gen_native != null)
                {
                    pOut = new global::IntStructWrapper[checked(4 + (int)pOutSize)];
                    for (int __i = 0; __i < pOut.Length; ++__i)
                    {
                        pOut[__i] = __pOut_gen_native[__i].ToManaged();
                    }
                }
                else
                    pOut = null;
            }
            finally
            {
                //
                // Cleanup
                //
                if (p__allocated)
                {
                    System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__p_gen_native);
                }

                if (pIn__allocated)
                {
                    System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pIn_gen_native);
                }

                System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pRef_gen_native);
                System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pOut_gen_native);
            }

            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe global::IntStructWrapperNative*Method__PInvoke__(global::IntStructWrapperNative*p, global::IntStructWrapperNative**pIn, int pRefSize, global::IntStructWrapperNative**pRef, global::IntStructWrapperNative**pOut, int *pOutSize);
}

…lling and gracefully fail when an array of a type with complex custom marshalling (Value property) is introduced.

DllImportGenerator/DllImportGenerator.UnitTests/Compiles.cs

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs

DllImportGenerator/DllImportGenerator/TypePositionInfo.cs

DllImportGenerator/TestAssets/NativeExports/Arrays.cs

jkotas · 2020-11-23T19:42:03Z

Could you please share code-snippets that this generates?

jkoritzinsky · 2020-11-23T19:50:24Z

I've added the example from the integration tests into the PR description. The only part that's "custom marshalling"-specific is the body of the for loop. The rest is the same array code as in the main branch.

jkotas · 2020-11-23T20:47:29Z

What is it going to do if the marshaller has FreeNative method?

jkoritzinsky · 2020-11-23T22:51:58Z

If the marshaller has a FreeNative method, the code-gen will have another for loop that calls FreeNative in the finally block right before the FreeCoTaskMem if block. The loop would look like the following:

                        if (pArray != null)
                            for (int __i = 0; __i < pArray.Length; ++__i)
                            {
                                __pArray_gen_native[__i].FreeNative();
                            }

jkotas · 2020-11-23T22:54:48Z

Does this need to account for error handling? What if the initialization of the array failed half-way through?

jkoritzinsky · 2020-11-23T23:32:13Z

If the initialization failed halfway through, the native structs should be default initialized. The implementor of the native struct should handle this scenario.

I may have to add handling for that case.

AaronRobinsonMSFT · 2020-11-24T00:29:30Z

Does this need to account for error handling? What if the initialization of the array failed half-way through?

I thought we were going to assume non-exception cases only at least custom marshalling. In this case that would seem to imply that if the custom marshalling throws, we can either let them handle the possible clean or determine which of the elements were initialized and only free them. @jkotas are you implying the latter?

…ntify when an element is empty due to not being marshalled.

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

jkoritzinsky · 2020-11-24T01:01:23Z

I've added in some basic handling for this case similar to the old system where we zero-init the memory before array marshalling in case we only partially marshal. I also fixed a bug around marshalling arrays of pointers since I found it along the way.

jkotas · 2020-11-24T02:45:04Z

we zero-init the memory before array marshalling in case we only partially marshal

This works, but it may be more efficient to keep track of how many elements of the array were marshalled successfully and cleanup only those.

jkotas · 2020-11-24T02:48:33Z

Also, what does would the code look for [in,out] ref BoolStruct[] pArray?

jkotas · 2020-11-24T02:50:18Z

we can either let them handle the possible clean or determine which of the elements were initialized and only free them

Agree with that.

jkoritzinsky · 2020-11-24T22:25:51Z

I've added a more comprehensive sample to the PR description that covers the ref case.

I prefer to use the mem-clear method initially since that's what the old system used and it still leaves open the option for switching methods in the future.

jkotas · 2020-11-24T22:31:45Z

for (int __i = 0; __i < pRef.Length; ++__i)

This is prone to buffer overruns. pRef can change between the time the buffer is allocate and the marshalling happens.

The length should be cached to avoid this problem.

jkotas · 2020-11-24T22:36:18Z

sizeof(global::IntStructWrapperNative) * pRef.Length

This is prone to overflow. It should be checked(...)

jkoritzinsky · 2020-11-24T22:40:36Z

for (int __i = 0; __i < pRef.Length; ++__i)

This is prone to buffer overruns. pRef can change between the time the buffer is allocate and the marshalling happens.

The length should be cached to avoid this problem.

Which loop is this referring to? There's multiple loops with this condition (one in marshal, one in unmarshal).

Since both of these comments are relating to general array marshalling, not marshalling of arrays of custom marshaled types, I'm going to put out a separate PR for these fixes.

jkotas · 2020-11-24T22:42:16Z

The problem is in the loops that operate on arrays passed in via ref. The user code can be changing the value on other thread.

jkotas · 2020-11-24T22:43:22Z

                        if (pArray == null)
                        {
                            __pArray_gen_native = null;
                        }
                        else
                        {

This can be just if (pArray != null). __pArray_gen_native is initialized to null from the prolog.

jkoritzinsky · 2020-11-25T18:43:27Z

@jkotas I've opened #384 with the array marshalling improvements.

…elab into arrays-with-custom-marshalled-elements

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

…elab into arrays-with-custom-marshalled-elements

jkoritzinsky · 2020-12-10T00:37:57Z

Up to date stub example with BoolStruct (taken from the integration tests):

namespace DllImportGenerator.IntegrationTests
{
    partial class NativeExportsNE
    {
        public partial class Arrays
        {
            [System.Runtime.CompilerServices.SkipLocalsInitAttribute]
            public static partial bool AndAllMembers(global::SharedTypes.BoolStruct[] pArray, int length)
            {
                unsafe
                {
                    global::SharedTypes.BoolStructNative*__pArray_gen_native = default;
                    bool __retVal = default;
                    byte __retVal_gen_native = default;
                    //
                    // Setup
                    //
                    bool pArray__allocated = false;
                    try
                    {
                        //
                        // Marshal
                        //
                        if (pArray != null)
                        {
                            int pArray__bytelen = checked(sizeof(global::SharedTypes.BoolStructNative) * pArray.Length);
                            if (pArray__bytelen > 512)
                            {
                                __pArray_gen_native = (global::SharedTypes.BoolStructNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pArray__bytelen);
                                pArray__allocated = true;
                            }
                            else
                            {
                                byte *pArray__stackptr = stackalloc byte[pArray__bytelen];
                                ;
                                __pArray_gen_native = (global::SharedTypes.BoolStructNative*)pArray__stackptr;
                            }
                        }

                        if (pArray != null)
                        {
                            new System.Span<global::SharedTypes.BoolStructNative>((global::SharedTypes.BoolStructNative*)__pArray_gen_native, pArray.Length).Clear();
                            for (int __i = 0; __i < pArray.Length; ++__i)
                            {
                                __pArray_gen_native[__i] = new global::SharedTypes.BoolStructNative(pArray[__i]);
                            }
                        }

                        //
                        // Invoke
                        //
                        __retVal_gen_native = AndAllMembers__PInvoke__(__pArray_gen_native, length);
                        //
                        // Unmarshal
                        //
                        __retVal = __retVal_gen_native != 0;
                    }
                    finally
                    {
                        //
                        // Cleanup
                        //
                        if (pArray__allocated)
                        {
                            System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pArray_gen_native);
                        }
                    }

                    return __retVal;
                }
            }

            [System.Runtime.InteropServices.DllImportAttribute("Microsoft.Interop.Tests.NativeExportsNE", EntryPoint = "and_all_members")]
            extern private static unsafe byte AndAllMembers__PInvoke__(global::SharedTypes.BoolStructNative*pArray, int length);
        }
    }
}

jkoritzinsky · 2020-12-10T00:44:52Z

Here's a more comprehensive one taken from the unit tests:

Source:

using System.Runtime.InteropServices;
partial class Test
{
    [GeneratedDllImport("DoesNotExist")]
    [return:MarshalAs(UnmanagedType.LPArray, SizeConst=10)]
    public static partial IntStructWrapper[] Method(
        IntStructWrapper[] p,
        in IntStructWrapper[] pIn,
        int pRefSize,
        [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] ref IntStructWrapper[] pRef,
        [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5, SizeConst=4)] out IntStructWrapper[] pOut,
        out int pOutSize
        );
}
[NativeMarshalling(typeof(IntStructWrapperNative))]
public struct IntStructWrapper
{
    public int Value;
}

public struct IntStructWrapperNative
{
    private int value;

    public IntStructWrapperNative(IntStructWrapper managed)
    {
        value = managed.Value;
    }

    public IntStructWrapper ToManaged() => new IntStructWrapper { Value = value };
}

Generated code:

partial class Test
{
    [System.Runtime.CompilerServices.SkipLocalsInitAttribute]
    public static partial global::IntStructWrapper[] Method(global::IntStructWrapper[] p, in global::IntStructWrapper[] pIn, int pRefSize, ref global::IntStructWrapper[] pRef, out global::IntStructWrapper[] pOut, out int pOutSize)
    {
        unsafe
        {
            global::IntStructWrapperNative*__p_gen_native = default;
            global::IntStructWrapperNative*__pIn_gen_native = default;
            global::IntStructWrapperNative*__pRef_gen_native = default;
            pOut = default;
            global::IntStructWrapperNative*__pOut_gen_native = default;
            pOutSize = default;
            global::IntStructWrapper[] __retVal = default;
            global::IntStructWrapperNative*__retVal_gen_native = default;
            //
            // Setup
            //
            bool p__allocated = false;
            bool pIn__allocated = false;
            global::IntStructWrapper[] pIn_local = pIn;
            global::IntStructWrapper[] pRef_local = pRef;
            global::IntStructWrapper[] pOut_local = pOut;
            try
            {
                //
                // Marshal
                //
                if (p != null)
                {
                    int p__bytelen = checked(sizeof(global::IntStructWrapperNative) * p.Length);
                    if (p__bytelen > 512)
                    {
                        __p_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(p__bytelen);
                        p__allocated = true;
                    }
                    else
                    {
                        byte *p__stackptr = stackalloc byte[p__bytelen];
                        ;
                        __p_gen_native = (global::IntStructWrapperNative*)p__stackptr;
                    }
                }

                if (p != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__p_gen_native, p.Length).Clear();
                    for (int __i = 0; __i < p.Length; ++__i)
                    {
                        __p_gen_native[__i] = new global::IntStructWrapperNative(p[__i]);
                    }
                }

                if (pIn_local != null)
                {
                    int pIn__bytelen = checked(sizeof(global::IntStructWrapperNative) * pIn_local.Length);
                    if (pIn__bytelen > 512)
                    {
                        __pIn_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pIn__bytelen);
                        pIn__allocated = true;
                    }
                    else
                    {
                        byte *pIn__stackptr = stackalloc byte[pIn__bytelen];
                        ;
                        __pIn_gen_native = (global::IntStructWrapperNative*)pIn__stackptr;
                    }
                }

                if (pIn_local != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__pIn_gen_native, pIn.Length).Clear();
                    for (int __i = 0; __i < pIn.Length; ++__i)
                    {
                        __pIn_gen_native[__i] = new global::IntStructWrapperNative(pIn_local[__i]);
                    }
                }

                __pRef_gen_native = null;
                if (pRef_local != null)
                {
                    int pRef__bytelen = checked(sizeof(global::IntStructWrapperNative) * pRef_local.Length);
                    __pRef_gen_native = (global::IntStructWrapperNative*)System.Runtime.InteropServices.Marshal.AllocCoTaskMem(pRef__bytelen);
                }

                if (pRef_local != null)
                {
                    new System.Span<global::IntStructWrapperNative>((global::IntStructWrapperNative*)__pRef_gen_native, pRef.Length).Clear();
                    for (int __i = 0; __i < pRef.Length; ++__i)
                    {
                        __pRef_gen_native[__i] = new global::IntStructWrapperNative(pRef_local[__i]);
                    }
                }

                //
                // Invoke
                //
                fixed (int *__pOutSize_gen_native = &pOutSize)
                    __retVal_gen_native = Method__PInvoke__(__p_gen_native, &__pIn_gen_native, pRefSize, &__pRef_gen_native, &__pOut_gen_native, __pOutSize_gen_native);
                //
                // Unmarshal
                //
                if (__retVal_gen_native != null)
                {
                    __retVal = new global::IntStructWrapper[10];
                    for (int __i = 0; __i < __retVal.Length; ++__i)
                    {
                        __retVal[__i] = __retVal_gen_native[__i].ToManaged();
                    }
                }
                else
                    __retVal = null;
                if (__pRef_gen_native != null)
                {
                    pRef_local = new global::IntStructWrapper[checked((int)pRefSize)];
                    for (int __i = 0; __i < pRef_local.Length; ++__i)
                    {
                        pRef_local[__i] = __pRef_gen_native[__i].ToManaged();
                    }
                }
                else
                    pRef_local = null;
                pRef = pRef_local;
                if (__pOut_gen_native != null)
                {
                    pOut_local = new global::IntStructWrapper[checked(4 + (int)pOutSize)];
                    for (int __i = 0; __i < pOut_local.Length; ++__i)
                    {
                        pOut_local[__i] = __pOut_gen_native[__i].ToManaged();
                    }
                }
                else
                    pOut_local = null;
                pOut = pOut_local;
            }
            finally
            {
                //
                // Cleanup
                //
                if (p__allocated)
                {
                    System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__p_gen_native);
                }

                if (pIn__allocated)
                {
                    System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pIn_gen_native);
                }

                System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pRef_gen_native);
                System.Runtime.InteropServices.Marshal.FreeCoTaskMem((System.IntPtr)__pOut_gen_native);
            }

            return __retVal;
        }
    }

    [System.Runtime.InteropServices.DllImportAttribute("DoesNotExist", EntryPoint = "Method")]
    extern private static unsafe global::IntStructWrapperNative*Method__PInvoke__(global::IntStructWrapperNative*p, global::IntStructWrapperNative**pIn, int pRefSize, global::IntStructWrapperNative**pRef, global::IntStructWrapperNative**pOut, int *pOutSize);
}

AaronRobinsonMSFT

Let's add some notes about arrays to the compat doc - multi-dimensional not supported and support for nested array types?

jkoritzinsky · 2020-12-10T01:28:38Z

The compat doc already mentions multidimensional arrays (it says only single dimensional arrays are supported). I've added a little blurb about current support for arrays of arrays.

…elab#379) Commit migrated from dotnet/runtimelab@ada198f

Add support for marshalling arrays of types with simple custom marsha…

110ac81

…lling and gracefully fail when an array of a type with complex custom marshalling (Value property) is introduced.

jkoritzinsky added the area-DllImportGenerator Source Generated stubs for P/Invokes in C# label Nov 23, 2020

jkoritzinsky requested review from AaronRobinsonMSFT and elinor-fung November 23, 2020 18:01

jkoritzinsky changed the title ~~Support arrays of types with simple custmo marshalling~~ Support arrays of types with simple custom marshalling Nov 23, 2020

jkoritzinsky mentioned this pull request Nov 23, 2020

Add handling for [In, Out] attributes. #380

Merged

AaronRobinsonMSFT reviewed Nov 23, 2020

View reviewed changes

PR feedback.

f643041

Invert if condition.

d1773bf

jkoritzinsky added 3 commits November 23, 2020 16:51

Zero allocated memory before starting marshalling so the user can ide…

f077d12

…ntify when an element is empty due to not being marshalled.

Fix pointer type native types in Spans.

5135d6d

Fix typo in casts. Fix path when null.

da466a8

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

jkoritzinsky mentioned this pull request Dec 1, 2020

Reliability improvements for array marshalling #384

Merged

Merge branch 'feature/DllImportGenerator' of github.com:dotnet/runtim…

ff7f0ad

…elab into arrays-with-custom-marshalled-elements

AaronRobinsonMSFT reviewed Dec 7, 2020

View reviewed changes

DllImportGenerator/DllImportGenerator/Marshalling/MarshallingGenerator.cs Outdated Show resolved Hide resolved

jkoritzinsky added 3 commits December 7, 2020 15:48

Clarify comment.

1e215c2

Signed-off-by: Jeremy Koritzinsky <jekoritz@microsoft.com>

Merge branch 'feature/DllImportGenerator' of github.com:dotnet/runtim…

e874214

…elab into arrays-with-custom-marshalled-elements

Fix DLLImport name.

a509cc1

Use local in marshal loop.

1514daa

AaronRobinsonMSFT approved these changes Dec 10, 2020

View reviewed changes

Update compat doc.

f0d66c6

jkoritzinsky merged commit ada198f into dotnet:feature/DllImportGenerator Dec 10, 2020

jkoritzinsky deleted the arrays-with-custom-marshalled-elements branch December 10, 2020 01:42

jkoritzinsky added a commit to jkoritzinsky/runtime that referenced this pull request Sep 20, 2021

Support arrays of types with simple custom marshalling (dotnet/runtim…

d24260a

…elab#379) Commit migrated from dotnet/runtimelab@ada198f

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Support arrays of types with simple custom marshalling #379

Support arrays of types with simple custom marshalling #379

jkoritzinsky commented Nov 23, 2020 •

edited

Loading

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020 •

edited

Loading

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020

AaronRobinsonMSFT commented Nov 24, 2020

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020 •

edited

Loading

jkotas commented Nov 24, 2020 •

edited

Loading

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkoritzinsky commented Nov 25, 2020

jkoritzinsky commented Dec 10, 2020

jkoritzinsky commented Dec 10, 2020 •

edited

Loading

AaronRobinsonMSFT left a comment

jkoritzinsky commented Dec 10, 2020

Support arrays of types with simple custom marshalling #379

Support arrays of types with simple custom marshalling #379

Conversation

jkoritzinsky commented Nov 23, 2020 • edited Loading

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020 • edited Loading

jkotas commented Nov 23, 2020

jkoritzinsky commented Nov 23, 2020

AaronRobinsonMSFT commented Nov 24, 2020

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020 • edited Loading

jkotas commented Nov 24, 2020 • edited Loading

jkoritzinsky commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkotas commented Nov 24, 2020

jkoritzinsky commented Nov 25, 2020

jkoritzinsky commented Dec 10, 2020

jkoritzinsky commented Dec 10, 2020 • edited Loading

AaronRobinsonMSFT left a comment

Choose a reason for hiding this comment

jkoritzinsky commented Dec 10, 2020

jkoritzinsky commented Nov 23, 2020 •

edited

Loading

jkoritzinsky commented Nov 23, 2020 •

edited

Loading

jkotas commented Nov 24, 2020 •

edited

Loading

jkotas commented Nov 24, 2020 •

edited

Loading

jkoritzinsky commented Dec 10, 2020 •

edited

Loading