如何在其他 Roslyn 编译中使用 Roslyn 脚本提交作为程序集

Question

我想在另一个非脚本 Roslyn 编译中将脚本作为动态程序集重用，但我终其一生都无法弄清楚如何实现这一目标。

例如，假设我以正常方式创建脚本，然后将脚本作为程序集发送到字节流，使用类似：

var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
var compilation = script.GetCompilation().WithOptions(compilationOptions);
using (var ms = new MemoryStream())
{
    EmitResult result = compilation.Emit(ms);
    ms.Seek(0, SeekOrigin.Begin);
    assembly = Assembly.Load(ms.ToArray());
}

现在，假设我想将该程序集作为参考提供给另一个非脚本编译。我不能只使用assembly，因为没有MetadataReference.CreateFrom...() 方法支持传递实际的Assembly 实例。作为一个动态程序集，它没有位置，所以我不能使用MetadataReference.CreateFromFile()。

过去我曾成功使用MetadataReference.CreateFromStream() 处理此类事情，但当程序集表示脚本提交时，这似乎不起作用（我不知道为什么）。编译继续进行，但一旦您尝试使用提交中的类型，您就会收到如下错误：

System.InvalidCastException: [A]Foo cannot be cast to [B]Foo. Type A originates from 'R*19cecf20-a48e-4a31-9b65-4c0163eba857#1-0, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' in the context 'LoadNeither' in a byte array. Type B originates from 'R*19cecf20-a48e-4a31-9b65-4c0163eba857#1-0, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null' in the context 'LoadNeither' in a byte array.

我猜这与提交程序集在评估与加载为字节数组时处于不同的上下文中有关。对于在以后的非脚本编译中使用脚本提交中定义的对象和方法的最佳方式，我很乐意提供任何见解或指导。

7/29 更新

我能够获得演示问题的最小重现。可以在https://github.com/daveaglick/ScriptingAssemblyReuse找到。

在生成重现时，很明显这个问题的一个重要组成部分是脚本将其中一个类的Type 传递给调用代码，然后调用代码使用该Type 来实例化一个对象的实例，然后将该实例传递到引用脚本程序集的编译中。当从宿主应用程序创建的类型的实例转换为引用编译中的类型时，会发生不匹配。当我重新阅读时，这听起来很混乱，所以希望下面的代码能让它更清晰。

以下是触发此问题的所有代码：

namespace ScriptingAssemblyReuse
{
    public class Globals
    {
        public IFactory Factory { get; set; }    
    }

    public interface IFactory
    {
        object Get();
    }

    public class Factory<T> : IFactory where T : new()
    {
        public object Get() => new T();
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            new Program().Run();
        }

        private Assembly _scriptAssembly;

        public void Run()
        {
            AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;

            // Create the script
            Script<object> script = CSharpScript.Create(@"
                public class Foo { }
                Factory = new ScriptingAssemblyReuse.Factory<Foo>();
                ", ScriptOptions.Default.WithReferences(MetadataReference.CreateFromFile(typeof(IFactory).Assembly.Location)), typeof(Globals));

            // Create a compilation and get the dynamic assembly
            CSharpCompilationOptions scriptCompilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
            Compilation scriptCompilation = script.GetCompilation().WithOptions(scriptCompilationOptions);
            byte[] scriptAssemblyBytes;
            using (MemoryStream ms = new MemoryStream())
            {
                EmitResult result = scriptCompilation.Emit(ms);
                ms.Seek(0, SeekOrigin.Begin);
                scriptAssemblyBytes = ms.ToArray();
            }
            _scriptAssembly = Assembly.Load(scriptAssemblyBytes);

            // Evaluate the script
            Globals globals = new Globals();
            script.RunAsync(globals).Wait();

            // Create the consuming compilation
            string assemblyName = Path.GetRandomFileName();
            CSharpParseOptions parseOptions = new CSharpParseOptions();
            SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@"
                public class Bar
                {
                    public void Baz(object obj)
                    {
                        Script.Foo foo = (Script.Foo)obj;  // This is the line that triggers the exception 
                    }
                }", parseOptions, assemblyName);
            CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
            string assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
            CSharpCompilation compilation = CSharpCompilation.Create(assemblyName, new[] {syntaxTree},
                new[]
                {
                    MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "mscorlib.dll")),
                    MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")),
                    MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")),
                    MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll"))
                }, compilationOptions);
            using (MemoryStream ms = new MemoryStream(scriptAssemblyBytes))
            {
                compilation = compilation.AddReferences(MetadataReference.CreateFromStream(ms));
            }

            // Get the consuming assembly
            Assembly assembly;
            using (MemoryStream ms = new MemoryStream())
            {
                EmitResult result = compilation.Emit(ms);
                ms.Seek(0, SeekOrigin.Begin);
                byte[] assemblyBytes = ms.ToArray();
                assembly = Assembly.Load(assemblyBytes);
            }

            // Call the consuming assembly
            Type barType = assembly.GetExportedTypes().First(t => t.Name.StartsWith("Bar", StringComparison.Ordinal));
            MethodInfo bazMethod = barType.GetMethod("Baz");
            object bar = Activator.CreateInstance(barType);
            object obj = globals.Factory.Get();
            bazMethod.Invoke(bar, new []{ obj });  // The exception bubbles up and gets thrown here
        }

        private Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
        {
            if (_scriptAssembly != null && args.Name == _scriptAssembly.FullName)
            {
                // Return the dynamically compiled script assembly if given it's name
                return _scriptAssembly;
            }
            return null;
        }
    }
}

Answer 1

我想我已经解开了这个谜。以下是发生的事情：

• 创建一个脚本。
• 获取脚本的编译，但覆盖编译选项。具体来说，它使用默认的ScriptClassName，即Script，而不是由脚本API 生成的（例如Submission#0） - 这是问题的症结。
• 使用覆盖的选项发出程序集并将其从流中加载到内存中。
• 运行脚本。此时，使用字节数组将两个不同且不兼容的同名程序集加载到AppDomain。
• 将流作为元数据引用添加到新编辑并在代码中使用。它编译得很好，因为它使用了从覆盖选项生成的程序集。您将无法使用脚本创建的实际程序集来编译它，因为 Submission#0 之类的名称在 C# 中是非法的。如果不是，那么您可以将实际脚本 Assembly 实例放在全局变量中并在 OnAssemblyResolve 中使用它。
• 使用Submission#0+Foo 类型的参数调用方法Baz 并尝试将其强制转换为Script+Foo。

总结 - 我认为使用当前的 Roslyn 脚本 API 是不可能的。但是，这些 API 并不是编译脚本的唯一方法。您可以自己创建一个编译并将SourceCodeKind 设置为Script。你必须自己做很多事情，比如运行主脚本方法、处理全局变量等。我做了类似in RoslynPad 的事情，因为我希望脚本程序集与 PDB 一起加载（所以异常会有行信息） .