Repository navigation
[API Proposal]: Define parameter marshalling of interfaces #85797
Description
Background and motivation
Today, we allow developers to specify the default marshaller for a type in source-generated marshalling with the NativeMarshalling attribute. We should allow this attribute on interface types, so interface types in source-generated interop signatures can have default marshallers. This wasn't common before, but with source-generated COM coming into the mix, this scenario is much more popular.
When NativeMarshalling is applied to an interface, the source-generator will only respect it when the static type in a signature is the interface type (same rules we use for all other types). We don't do any inheritance walking, we only look on the type itself.
API Proposal
namespace System.Runtime.InteropServices.Marshalling;
- [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Delegate)]
+ [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate)]
public sealed class NativeMarshallingAttribute : Attribute
{
}
+/// <summary>
+/// COM interface marshaller using a StrategyBasedComWrappers instance
+/// </summary>
+/// <remarks>
+/// This marshaller will always pass the <see cref="CreateObjectFlags.Unwrap"/> flag
+/// to <see cref="ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)"/>.
+/// </remarks>
+[CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder), MarshalMode.Default, typeof(ComInterfaceMarshaller<>)]
+public static class ComInterfaceMarshaller<T>
+{
+ public static void* ConvertToUnmanaged(T managed);
+ public static T ConvertToManaged(void* unmanaged);
+}
+/// <summary>
+/// COM interface marshaller using a StrategyBasedComWrappers instance
+/// that will only create unique native object wrappers (RCW).
+/// </summary>
+/// <remarks>
+/// This marshaller will always pass the <see cref="CreateObjectFlags.Unwrap"/> and <see cref="CreateObjectFlags.UniqueInstance"/> flags
+/// to <see cref="ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)"/>.
+/// </remarks>
+[CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder), MarshalMode.Default, typeof(UniqueComInterfaceMarshaller<>)]
+public static class UniqueComInterfaceMarshaller<T>
+{
+ public static void* ConvertToUnmanaged(T managed);
+ public static T ConvertToManaged(void* unmanaged);
+}
+/// <summary>
+/// COM interface marshaller using a user defined ComWrappers type.
+/// </summary>
+/// <remarks>
+/// This marshaller will always pass the <see cref="CreateObjectFlags.Unwrap"/> flag
+/// to <see cref="ComWrappers.GetOrCreateObjectForComInstance(IntPtr, CreateObjectFlags)"/>.
+/// </remarks>
+[CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder), MarshalMode.Default, typeof(ComInterfaceMarshaller<,>)]
+public static class ComInterfaceMarshaller<T, U> where U : ComWrappers
+{
+ public static void* ConvertToUnmanaged(T managed);
+ public static T ConvertToManaged(void* unmanaged);
+}API Usage
[NativeMarshalling(typeof(ComInterfaceMarshaller<IMyComInterface>))]
interface IMyComInterface
{
public void Method([MarshalUsing(typeof(UniqueComInterfaceMarshaller<IMyComInterface>))] IMyComInterface itf);
}Alternative Designs
None
Risks
This proposal does not attempt to provide first-class support for more complicated scenarios such as using a specific ComWrappers instance or specifying the IID of an object in a method signature. Rather than add complexity to the source generator, users can handle such scenarios manually by explicitly marshalling using their ComWrappers instance and/or defining different interfaces.
Activity
AaronRobinsonMSFT commentedon May 4, 2023
We might want to add in a built-in marshaller type too.
AaronRobinsonMSFT commentedon May 5, 2023
How would this integrate with
LibraryImport? Is the assumption here the logic would "just work" since the defined marshaller could be used and so APIs likeCreateStreamOnHGlobal()could be defined as:Do we have any concerns with down level support if the above is true? The
LibraryImportAPI degrades toDllImport, how would the above scenario work in that case?[-][API Proposal]: Allow System.Runtime.InteropServices.Marshalling.NativeMarshalling on interfaces[/-][+][API Proposal]: Define parameter marshalling of interfaces[/+]jkoritzinsky commentedon May 5, 2023
For LibraryImport, these marshallers would work like any other user-defined marshaller. They don't work downlevel below .NET 7. If we decide to make the
ComInterfaceMarshaller<T>type the default marshaller for[MarshalAs(UnmanagedType.Interface)](which it sounds like we want), then we'd only recognizeUnmanagedType.Interfaceon .NET 8 and newer.bartonjs commentedon May 9, 2023
Video
ComInterfaceMarshaller<T, U>in lieu of answering whether or not the generic arity overloading was obvious for the scenario.UniqueComInterfaceMarshallerneeded "Instance" in the name, and decided it was OK as-is because of a low number of users (who are expected to be domain semi-experts) and that the name was already long enough.