等效于.NET中的类加载器

答案是肯定的,但解决方法有点棘手。

这个 System.Reflection.Emit 命名空间定义允许动态生成程序集的类型。它们还允许增量定义生成的程序集。换句话说,可以向动态程序集添加类型,执行生成的代码,然后后者向程序集添加更多类型。

这个 System.AppDomain 类还定义了 AssemblyResolve 每当框架未能加载程序集时激发的事件。通过为该事件添加处理程序,可以定义一个单独的“运行时”程序集,将所有“构造的”类型都放入其中。编译器生成的使用构造类型的代码将引用运行时程序集中的类型。因为运行时程序集实际上不存在于磁盘上,所以 汇编解析 当编译的代码第一次尝试访问构造的类型时,将激发事件。然后,事件的句柄将生成动态程序集并将其返回到CLR。

不幸的是,要使这项工作顺利进行还有一些棘手的问题。第一个问题是确保在运行已编译的代码之前始终安装事件处理程序。使用控制台应用程序,这很容易。用于连接事件处理程序的代码可以添加到 Main 方法。但是,对于类库,没有主方法。DLL可以作为用另一种语言编写的应用程序的一部分进行加载,因此不可能假定始终存在可用于连接事件处理程序代码的主方法。

第二个问题是确保引用的类型都在使用引用它们的任何代码之前插入到动态程序集中。这个 系统.appdomain 类还定义了 TypeResolve 每当CLR无法解析动态程序集中的类型时执行的事件。它使事件处理程序有机会在使用它的代码运行之前在动态程序集中定义类型。但是,在这种情况下,该事件将不起作用。即使引用的程序集是动态定义的,CLR也不会为其他程序集“静态引用”的程序集触发事件。这意味着我们需要一种方法来在编译程序集中的任何其他代码运行之前运行代码,并让它动态地将所需的类型注入到运行时程序集中(如果尚未定义这些类型的话)。否则,当CLR尝试加载这些类型时,它将注意到动态程序集不包含它们需要的类型,并将引发类型加载异常。

幸运的是,clr提供了两个问题的解决方案:模块初始值设定项。模块初始值设定项等价于“静态类构造函数”,只是它初始化了整个模块,而不仅仅是单个类。贝塞尔,CLR将:

1. 在访问模块内的任何类型之前运行模块构造函数。
2. 确保只有模块构造函数直接访问的类型才会在执行时加载
3. 在构造函数完成之前,不允许模块外部的代码访问它的任何成员。

它为所有程序集(包括类库和可执行文件)执行此操作,并且for-exes将在执行主方法之前运行模块构造函数。

看到这个 blog post 有关构造函数的详细信息。

在任何情况下,解决我的问题都需要几个步骤:

1. 在“语言运行时dll”中定义的下列类定义,由编译器生成的所有程序集引用(这是C代码)。

   using System;
   using System.Collections.Generic;
   using System.Reflection;
   using System.Reflection.Emit;
   
   namespace SharedLib
   {
       public class Loader
       {
           private Loader(ModuleBuilder dynamicModule)
           {
               m_dynamicModule = dynamicModule;
               m_definedTypes = new HashSet<string>();
           }
   
           private static readonly Loader m_instance;
           private readonly ModuleBuilder m_dynamicModule;
           private readonly HashSet<string> m_definedTypes;
   
           static Loader()
           {
               var name = new AssemblyName("$Runtime");
               var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
               var module = assemblyBuilder.DefineDynamicModule("$Runtime");
               m_instance = new Loader(module);
               AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
           }
   
           static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
           {
               if (args.Name == Instance.m_dynamicModule.Assembly.FullName)
               {
                   return Instance.m_dynamicModule.Assembly;
               }
               else
               {
                   return null;
               }
           }
   
           public static Loader Instance
           {
               get
               {
                   return m_instance;
               }
           }
   
           public bool IsDefined(string name)
           {
               return m_definedTypes.Contains(name);
           }
   
           public TypeBuilder DefineType(string name)
           {
               //in a real system we would not expose the type builder.
               //instead a AST for the type would be passed in, and we would just create it.
               var type = m_dynamicModule.DefineType(name, TypeAttributes.Public);
               m_definedTypes.Add(name);
               return type;
           }
       }
   }
   

   类定义了一个singleton,它保存对将在其中创建构造类型的动态程序集的引用。它还保存一个“哈希集”,存储已经动态生成的类型集,最后定义一个可用于定义类型的成员。此示例只返回System.Reflection.Emit.TypeBuilder实例,然后可以使用该实例定义正在生成的类。在实际系统中,该方法可能会采用类的AST表示,并且只进行它自己的生成。

2. 发出以下两个引用的已编译程序集(以ILASM语法显示):

   .assembly extern $Runtime
   {
       .ver 0:0:0:0
   }
   .assembly extern SharedLib
   {
       .ver 1:0:0:0
   }
   

   这里“sharedlib”是语言的预定义运行时库,其中包括上面定义的“loader”类,“$runtime”是将插入被构造类型的动态运行时程序集。

3. 在用该语言编译的每个程序集中都有一个“模块构造函数”。

   据我所知,没有.NET语言允许在源代码中定义模块构造函数。C++/CLI编译器是我所知道的唯一生成它们的编译器。在IL中,它们看起来像这样,直接在模块中定义,而不是在任何类型定义中定义:

   .method privatescope specialname rtspecialname static 
           void  .cctor() cil managed
   {
       //generate any constructed types dynamically here...
   }
   

   对我来说,我不需要编写定制的IL来实现这一点。我正在编写编译器,因此代码生成不是一个问题。

   对于使用类型的程序集 tuple<i as int, j as int> 和 tuple<x as double, y as double, z as double> 模块构造函数将需要生成如下类型(在C语法中):

   class Tuple_i_j<T, R>
   {
       public T i;
       public R j;
   }
   
   class Tuple_x_y_z<T, R, S>
   {
       public T x;
       public R y;
       public S z;
   }
   

   元组类作为通用类型生成,以解决可访问性问题。这将允许编译程序集中的代码使用 tuple<x as Foo> ,其中foo是一些非公共类型。

   执行此操作的模块构造函数的主体(此处仅显示一种类型,并用C语法编写)如下所示:

   var loader = SharedLib.Loader.Instance;
   lock (loader)
   {
       if (! loader.IsDefined("$Tuple_i_j"))
       {
           //create the type.
           var Tuple_i_j = loader.DefineType("$Tuple_i_j");
           //define the generic parameters <T,R>
          var genericParams = Tuple_i_j.DefineGenericParameters("T", "R");
          var T = genericParams[0];
          var R = genericParams[1];
          //define the field i
          var fieldX = Tuple_i_j.DefineField("i", T, FieldAttributes.Public);
          //define the field j
          var fieldY = Tuple_i_j.DefineField("j", R, FieldAttributes.Public);
          //create the default constructor.
          var constructor= Tuple_i_j.DefineDefaultConstructor(MethodAttributes.Public);
   
          //"close" the type so that it can be used by executing code.
          Tuple_i_j.CreateType();
       }
   }
   

所以在任何情况下,这就是我能够想到的在clr中实现自定义类装入器的大致等效的机制。

有人知道更简单的方法吗?

我认为这是DLR应该在C 4.0中提供的类型。信息还很难提供,但也许我们会在pdc08中学到更多。尽管如此,急切地等待着看到你的C 3解决方案…我猜它使用匿名类型。