Refactor ComponentActivator

src/coreclr/src/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs

@@ -6,9 +6,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Runtime.Loader;
 
 namespace Internal.Runtime.InteropServices
 {
@@ -39,6 +39,31 @@ private static string MarshalToString(IntPtr arg, string argName)
             return result;
         }
 
+        private static (Type? delegateType, string? delegateTypeName) GetDelegateTypeArgs(IntPtr delegateTypeNative)
+        {
+            // Determine the signature of the type. There are 3 possibilities:
+            //  * No delegate type was supplied - use the default (i.e. ComponentEntryPoint).
+            //  * A sentinel value was supplied - the function is marked UnmanagedCallersOnly. This means
+            //      a function pointer can be returned without creating a delegate.
+            //  * A delegate type was supplied - Load the type and create a delegate for that method.
+            string? delegateTypeName = null;
+            Type? delegateType = null;
+            if (delegateTypeNative == IntPtr.Zero)
+            {
+                delegateType = typeof(ComponentEntryPoint);
+            }
+            else if (delegateTypeNative == (IntPtr)(-1))
+            {
+                // Leave both null.
+            }
+            else
+            {
+                delegateTypeName = MarshalToString(delegateTypeNative, nameof(delegateTypeNative));
+            }
+
+            return (delegateType, delegateTypeName);
+        }
+
         /// <summary>
         /// Native hosting entry point for creating a native delegate
         /// </summary>
@@ -50,45 +75,19 @@ private static string MarshalToString(IntPtr arg, string argName)
         /// <param name="functionHandle">Pointer where to store the function pointer result</param>
         [UnmanagedCallersOnly]
         public static unsafe int LoadAssemblyAndGetFunctionPointer(IntPtr assemblyPathNative,
-                                                            IntPtr typeNameNative,
-                                                            IntPtr methodNameNative,
-                                                            IntPtr delegateTypeNative,
-                                                            IntPtr reserved,
-                                                            IntPtr functionHandle)
+                                                                   IntPtr typeNameNative,
+                                                                   IntPtr methodNameNative,
+                                                                   IntPtr delegateTypeNative,
+                                                                   IntPtr reserved,
+                                                                   IntPtr functionHandle)
         {
             try
             {
-                // Load the assembly and create a resolver callback for types.
+                // Validate all parameters first.
                 string assemblyPath = MarshalToString(assemblyPathNative, nameof(assemblyPathNative));
-                IsolatedComponentLoadContext alc = GetIsolatedComponentLoadContext(assemblyPath);
-                Func<AssemblyName, Assembly> resolver = name => alc.LoadFromAssemblyName(name);
-
-                // Get the requested type.
                 string typeName = MarshalToString(typeNameNative, nameof(typeNameNative));
-                Type type = Type.GetType(typeName, resolver, null, throwOnError: true)!;
-
-                // Get the method name on the type.
                 string methodName = MarshalToString(methodNameNative, nameof(methodNameNative));
-
-                // Determine the signature of the type. There are 3 possibilities:
-                //  * No delegate type was supplied - use the default (i.e. ComponentEntryPoint).
-                //  * A sentinel value was supplied - the function is marked UnmanagedCallersOnly. This means
-                //      a function pointer can be returned without creating a delegate.
-                //  * A delegate type was supplied - Load the type and create a delegate for that method.
-                Type? delegateType;
-                if (delegateTypeNative == IntPtr.Zero)
-                {
-                    delegateType = typeof(ComponentEntryPoint);
-                }
-                else if (delegateTypeNative == (IntPtr)(-1))
-                {
-                    delegateType = null;
-                }
-                else
-                {
-                    string delegateTypeName = MarshalToString(delegateTypeNative, nameof(delegateTypeNative));
-                    delegateType = Type.GetType(delegateTypeName, resolver, null, throwOnError: true)!;
-                }
+                (Type? delegateType, string? delegateTypeName) = GetDelegateTypeArgs(delegateTypeNative);
 
                 if (reserved != IntPtr.Zero)
                 {
@@ -100,35 +99,11 @@ public static unsafe int LoadAssemblyAndGetFunctionPointer(IntPtr assemblyPathNa
                     throw new ArgumentNullException(nameof(functionHandle));
                 }
 
-                IntPtr functionPtr;
-                if (delegateType == null)
-                {
-                    // Match search semantics of the CreateDelegate() function below.
-                    BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
-                    MethodInfo? methodInfo = type.GetMethod(methodName, bindingFlags);
-                    if (methodInfo == null)
-                        throw new MissingMethodException(typeName, methodName);
+                // Set up the AssemblyLoadContext for this delegate.
+                AssemblyLoadContext alc = InternalLoadAssembly(assemblyPath);
 
-                    // Verify the function is properly marked.
-                    if (null == methodInfo.GetCustomAttribute<UnmanagedCallersOnlyAttribute>())
-                        throw new InvalidOperationException(SR.InvalidOperation_FunctionMissingUnmanagedCallersOnly);
-
-                    functionPtr = methodInfo.MethodHandle.GetFunctionPointer();
-                }
-                else
-                {
-                    Delegate d = Delegate.CreateDelegate(delegateType, type, methodName)!;
-
-                    functionPtr = Marshal.GetFunctionPointerForDelegate(d);
-
-                    lock (s_delegates)
-                    {
-                        // Keep a reference to the delegate to prevent it from being garbage collected
-                        s_delegates[functionPtr] = d;
-                    }
-                }
-
-                *(IntPtr*)functionHandle = functionPtr;
+                // Create the function pointer.
+                *(IntPtr*)functionHandle = InternalGetFunctionPointer(alc, typeName, methodName, delegateType, delegateTypeName);
             }
             catch (Exception e)
             {
@@ -153,5 +128,61 @@ private static IsolatedComponentLoadContext GetIsolatedComponentLoadContext(stri
 
             return alc;
         }
+
+        private static AssemblyLoadContext InternalLoadAssembly(string assemblyPath)
+        {
+
+            IsolatedComponentLoadContext alc = GetIsolatedComponentLoadContext(assemblyPath);
+            return alc;
+        }
+
+        private static IntPtr InternalGetFunctionPointer(AssemblyLoadContext alc,
+                                                         string typeName,
+                                                         string methodName,
+                                                         Type? delegateType,
+                                                         string? delegateTypeName)
+        {
+            // Create a resolver callback for types.
+            Func<AssemblyName, Assembly> resolver = name => alc.LoadFromAssemblyName(name);
+
+            // Get the requested delegateType if a name was given.
+            if (delegateTypeName != null)
+            {
+                delegateType = Type.GetType(delegateTypeName, resolver, null, throwOnError: true)!;
+            }
+
+            // Get the requested type.
+            Type type = Type.GetType(typeName, resolver, null, throwOnError: true)!;
+
+            IntPtr functionPtr;
+            if (delegateType == null)
+            {
+                // Match search semantics of the CreateDelegate() function below.
+                BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+                MethodInfo? methodInfo = type.GetMethod(methodName, bindingFlags);
+                if (methodInfo == null)
+                    throw new MissingMethodException(typeName, methodName);
+
+                // Verify the function is properly marked.
+                if (null == methodInfo.GetCustomAttribute<UnmanagedCallersOnlyAttribute>())
+                    throw new InvalidOperationException(SR.InvalidOperation_FunctionMissingUnmanagedCallersOnly);
+
+                functionPtr = methodInfo.MethodHandle.GetFunctionPointer();
+            }
+            else
+            {
+                Delegate d = Delegate.CreateDelegate(delegateType, type, methodName)!;
+
+                functionPtr = Marshal.GetFunctionPointerForDelegate(d);
+
+                lock (s_delegates)
+                {
+                    // Keep a reference to the delegate to prevent it from being garbage collected
+                    s_delegates[functionPtr] = d;
+                }
+            }
+
+            return functionPtr;
+        }
     }
 }

src/installer/corehost/cli/test/nativehost/host_context_test.cpp

@@ -252,7 +252,7 @@ namespace
         return _printable_delegate_name_t{ delegate_name };
     }
 
-    int call_delegate_flavour(
+    int call_load_assembly_and_get_function_pointer_flavour(
         load_assembly_and_get_function_pointer_fn delegate,
         const pal::char_t *assembly_path,
         const pal::char_t *type_name,
@@ -294,7 +294,7 @@ namespace
         return rc;
     }
 
-    bool load_assembly_and_get_function_pointer_test(
+    bool component_load_assembly_and_get_function_pointer_test(
         const hostfxr_exports &hostfxr,
         const pal::char_t *config_path,
         int argc,
@@ -327,7 +327,7 @@ namespace
             else
             {
                 test_output << log_prefix << _X("hostfxr_get_runtime_delegate succeeded: ") << std::hex << std::showbase << rc << std::endl;
-                rc = call_delegate_flavour(delegate, assembly_path, type_name, method_name, log_prefix, test_output);
+                rc = call_load_assembly_and_get_function_pointer_flavour(delegate, assembly_path, type_name, method_name, log_prefix, test_output);
             }
         }
 
@@ -370,7 +370,7 @@ namespace
             else
             {
                 test_output << log_prefix << _X("hostfxr_get_runtime_delegate succeeded: ") << std::hex << std::showbase << rc << std::endl;
-                rc = call_delegate_flavour(delegate, assembly_path, type_name, method_name, log_prefix, test_output);
+                rc = call_load_assembly_and_get_function_pointer_flavour(delegate, assembly_path, type_name, method_name, log_prefix, test_output);
             }
         }
 
@@ -603,7 +603,7 @@ bool host_context_test::non_context_mixed(
     return success;
 }
 
-bool host_context_test::load_assembly_and_get_function_pointer(
+bool host_context_test::component_load_assembly_and_get_function_pointer(
     const pal::string_t &hostfxr_path,
     const pal::char_t *config_path,
     int argc,
@@ -612,7 +612,7 @@ bool host_context_test::load_assembly_and_get_function_pointer(
 {
     hostfxr_exports hostfxr{ hostfxr_path };
 
-    return load_assembly_and_get_function_pointer_test(hostfxr, config_path, argc, argv, config_log_prefix, test_output);
+    return component_load_assembly_and_get_function_pointer_test(hostfxr, config_path, argc, argv, config_log_prefix, test_output);
 }
 
 bool host_context_test::app_load_assembly_and_get_function_pointer(

src/installer/corehost/cli/test/nativehost/host_context_test.h

@@ -59,7 +59,7 @@ namespace host_context_test
         int argc,
         const pal::char_t *argv[],
         pal::stringstream_t &test_output);
-    bool load_assembly_and_get_function_pointer(
+    bool component_load_assembly_and_get_function_pointer(
         const pal::string_t &hostfxr_path,
         const pal::char_t *config_path,
         int argc,

src/installer/corehost/cli/test/nativehost/nativehost.cpp

@@ -215,7 +215,7 @@ int main(const int argc, const pal::char_t *argv[])
         std::cout << tostr(test_output.str()).data() << std::endl;
         return success ? EXIT_SUCCESS : EXIT_FAILURE;
     }
-    else if (pal::strcmp(command, _X("load_assembly_and_get_function_pointer")) == 0)
+    else if (pal::strcmp(command, _X("component_load_assembly_and_get_function_pointer")) == 0)
     {
         // args: ... <hostfxr_path> <app_or_config_path> <assembly_path> <type_name> <method_name> [<assembly_path> <type_name> <method_name>...]
         const int min_argc = 4;
@@ -236,7 +236,7 @@ int main(const int argc, const pal::char_t *argv[])
         pal::stringstream_t test_output;
         bool success = false;
 
-        success = host_context_test::load_assembly_and_get_function_pointer(hostfxr_path, app_or_config_path, remaining_argc, remaining_argv, test_output);
+        success = host_context_test::component_load_assembly_and_get_function_pointer(hostfxr_path, app_or_config_path, remaining_argc, remaining_argv, test_output);
 
         std::cout << tostr(test_output.str()).data() << std::endl;
         return success ? EXIT_SUCCESS : EXIT_FAILURE;

src/installer/tests/Assets/TestProjects/ComponentWithNoDependencies/ComponentWithNoDependencies.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
     <RuntimeFrameworkVersion>$(MNAVersion)</RuntimeFrameworkVersion>
-    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
   </PropertyGroup>
 
 </Project>