Add ComClassFactory

Add ComClassFactory based on WinForms implementation.

Author: Tofudebeast

src/thirtytwo/NativeMethods.txt

@@ -60,6 +60,7 @@ DISPID_Parent
 DISPID_PROPERTYPUT
 DISPID_STARTENUM
 DISPID_UNKNOWN
+DLLVERSIONINFO
 DPI_AWARENESS_CONTEXT_*
 DrawFocusRect
 DrawIconEx
@@ -263,6 +264,7 @@ LineTo
 LoadCursor
 LoadIcon
 LoadLibrary
+LoadLibraryEx
 LoadRegTypeLib
 LOCALE_NAME_MAX_LENGTH
 LocalFree

src/thirtytwo/Win32/Foundation/HMODULE.cs

@@ -2,11 +2,14 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using Windows.Support;
+using Windows.Win32.System.LibraryLoader;
 
 namespace Windows.Win32.Foundation;
 
 public unsafe partial struct HMODULE : IHandle<HMODULE>
 {
+    private const string DllGetVersionMethodName = "DllGetVersion";
+
     HMODULE IHandle<HMODULE>.Handle => this;
     object? IHandle<HMODULE>.Wrapper => null;
 
@@ -68,4 +71,59 @@ public static HMODULE FromName(string name, bool incrementRefCount = false)
             return hmodule;
         }
     }
+
+    /// <summary>
+    ///  Loads the module from the specified file path. Throws on failure.
+    /// </summary>
+    public static HMODULE LoadModule(string filePath, LOAD_LIBRARY_FLAGS flags = default)
+    {
+        HMODULE module = Interop.LoadLibraryEx(filePath, flags);
+        if (module.IsNull)
+        {
+            Error.ThrowLastError();
+        }
+
+        return module;
+    }
+
+    /// <summary>
+    ///  Gets the dll version of the module. Throws if the module doesn't expose `DllGetVersion`.
+    /// </summary>
+    public Version GetDllVersion()
+    {
+        FARPROC proc = Interop.GetProcAddress(this, DllGetVersionMethodName);
+
+        if (proc.IsNull)
+        {
+            Error.ThrowLastError();
+        }
+
+        DLLVERSIONINFO versionInfo = new()
+        {
+            cbSize = (uint)sizeof(DLLVERSIONINFO)
+        };
+
+        // HRESULT Dllgetversionproc(DLLVERSIONINFO* version)
+        ((delegate* unmanaged<DLLVERSIONINFO*, HRESULT>)proc.Value)(&versionInfo).ThrowOnFailure();
+
+        return new Version(
+            (int)versionInfo.dwMajorVersion,
+            (int)versionInfo.dwMinorVersion,
+            (int)versionInfo.dwBuildNumber,
+            (int)versionInfo.dwPlatformID);
+    }
+
+    /// <summary>
+    ///  Gets the address of the specified procedure. Throws if the procedure can't be found.
+    /// </summary>
+    public FARPROC GetProcAddress(string procName)
+    {
+        FARPROC proc = Interop.GetProcAddress(this, procName);
+        if (proc.IsNull)
+        {
+            Error.ThrowLastError();
+        }
+
+        return proc;
+    }
 }

src/thirtytwo/Win32/System/Com/ComClassFactory.cs

@@ -0,0 +1,87 @@
+// Copyright (c) Jeremy W. Kuhne. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+// Original license (from https://github.com/dotnet/winforms):
+//
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Windows.Support;
+using RuntimeMarshal = System.Runtime.InteropServices.Marshal;
+
+namespace Windows.Win32.System.Com;
+
+/// <summary>
+///  Wraps an <see cref="IClassFactory"/> from a dynamically loaded assembly.
+/// </summary>
+internal unsafe class ComClassFactory : IDisposable
+{
+    private readonly HMODULE _module;
+    private readonly bool _unloadModule;
+    private readonly IClassFactory* _classFactory;
+
+    public Guid ClassId { get; }
+
+    private const string ExportMethodName = "DllGetClassObject";
+
+    public ComClassFactory(
+        string filePath,
+        Guid classId) : this(HMODULE.LoadModule(filePath), classId)
+    {
+        _unloadModule = true;
+    }
+
+    public ComClassFactory(
+        HMODULE module,
+        Guid classId)
+    {
+        _module = module;
+        ClassId = classId;
+
+        // Dynamically get the class factory method.
+
+        // HRESULT DllGetClassObject(
+        //   [in] REFCLSID rclsid,
+        //   [in] REFIID riid,
+        //   [out] LPVOID* ppv
+        // );
+
+        FARPROC proc = Interop.GetProcAddress(module, ExportMethodName);
+
+        if (proc.IsNull)
+        {
+            Error.ThrowLastError();
+        }
+
+        IClassFactory* classFactory;
+        ((delegate* unmanaged<Guid*, Guid*, void**, HRESULT>)proc.Value)(
+            &classId, IID.Get<IClassFactory>(),
+            (void**)&classFactory).ThrowOnFailure();
+        _classFactory = classFactory;
+    }
+
+    internal HRESULT CreateInstance(out IUnknown* unknown)
+    {
+        unknown = default;
+        fixed (IUnknown** u = &unknown)
+        {
+            return _classFactory->CreateInstance(null, IID.Get<IUnknown>(), (void**)u);
+        }
+    }
+
+    internal HRESULT CreateInstance(out object? unknown)
+    {
+        HRESULT result = CreateInstance(out IUnknown* punk);
+        unknown = punk is null ? null : RuntimeMarshal.GetObjectForIUnknown((nint)punk);
+        return result;
+    }
+
+    public void Dispose()
+    {
+        _classFactory->Release();
+        if (_unloadModule && !_module.IsNull)
+        {
+            Interop.FreeLibrary(_module);
+        }
+    }
+}