如何缓存程序集以供以后编译？ [罗斯林]

Question

In my project I'm gonna compile lots of assemblies using the same reference assemblies for each compilation (about 30 dlls). Seems like after the first compilation reference assemblies are cached and huge speed boost is achieved starting from second compilation (1360ms -> 40ms). I want to cache all reference assemblies before compiling new assemblies.

Assemblies are cached during CSharpCompilation.Create(name, syntaxTrees, references) method. This method requires syntaxTree to compile, but I only want to cache references. What I need to invoke to cache references?

Main compilation code:

List<MetadataReference> references = new List<MetadataReference>();
foreach (var reference in assemblies)
{
   try
   {
      references.Add(MetadataReference.CreateFromFile(reference));
   }
   catch (Exception e)
   {
      error += e + "\n";
      exitCode |= (int)ExitCode.ReferenceError;
   }
}

CSharpCompilation compilation = null;
compilation = CSharpCompilation.Create(
   assemblyName,
   syntaxTrees: syntaxTree,
   references: references,
   options: new CSharpCompilationOptions(
      OutputKind.DynamicallyLinkedLibrary,
      optimizationLevel: OptimizationLevel.Release,
      allowUnsafe: true));

Answer 1

Note that the cost of the 'first run' might not be the consumed assemblies, but simply the runtime having to JIT Roslyn itself; later Compilations are taking advantage of that fact as well.

That said, there are already caches behind the scenes where we reuse the loaded metadata information between created Compilations. Those will kick in automatically as long as we recognize the assemblies are being reused. The best way to ensure the cache is being used would be to reuse the same MetadataReference objects you get back from CreateFromFile just to simplify the cache being triggered. But you don't really have to do any explicit caching -- we're already doing that for you!

Note you can also create a Compilation from an existing Compilation but replacing syntax trees; so you could make a single Compilation with just the references, and then take that and call.WithSyntaxTree() to produce a new Compilation with those trees -- you can keep going back to that first one and 'forking' it with new trees. That might be a bit faster as well, but you'd have to benchmark it accordingly.