Merge branch 'master' into features/NetAnalyzers/CA1822

src/Avalonia.Base/Input/DragDrop.cs

@@ -13,7 +13,7 @@ namespace Avalonia.Input
         /// <summary>
         /// Event which is raised, when a drag-and-drop operation leaves the element.
         /// </summary>
-        public static readonly RoutedEvent<RoutedEventArgs> DragLeaveEvent = RoutedEvent.Register<RoutedEventArgs>("DragLeave", RoutingStrategies.Bubble, typeof(DragDrop));
+        public static readonly RoutedEvent<DragEventArgs> DragLeaveEvent = RoutedEvent.Register<DragEventArgs>("DragLeave", RoutingStrategies.Bubble, typeof(DragDrop));
         /// <summary>
         /// Event which is raised, when a drag-and-drop operation is updated while over the element.
         /// </summary>

src/Avalonia.Base/Input/DragDropDevice.cs

@@ -54,7 +54,7 @@ namespace Avalonia.Input
             try
             {
                 if (_lastTarget != null)
-                    _lastTarget.RaiseEvent(new RoutedEventArgs(DragDrop.DragLeaveEvent));
+                    RaiseDragEvent(_lastTarget, inputRoot, point, DragDrop.DragLeaveEvent, effects, data, modifiers);
                 return RaiseDragEvent(target, inputRoot, point, DragDrop.DragEnterEvent, effects, data, modifiers);
             }
             finally
@@ -63,13 +63,13 @@ namespace Avalonia.Input
             }            
         }
 
-        private void DragLeave(IInputElement inputRoot)
+        private void DragLeave(IInputRoot inputRoot, Point point, IDataObject data, DragDropEffects effects, KeyModifiers modifiers)
         {
             if (_lastTarget == null)
                 return;
             try
             {
-                _lastTarget.RaiseEvent(new RoutedEventArgs(DragDrop.DragLeaveEvent));
+                RaiseDragEvent(_lastTarget, inputRoot, point, DragDrop.DragLeaveEvent, effects, data, modifiers);
             }
             finally 
             {
@@ -106,7 +106,7 @@ namespace Avalonia.Input
                     e.Effects = DragOver(e.Root, e.Location, e.Data, e.Effects, e.KeyModifiers);
                     break;
                 case RawDragEventType.DragLeave:
-                    DragLeave(e.Root);
+                    DragLeave(e.Root, e.Location, e.Data, e.Effects, e.KeyModifiers);
                     break;
                 case RawDragEventType.Drop:
                     e.Effects = Drop(e.Root, e.Location, e.Data, e.Effects, e.KeyModifiers);

src/Avalonia.Diagnostics/Avalonia.Diagnostics.csproj

@@ -19,7 +19,8 @@
     <ProjectReference Include="..\Avalonia.Themes.Simple\Avalonia.Themes.Simple.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.8.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="3.8.0" />
   </ItemGroup>
   <Import Project="..\..\build\EmbedXaml.props" />
   <Import Project="..\..\build\Rx.props" />

src/Avalonia.MicroCom/Avalonia.MicroCom.csproj

@@ -4,6 +4,7 @@
       <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
+    <PackageReference Include="MicroCom.Runtime" Version="0.10.5" />
     <ProjectReference Include="..\Avalonia.Build.Tasks\Avalonia.Build.Tasks.csproj">
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
       <ExcludeAssets>all</ExcludeAssets>

src/Avalonia.MicroCom/CallbackBase.cs

@@ -1,4 +1,6 @@
-namespace Avalonia.MicroCom
+using MicroCom.Runtime;
+
+namespace Avalonia.MicroCom
 {
     public abstract class CallbackBase : IUnknown, IMicroComShadowContainer
     {

src/Avalonia.MicroCom/IMicroComExceptionCallback.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace Avalonia.MicroCom
-{
-    public interface IMicroComExceptionCallback
-    {
-        void RaiseException(Exception e);
-    }
-}

src/Avalonia.MicroCom/IMicroComShadowContainer.cs

@@ -1,9 +0,0 @@
-namespace Avalonia.MicroCom
-{
-    public interface IMicroComShadowContainer
-    {
-        MicroComShadow Shadow { get; set; }
-        void OnReferencedFromNative();
-        void OnUnreferencedFromNative();
-    }
-}

src/Avalonia.MicroCom/IUnknown.cs

@@ -1,8 +0,0 @@
-using System;
-
-namespace Avalonia.MicroCom
-{
-    public interface IUnknown : IDisposable
-    {
-    }
-}

src/Avalonia.MicroCom/LocalInterop.cs

@@ -1,17 +0,0 @@
-using System;
-
-namespace Avalonia.MicroCom
-{
-    unsafe class LocalInterop
-    {
-        public static unsafe void CalliStdCallvoid(void* thisObject, void* methodPtr)
-        {
-            throw null;
-        }
-        
-        public static unsafe int CalliStdCallint(void* thisObject, Guid* guid, IntPtr* ppv,  void* methodPtr)
-        {
-            throw null;
-        }
-    }
-}

src/Avalonia.MicroCom/MicroComProxyBase.cs

@@ -1,110 +0,0 @@
-using System;
-using System.Runtime.ConstrainedExecution;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace Avalonia.MicroCom
-{
-    public unsafe class MicroComProxyBase : CriticalFinalizerObject, IUnknown
-    {
-        private IntPtr _nativePointer;
-        private bool _ownsHandle;
-        private SynchronizationContext _synchronizationContext;
-
-        public IntPtr NativePointer
-        {
-            get
-            {
-                if (_nativePointer == IntPtr.Zero)
-                    throw new ObjectDisposedException(this.GetType().FullName);
-                return _nativePointer;
-            }
-        }
-
-        public void*** PPV => (void***)NativePointer;
-
-        public MicroComProxyBase(IntPtr nativePointer, bool ownsHandle)
-        {
-            _nativePointer = nativePointer;
-            _ownsHandle = ownsHandle;
-            _synchronizationContext = SynchronizationContext.Current;
-            if(!_ownsHandle)
-                GC.SuppressFinalize(this);
-        }
-
-        protected virtual int VTableSize => 3;
-        
-        public void AddRef()
-        {
-            LocalInterop.CalliStdCallvoid(PPV, (*PPV)[1]);
-        }
-
-        public void Release()
-        {
-            LocalInterop.CalliStdCallvoid(PPV, (*PPV)[2]);
-        }
-
-        public int QueryInterface(Guid guid, out IntPtr ppv)
-        {
-            IntPtr r = default;
-            var rv = LocalInterop.CalliStdCallint(PPV, &guid, &r, (*PPV)[0]);
-            ppv = r;
-            return rv;
-        }
-
-        public T QueryInterface<T>() where T : IUnknown
-        {
-            var guid = MicroComRuntime.GetGuidFor(typeof(T));
-            var rv = QueryInterface(guid, out var ppv);
-            if (rv == 0)
-                return (T)MicroComRuntime.CreateProxyFor(typeof(T), ppv, true);
-            throw new COMException("QueryInterface failed", rv);
-        }
-
-        public bool IsDisposed => _nativePointer == IntPtr.Zero;
-
-        protected virtual void Dispose(bool disposing)
-        {
-            if(_nativePointer == IntPtr.Zero)
-                return;
-            if (_ownsHandle)
-            {
-                Release();
-                _ownsHandle = false;
-            }
-            _nativePointer = IntPtr.Zero;
-            GC.SuppressFinalize(this);
-        }
-        
-        public void Dispose() => Dispose(true);
-
-        public bool OwnsHandle => _ownsHandle;
-        
-        public void EnsureOwned()
-        {
-            if (!_ownsHandle)
-            {
-                GC.ReRegisterForFinalize(true);
-                AddRef();
-                _ownsHandle = true;
-            }
-        }
-
-        private static readonly SendOrPostCallback _disposeDelegate = DisposeOnContext;
-
-        private static void DisposeOnContext(object state)
-        {
-            (state as MicroComProxyBase)?.Dispose(false);
-        }
-
-        ~MicroComProxyBase()
-        {
-            if(!_ownsHandle)
-                return;
-            if (_synchronizationContext == null)
-                Dispose();
-            else
-                _synchronizationContext.Post(_disposeDelegate, this);
-        }
-    }
-}

src/Avalonia.MicroCom/MicroComRuntime.cs

@@ -1,143 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Runtime.InteropServices;
-
-namespace Avalonia.MicroCom
-{
-    public static unsafe class MicroComRuntime
-    {
-        private static ConcurrentDictionary<Type, IntPtr> _vtables = new ConcurrentDictionary<Type, IntPtr>();
-
-        private static ConcurrentDictionary<Type, Func<IntPtr, bool, object>> _factories =
-            new ConcurrentDictionary<Type, Func<IntPtr, bool, object>>();
-        private static ConcurrentDictionary<Type, Guid> _guids = new ConcurrentDictionary<Type, Guid>();
-        private static ConcurrentDictionary<Guid, Type> _guidsToTypes = new ConcurrentDictionary<Guid, Type>();
-
-        internal static readonly Guid ManagedObjectInterfaceGuid = Guid.Parse("cd7687c0-a9c2-4563-b08e-a399df50c633");
-        
-        static MicroComRuntime()
-        {
-            Register(typeof(IUnknown), new Guid("00000000-0000-0000-C000-000000000046"),
-                (ppv, owns) => new MicroComProxyBase(ppv, owns));
-            RegisterVTable(typeof(IUnknown), MicroComVtblBase.Vtable);
-        }
-
-        public static void RegisterVTable(Type t, IntPtr vtable)
-        {
-            _vtables[t] = vtable;
-        }
-        
-        public static void Register(Type t, Guid guid, Func<IntPtr, bool, object> proxyFactory)
-        {
-            _factories[t] = proxyFactory;
-            _guids[t] = guid;
-            _guidsToTypes[guid] = t;
-        }
-
-        public static Guid GetGuidFor(Type type) => _guids[type];
-
-        public static T CreateProxyFor<T>(void* pObject, bool ownsHandle) => (T)CreateProxyFor(typeof(T), new IntPtr(pObject), ownsHandle);
-        public static T CreateProxyFor<T>(IntPtr pObject, bool ownsHandle) => (T)CreateProxyFor(typeof(T), pObject, ownsHandle);
-
-        public static T CreateProxyOrNullFor<T>(void* pObject, bool ownsHandle) where T : class =>
-            pObject == null ? null : (T)CreateProxyFor(typeof(T), new IntPtr(pObject), ownsHandle);
-        
-        public static T CreateProxyOrNullFor<T>(IntPtr pObject, bool ownsHandle) where T : class =>
-            pObject == IntPtr.Zero ? null : (T)CreateProxyFor(typeof(T), pObject, ownsHandle);
-
-        public static object CreateProxyFor(Type type, IntPtr pObject, bool ownsHandle) => _factories[type](pObject, ownsHandle);
-
-        public static IntPtr GetNativeIntPtr<T>(this T obj, bool owned = false) where T : IUnknown
-            => new IntPtr(GetNativePointer(obj, owned));
-        public static void* GetNativePointer<T>(T obj, bool owned = false) where T : IUnknown
-        {
-            if (obj == null)
-                return null;
-            if (obj is MicroComProxyBase proxy)
-            {
-                if(owned)
-                    proxy.AddRef();
-                return (void*)proxy.NativePointer;
-            }
-
-            if (obj is IMicroComShadowContainer container)
-            {
-                container.Shadow ??= new MicroComShadow(container);
-                void* ptr = null;
-                var res = container.Shadow.GetOrCreateNativePointer(typeof(T), &ptr);
-                if (res != 0)
-                    throw new COMException(
-                        "Unable to create native callable wrapper for type " + typeof(T) + " for instance of type " +
-                        obj.GetType(),
-                        res);
-                if (owned)
-                    container.Shadow.AddRef((Ccw*)ptr);
-                return ptr;
-            }
-            throw new ArgumentException("Unable to get a native pointer for " + obj);
-        }
-
-        public static object GetObjectFromCcw(IntPtr ccw)
-        {
-            var ptr = (Ccw*)ccw;
-            var shadow = (MicroComShadow)GCHandle.FromIntPtr(ptr->GcShadowHandle).Target;
-            return shadow.Target;
-        }
-
-        public static bool IsComWrapper(IUnknown obj) => obj is MicroComProxyBase;
-
-        public static object TryUnwrapManagedObject(IUnknown obj)
-        {
-            if (obj is not MicroComProxyBase proxy)
-                return null;
-            if (proxy.QueryInterface(ManagedObjectInterfaceGuid, out _) != 0)
-                return null;
-            // Successful QueryInterface always increments ref counter
-            proxy.Release();
-            return GetObjectFromCcw(proxy.NativePointer);
-        }
-
-        public static bool TryGetTypeForGuid(Guid guid, out Type t) => _guidsToTypes.TryGetValue(guid, out t);
-
-        public static bool GetVtableFor(Type type, out IntPtr ptr) => _vtables.TryGetValue(type, out ptr);
-
-        public static void UnhandledException(object target, Exception e)
-        {
-            if (target is IMicroComExceptionCallback cb)
-            {
-                try
-                {
-                    cb.RaiseException(e);
-                }
-                catch
-                {
-                    // We've tried
-                }
-            }
-
-        }
-
-        public static T CloneReference<T>(this T iface) where T : IUnknown
-        {
-            var proxy = (MicroComProxyBase)(object)iface;
-            var ownedPointer = GetNativePointer(iface, true);
-            return CreateProxyFor<T>(ownedPointer, true);
-        }
-
-        public static T QueryInterface<T>(this IUnknown unknown) where T : IUnknown
-        {
-            var proxy = (MicroComProxyBase)unknown;
-            return proxy.QueryInterface<T>();
-        }
-
-        public static void UnsafeAddRef(this IUnknown unknown)
-        {
-            ((MicroComProxyBase)unknown).AddRef();
-        }
-        
-        public static void UnsafeRelease(this IUnknown unknown)
-        {
-            ((MicroComProxyBase)unknown).Release();
-        }
-    }
-}

src/Avalonia.MicroCom/MicroComShadow.cs

@@ -1,177 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace Avalonia.MicroCom
-{
-    public unsafe class MicroComShadow : IDisposable
-    {
-        private readonly object _lock = new object();
-        private readonly Dictionary<Type, IntPtr> _shadows = new Dictionary<Type, IntPtr>();
-        private readonly Dictionary<IntPtr, Type> _backShadows = new Dictionary<IntPtr, Type>();
-        private GCHandle? _handle;
-        private volatile int _refCount;
-        internal IMicroComShadowContainer Target { get; }
-        internal MicroComShadow(IMicroComShadowContainer target)
-        {
-            Target = target;
-            Target.Shadow = this;
-        }
-        
-        internal int QueryInterface(Ccw* ccw, Guid* guid, void** ppv)
-        {
-            if (MicroComRuntime.TryGetTypeForGuid(*guid, out var type))
-                return QueryInterface(type, ppv);
-            else if (*guid == MicroComRuntime.ManagedObjectInterfaceGuid)
-            {
-                ccw->RefCount++;
-                *ppv = ccw;
-                return 0;
-            }
-            else
-                return unchecked((int)0x80004002u);
-        }
-
-        internal int QueryInterface(Type type, void** ppv)
-        {
-            if (!type.IsInstanceOfType(Target))
-                return unchecked((int)0x80004002u);
-
-            var rv = GetOrCreateNativePointer(type, ppv);
-            if (rv == 0)
-                AddRef((Ccw*)*ppv);
-            return rv;
-        }
-
-        internal int GetOrCreateNativePointer(Type type, void** ppv)
-        {
-            if (!MicroComRuntime.GetVtableFor(type, out var vtable))
-                return unchecked((int)0x80004002u);
-            lock (_lock)
-            {
-
-                if (_shadows.TryGetValue(type, out var shadow))
-                {
-                    var targetCcw = (Ccw*)shadow;
-                    AddRef(targetCcw);
-                    *ppv = targetCcw;
-                    return 0;
-                }
-                else
-                {
-                    var intPtr = Marshal.AllocHGlobal(Marshal.SizeOf<Ccw>());
-                    var targetCcw = (Ccw*)intPtr;
-                    *targetCcw = default;
-                    targetCcw->RefCount = 0;
-                    targetCcw->VTable = vtable;
-                    if (_handle == null)
-                        _handle = GCHandle.Alloc(this);
-                    targetCcw->GcShadowHandle = GCHandle.ToIntPtr(_handle.Value);
-                    _shadows[type] = intPtr;
-                    _backShadows[intPtr] = type;
-                    *ppv = targetCcw;
-
-                    return 0;
-                }
-            }
-        }
-
-        internal int AddRef(Ccw* ccw)
-        {
-            if (Interlocked.Increment(ref _refCount) == 1)
-            {
-                try
-                {
-                    Target.OnReferencedFromNative();
-                }
-                catch (Exception e)
-                {
-                    MicroComRuntime.UnhandledException(Target, e);
-                }
-            }
-            
-            return Interlocked.Increment(ref ccw->RefCount);
-        }
-
-        internal int Release(Ccw* ccw)
-        {
-            Interlocked.Decrement(ref _refCount);
-            var cnt = Interlocked.Decrement(ref ccw->RefCount);
-            if (cnt == 0)
-                return FreeCcw(ccw);
-
-            return cnt;
-        }
-
-        int FreeCcw(Ccw* ccw)
-        {
-            lock (_lock)
-            {
-                // Shadow got resurrected by a call to QueryInterface from another thread
-                if (ccw->RefCount != 0)
-                    return ccw->RefCount;
-                    
-                var intPtr = new IntPtr(ccw);
-                var type = _backShadows[intPtr];
-                _backShadows.Remove(intPtr);
-                _shadows.Remove(type);
-                Marshal.FreeHGlobal(intPtr);
-                if (_shadows.Count == 0)
-                {
-                    _handle?.Free();
-                    _handle = null;
-                    try
-                    {
-                        Target.OnUnreferencedFromNative();
-                    }
-                    catch(Exception e)
-                    {
-                        MicroComRuntime.UnhandledException(Target, e);
-                    }
-                }
-            }
-
-            return 0;
-        }
-
-        /*
-         Needs to be called to support the following scenario:
-         1) Object created
-         2) Object passed to native code, shadow is created, CCW is created
-         3) Native side has never called AddRef
-         
-         In that case the GC handle to the shadow object is still alive
-         */
-        
-        public void Dispose()
-        {
-            lock (_lock)
-            {
-                List<IntPtr> toRemove = null;
-                foreach (var kv in _backShadows)
-                {
-                    var ccw = (Ccw*)kv.Key;
-                    if (ccw->RefCount == 0)
-                    {
-                        toRemove ??= new List<IntPtr>();
-                        toRemove.Add(kv.Key);
-                    }
-                }
-
-                if(toRemove != null)
-                    foreach (var intPtr in toRemove)
-                        FreeCcw((Ccw*)intPtr);
-            }
-        }
-    }
-    
-    [StructLayout(LayoutKind.Sequential)]
-    struct Ccw
-    {
-        public IntPtr VTable;
-        public IntPtr GcShadowHandle;
-        public volatile int RefCount;
-        public MicroComShadow GetShadow() => (MicroComShadow)GCHandle.FromIntPtr(GcShadowHandle).Target;
-    }
-}

src/Avalonia.MicroCom/MicroComVtblBase.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-
-namespace Avalonia.MicroCom
-{
-    public unsafe class MicroComVtblBase
-    {
-        private List<IntPtr> _methods = new List<IntPtr>();
-        [UnmanagedFunctionPointerAttribute(CallingConvention.StdCall)]
-        private delegate int AddRefDelegate(Ccw* ccw);
-
-        [UnmanagedFunctionPointerAttribute(CallingConvention.StdCall)]
-        private delegate int QueryInterfaceDelegate(Ccw* ccw, Guid* guid, void** ppv);
-
-        public static IntPtr Vtable { get; } = new MicroComVtblBase().CreateVTable();
-        public MicroComVtblBase()
-        {
-            AddMethod((QueryInterfaceDelegate)QueryInterface);
-            AddMethod((AddRefDelegate)AddRef);
-            AddMethod((AddRefDelegate)Release);
-        }
-
-        protected void AddMethod(void* f)
-        {
-            _methods.Add(new IntPtr(f));
-        }
-
-        protected void AddMethod(Delegate d)
-        {
-            GCHandle.Alloc(d);
-            _methods.Add(Marshal.GetFunctionPointerForDelegate(d));
-        }
-
-        protected unsafe IntPtr CreateVTable()
-        {
-            var ptr = (IntPtr*)Marshal.AllocHGlobal((IntPtr.Size + 1) * _methods.Count);
-            for (var c = 0; c < _methods.Count; c++)
-                ptr[c] = _methods[c];
-            return new IntPtr(ptr);
-        }
-
-        static int QueryInterface(Ccw* ccw, Guid* guid, void** ppv) => ccw->GetShadow().QueryInterface(ccw, guid, ppv);
-        static int AddRef(Ccw* ccw) => ccw->GetShadow().AddRef(ccw);
-        static int Release(Ccw* ccw) => ccw->GetShadow().Release(ccw);
-    }
-}

src/Avalonia.Native/Avalonia.Native.csproj

@@ -6,7 +6,6 @@
     <IsPackable Condition="'$([MSBuild]::IsOSPlatform(OSX))' == 'True'">true</IsPackable>
     <TargetFrameworks>net6.0;netstandard2.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <MicroComGeneratorRuntimeNamespace>Avalonia.MicroCom</MicroComGeneratorRuntimeNamespace>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(PackAvaloniaNative)' == 'true'">

src/Avalonia.Native/AvaloniaNativePlatform.cs

@@ -10,6 +10,7 @@ using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 using JetBrains.Annotations;
+using MicroCom.Runtime;
 
 namespace Avalonia.Native
 {

src/Avalonia.Native/CallbackBase.cs

@@ -2,6 +2,7 @@
 using System.Runtime.ExceptionServices;
 using Avalonia.MicroCom;
 using Avalonia.Platform;
+using MicroCom.Runtime;
 
 namespace Avalonia.Native
 {

src/Avalonia.Native/NativeControlHostImpl.cs

@@ -4,6 +4,7 @@ using Avalonia.MicroCom;
 using Avalonia.Native.Interop;
 using Avalonia.Platform;
 using Avalonia.VisualTree;
+using MicroCom.Runtime;
 
 namespace Avalonia.Native
 {

src/Windows/Avalonia.Win32/Avalonia.Win32.csproj

@@ -3,7 +3,6 @@
     <TargetFrameworks>net6.0;netstandard2.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <PackageId>Avalonia.Win32</PackageId>
-    <MicroComGeneratorRuntimeNamespace>Avalonia.MicroCom</MicroComGeneratorRuntimeNamespace>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="System.Numerics.Vectors" Version="4.5.0" />

src/Windows/Avalonia.Win32/ClipboardImpl.cs

@@ -7,6 +7,7 @@ using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Threading;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32
 {
@@ -83,7 +84,7 @@ namespace Avalonia.Win32
 
             while (true)
             {
-                var ptr = MicroCom.MicroComRuntime.GetNativeIntPtr<Win32Com.IDataObject>(wrapper);
+                var ptr = wrapper.GetNativeIntPtr<Win32Com.IDataObject>();
                 var hr = UnmanagedMethods.OleSetClipboard(ptr);
 
                 if (hr == 0)
@@ -107,7 +108,7 @@ namespace Avalonia.Win32
 
                 if (hr == 0)
                 {
-                    using var proxy = MicroCom.MicroComRuntime.CreateProxyFor<Win32Com.IDataObject>(dataObject, true);
+                    using var proxy = MicroComRuntime.CreateProxyFor<Win32Com.IDataObject>(dataObject, true);
                     using var wrapper = new OleDataObject(proxy);
                     var formats = wrapper.GetDataFormats().ToArray();
                     return formats;
@@ -131,7 +132,7 @@ namespace Avalonia.Win32
 
                 if (hr == 0)
                 {
-                    using var proxy = MicroCom.MicroComRuntime.CreateProxyFor<Win32Com.IDataObject>(dataObject, true);
+                    using var proxy = MicroComRuntime.CreateProxyFor<Win32Com.IDataObject>(dataObject, true);
                     using var wrapper = new OleDataObject(proxy);
                     var rv = wrapper.Get(format);
                     return rv;

src/Windows/Avalonia.Win32/DragSource.cs

@@ -3,6 +3,7 @@ using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Threading;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32
 {
@@ -19,8 +20,8 @@ namespace Avalonia.Win32
             using var src = new OleDragSource();
             var allowed = OleDropTarget.ConvertDropEffect(allowedEffects);
             
-            var objPtr = MicroCom.MicroComRuntime.GetNativeIntPtr<Win32Com.IDataObject>(dataObject);
-            var srcPtr = MicroCom.MicroComRuntime.GetNativeIntPtr<Win32Com.IDropSource>(src);
+            var objPtr = MicroComRuntime.GetNativeIntPtr<Win32Com.IDataObject>(dataObject);
+            var srcPtr = MicroComRuntime.GetNativeIntPtr<Win32Com.IDropSource>(src);
 
             UnmanagedMethods.DoDragDrop(objPtr, srcPtr, (int)allowed, out var finalEffect);
             

src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs

@@ -7,6 +7,7 @@ using System.Runtime.InteropServices.ComTypes;
 using System.Text;
 
 using Avalonia.MicroCom;
+using MicroCom.Runtime;
 using Avalonia.Win32.Win32Com;
 
 // ReSharper disable InconsistentNaming

src/Windows/Avalonia.Win32/OleContext.cs

@@ -5,6 +5,7 @@ using Avalonia.Platform;
 using Avalonia.Threading;
 using Avalonia.Win32.Interop;
 using Avalonia.Win32.Win32Com;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32
 {
@@ -47,7 +48,7 @@ namespace Avalonia.Win32
                 return false;
             }
 
-            var trgPtr = MicroCom.MicroComRuntime.GetNativeIntPtr(target);
+            var trgPtr = target.GetNativeIntPtr();
             return UnmanagedMethods.RegisterDragDrop(hwnd.Handle, trgPtr) == UnmanagedMethods.HRESULT.S_OK;
         }
 

src/Windows/Avalonia.Win32/OleDataObject.cs

@@ -10,7 +10,7 @@ using Avalonia.Input;
 using Avalonia.MicroCom;
 using Avalonia.Utilities;
 using Avalonia.Win32.Interop;
-
+using MicroCom.Runtime;
 using IDataObject = Avalonia.Input.IDataObject;
 
 namespace Avalonia.Win32

src/Windows/Avalonia.Win32/OleDropTarget.cs

@@ -5,6 +5,7 @@ using Avalonia.Input.Raw;
 using Avalonia.MicroCom;
 using Avalonia.Platform;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 using DropEffect = Avalonia.Win32.Win32Com.DropEffect;
 
 namespace Avalonia.Win32

src/Windows/Avalonia.Win32/Win32StorageProvider.cs

@@ -12,6 +12,7 @@ using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 using Avalonia.Win32.Interop;
 using Avalonia.Win32.Win32Com;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32
 {

src/Windows/Avalonia.Win32/WinRT/Composition/WinUICompositedWindow.cs

@@ -6,6 +6,7 @@ using Avalonia.MicroCom;
 using Avalonia.OpenGL;
 using Avalonia.OpenGL.Egl;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT.Composition
 {

src/Windows/Avalonia.Win32/WinRT/Composition/WinUICompositorConnection.cs

@@ -12,6 +12,7 @@ using Avalonia.OpenGL.Angle;
 using Avalonia.OpenGL.Egl;
 using Avalonia.Rendering;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT.Composition
 {

src/Windows/Avalonia.Win32/WinRT/Composition/WinUIEffectBase.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia.MicroCom;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT.Composition
 {

src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositedWindowSurface.cs

@@ -6,6 +6,7 @@ using Avalonia.OpenGL.Egl;
 using Avalonia.OpenGL.Surfaces;
 using Avalonia.Utilities;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT.Composition
 {

src/Windows/Avalonia.Win32/WinRT/NativeWinRTMethods.cs

@@ -7,6 +7,7 @@ using System.Runtime.InteropServices;
 using System.Threading;
 using Avalonia.MicroCom;
 using Avalonia.Win32.Interop;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT
 {

src/Windows/Avalonia.Win32/WinRT/WinRTInspectable.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Avalonia.MicroCom;
+using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT
 {