.Net Core - CS0012“对象”在未引用的程序集中定义

Question

我是 .Net Core 的新手，我正在尝试基于它构建一个构建系统。作为该项目的一部分，我创建了一个抽象类来说明构建任务应该实现的内容，并将其填充到一个共享库中。

可执行项目引用此库并扫描项目目录以查找特殊命名的目录，然后检查其中是否有任何.cs 文件。加载这些脚本，然后使用Microsoft.CodeAnalysis 和朋友提供的工具尝试编译。

在这样的背景下，我在编译阶段遇到了一个奇怪的问题：

如果我尝试将包含抽象类的共享库作为参考提供给编译过程，则会收到以下错误：

失败的 CS0012：“对象”类型是在不是 参考。您必须添加对程序集“mscorlib”的引用， 版本=4.0.0.0，文化=中性，PublicKeyToken=7cec85d7bea7798e'。

接着是一堆关于预定义类型的抱怨：

CS0518：未定义或导入预定义类型“System.Boolean” CS0518：未定义或导入预定义类型“System.Boolean” CS0518：未定义或导入预定义类型“System.Void”... 等等等等。

但是，如果我省略引用，而是将每个共享库的源文件解析为语法树并将它们传递给编译过程，那么整个过程就会成功，并且我会得到一个返回的内存程序集，我可以从中提取类型并实例化。

我已经阅读了 Google 提供的有关此错误的所有内容，但我不知所措。有人能告诉我为什么会发生这种情况，以及如何实现我最初的目标，即简单地链接到一个公共共享库中吗？

相关代码

    CSharpParseOptions parseOptions = CSharpParseOptions.Default;

    SyntaxTree jobSyntaxTree = CSharpSyntaxTree.ParseText(scriptContents, parseOptions);

    string generatedAssemblyName = Path.GetRandomFileName();
    var referencedAssemblies = Assembly.GetEntryAssembly().GetReferencedAssemblies();

    foreach(var referencedAssembly in referencedAssemblies)
    {
        var rfas = Assembly.Load(referencedAssembly);
        references.Add(MetadataReference.CreateFromFile(rfas.Location)); 
    }

    var op = new  CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);

    CSharpCompilation compilation = CSharpCompilation.Create(
       generatedAssemblyName,
       syntaxTrees: new[] { jobSyntaxTree },
       references: references,
       options: op);

    var ms = new MemoryStream();

    EmitOptions emitOptions = new EmitOptions();

    EmitResult result = compilation.Emit(ms);

    if(result.Success)
    {
       // Yay
    }
    else
    {
       // Boo-hoo
    }

共享库的 Project.json 文件

{
    "title": "BuildBotCore",
    "version": "1.0.0-*",
    "buildOptions": {
        "emitEntryPoint": false,
        "preserveCompilationContext": true
    },
    "dependencies": {
        "Microsoft.NETCore.App": {
            "type": "platform",
            "version": "1.0.0"
        },
        "System.Runtime": "4.1.0",
        "System.Runtime.Loader": "4.0.0",
        "Microsoft.NETCore.Portable.Compatibility": "1.0.1"
    },
    "frameworks": {
        "netcoreapp1.0": {
            "imports": "netcore50",
            "buildOptions": {
                "preserveCompilationContext": true
            }
        }
    },
    "configurations": {
        "Debug": {
            "buildOptions": {
                "define": [
                    "DEBUG",
                    "TRACE"
                ],
                "optimize": false,
                "preserveCompilationContext": true
            }
        },
        "Release": {
            "buildOptions": {
                "define": [
                    "RELEASE",
                    "TRACE"
                ],
                "optimize": true,
                "preserveCompilationContext": true
            }
        }
    }
}

主要可执行文件的 Project.json

{
    "version": "1.0.0-*",
    "buildOptions": {
        "emitEntryPoint": true,
        "preserveCompilationContext": true
    },
    "dependencies": {
        "Microsoft.NETCore.App": {
            "type": "platform",
            "version": "1.0.0"
        },
        "System.Runtime": "4.1.0",
        "Microsoft.CodeAnalysis.CSharp": "1.3.2",
        "System.Runtime.Loader": "4.0.0",
        "Microsoft.NETCore.Portable.Compatibility": "1.0.1",
        "BuildBotCore": "1.0.0-*"
    },
    "frameworks": {
        "netcoreapp1.0": {
            "imports": "netcore50",
            "buildOptions": {
                "preserveCompilationContext": true
            }
        }
    },
    "configurations": {
        "Debug": {
            "buildOptions": {
                "define": [
                    "DEBUG",
                    "TRACE"
                ],
                "optimize": false,
                "preserveCompilationContext": true
            }
        },
        "Release": {
            "buildOptions": {
                "define": [
                    "RELEASE",
                    "TRACE"
                ],
                "optimize": true,
                "preserveCompilationContext": true
            }
        }
    }
}

Answer 1

TL;DR
归根结底，您需要传递对“mscorlib.dll”及其私有变体的引用。这将使上述编译错误消失。这也是 .net core 中的跨平台，因为我已经在 Linux 和 Windows 上测试过这个解决方案。

完整版和代码示例
由于我正在等待帐户删除，我将发布最后一个答案。

解决方案是根据其他类型程序集的位置手动包含 mscorlib.dll。像这样：

// Get the directory of a core assembly. We need this directory to
// build out our platform specific reference to mscorlib. mscorlib
// and the private mscorlib must be supplied as references for
// compilation to succeed. Of these two assemblies, only the private
// mscorlib is discovered via enumerataing assemblies referenced by
// this executing binary.
var dd = typeof(Enumerable).GetTypeInfo().Assembly.Location;
var coreDir = Directory.GetParent(dd);            

List<MetadataReference> references = new List<MetadataReference>
{   
    // Here we get the path to the mscorlib and private mscorlib
    // libraries that are required for compilation to succeed.
    MetadataReference.CreateFromFile(coreDir.FullName + Path.DirectorySeparatorChar + "mscorlib.dll"),
    MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)           
};

还有第二个 mscorelib，但它的名称以“private”为前缀。这是由执行程序集自动引用的，因此不需要像上面那样手动生成它的路径。

当您从正在执行动态代码编译的执行程序集中提取引用时，您将获得此私有 mscorlib。像这样：

// Enumerate all assemblies referenced by this executing assembly
// and provide them as references to the build script we're about to
// compile.
var referencedAssemblies = Assembly.GetEntryAssembly().GetReferencedAssemblies();
foreach(var referencedAssembly in referencedAssemblies)
{
    var loadedAssembly = Assembly.Load(referencedAssembly);   

    references.Add(MetadataReference.CreateFromFile(loadedAssembly.Location)); 
}

所以现在这些引用已经组装好了，您可以简单地将它们传递给您的代码编译：

// Initialize the compilation with our options, references and the
// already parsed syntax tree of the build script.
CSharpCompilation compilation = CSharpCompilation.Create(
    generatedAssemblyName,
    syntaxTrees: new[] { jobSyntaxTree },
    references: references,
    options: op);           

// Compile and emit new assembly into memory.
var ms = new MemoryStream();
EmitResult result = compilation.Emit(ms);

...瞧，您可以在 .Net 核心中使用 Roslyn 跨平台动态编译代码。