feat: Regasm: should call static methods with Com(Un)RegisterFunctionAttribute (#370)

* Added Feature

* Update RegistrationServices.cs

* Moved Implementation

Author: mavToday

src/dscom.test/tests/RegistrationServicesTest.cs

@@ -168,6 +168,53 @@ public void RegisterTypeForComClients_SuspendedTestClassAsLocalServerWithCoResum
         // Cleanup
         registrationServices.UnregisterTypeForComClients(cookie);
     }
+
+    [Fact]
+    public void RegistrationServices_Should_No_ThrowOn_ComRegister_Without_Method()
+    {
+        RegistrationServices.CustomRegistrationFunction(typeof(NoRegisterFunctionClass));
+        RegistrationServices.CustomUnregistrationFunction(typeof(NoRegisterFunctionClass));
+    }
+
+    [Fact]
+    public void RegistrationServices_Should_Invoke_ComRegisterMethod()
+    {
+        RegistrationServices.CustomRegistrationFunction(typeof(SingleRegisterFunctionClass));
+        RegistrationServices.CustomUnregistrationFunction(typeof(SingleRegisterFunctionClass));
+
+        Assert.Equal(typeof(SingleRegisterFunctionClass), SingleRegisterFunctionClass.RegisteredType);
+        Assert.Equal(typeof(SingleRegisterFunctionClass), SingleRegisterFunctionClass.UnregisteredType);
+    }
+
+    [Fact]
+    public void RegistrationServices_Should_Throw_On_Instance_ComRegisterMethod()
+    {
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomRegistrationFunction(typeof(SingleInstanceRegisterFunctionClass)));
+
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomUnregistrationFunction(typeof(SingleInstanceRegisterFunctionClass)));
+    }
+
+    [Fact]
+    public void RegistrationServices_Should_Throw_On_Multiple_ComRegisterMethod()
+    {
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomRegistrationFunction(typeof(MultipleRegisterFunctionClass)));
+
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomUnregistrationFunction(typeof(MultipleRegisterFunctionClass)));
+    }
+
+    [Fact]
+    public void RegistrationServices_Should_Throw_On_WrongSignature_ComRegisterMethod()
+    {
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomRegistrationFunction(typeof(WrongSignatureRegisterFunctionClass)));
+
+        Assert.Throws<InvalidOperationException>(
+            () => RegistrationServices.CustomUnregistrationFunction(typeof(WrongSignatureRegisterFunctionClass)));
+    }
 }
 
 [ComVisible(true)]
@@ -220,3 +267,88 @@ public string GetSuccessString()
         return "Success";
     }
 }
+
+public class NoRegisterFunctionClass
+{
+
+}
+
+public class SingleRegisterFunctionClass
+{
+    public static Type? RegisteredType { get; private set; }
+
+    public static Type? UnregisteredType { get; private set; }
+
+    [ComRegisterFunction]
+    public static void ComRegister(Type type)
+    {
+        RegisteredType = type;
+    }
+
+    [ComUnregisterFunction]
+    public static void ComUnregister(Type type)
+    {
+        UnregisteredType = type;
+    }
+}
+
+public class SingleInstanceRegisterFunctionClass
+{
+    public Type? RegisteredType { get; private set; }
+
+    public Type? UnregisteredType { get; private set; }
+
+    [ComRegisterFunction]
+    public void ComRegister(Type type)
+    {
+        RegisteredType = type;
+    }
+
+    [ComUnregisterFunction]
+    public void ComUnregister(Type type)
+    {
+        UnregisteredType = type;
+    }
+}
+
+public class MultipleRegisterFunctionClass
+{
+    public static Type? RegisteredType { get; private set; }
+
+    public static Type? UnregisteredType { get; private set; }
+
+    [ComRegisterFunction]
+    public static void ComRegisterA(Type type)
+    {
+        RegisteredType = type;
+    }
+
+    [ComRegisterFunction]
+    public static void ComRegisterB(Type type)
+    {
+        RegisteredType = type;
+    }
+
+    [ComUnregisterFunction]
+    public static void ComUnregisterA(Type type)
+    {
+        UnregisteredType = type;
+    }
+
+    [ComUnregisterFunction]
+    public static void ComUnregisterB(Type type)
+    {
+        UnregisteredType = type;
+    }
+}
+
+public class WrongSignatureRegisterFunctionClass
+{
+    [ComRegisterFunction]
+    public static void ComRegister()
+    { }
+
+    [ComUnregisterFunction]
+    public static void ComUnregister()
+    { }
+}

src/dscom/RegistrationServices.cs

@@ -227,7 +227,7 @@ public bool RegisterAssembly(Assembly assembly, bool registerCodeBase, ManagedCa
                 RegisterManagedType(type, fullName, assemblyVersion, codeBase, runtimeVersion, preferredAction);
             }
 
-            // Skip: CustomRegistrationFunction
+            CustomRegistrationFunction(type);
         }
 
         // Skip: PIA Regitration
@@ -263,7 +263,8 @@ public bool UnregisterAssembly(Assembly assembly)
 
         foreach (var type in typesToUnregister)
         {
-            // Skip: Custom unregister function
+            CustomUnregistrationFunction(type);
+
             if (IsComRegistratableValueType(type) && !UnregisterValueType(type, assemblyVersion))
             {
                 typesNotRemoved.Add(type);
@@ -848,4 +849,56 @@ private static bool CanWriteGlobalRegistry()
         }
     }
 
+    public static void CustomRegistrationFunction(Type type)
+    {
+        var provider = TryGetComRegisterFunction<ComRegisterFunctionAttribute>(type);
+
+        provider?.Invoke(null, new object[] { type });
+    }
+
+    public static void CustomUnregistrationFunction(Type type)
+    {
+        var provider = TryGetComRegisterFunction<ComUnregisterFunctionAttribute>(type);
+
+        provider?.Invoke(null, new object[] { type });
+    }
+
+    private static MethodInfo? TryGetComRegisterFunction<T>(Type type)
+        where T : Attribute
+    {
+        var registerMethod = type
+            .GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
+            .Where(m => m.GetCustomAttribute<T>() is not null)
+            .ToList();
+
+        // No method
+        if (registerMethod.Count == 0)
+        {
+            return null;
+        }
+
+        // multipe methods -> error
+        if (registerMethod.Count > 1)
+        {
+            throw new InvalidOperationException($"The type '{type.Name}' contains more than on COM-Function for registration.");
+        }
+
+        var provider = registerMethod[0];
+
+        // method should be static
+        if (!provider.IsStatic)
+        {
+            throw new InvalidOperationException($"The COM-Function for registration of type '{type.Name}' should be static.");
+        }
+
+        // method should have exactly one parameter of type
+        var paramters = provider.GetParameters();
+        if (paramters.Length != 1 || paramters[0].ParameterType != typeof(Type))
+        {
+            throw new InvalidOperationException($"The COM-Function for registration of type '{type.Name}' should have exactly one parameter of '{nameof(Type)}.");
+        }
+
+        return provider;
+    }
+
 }