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

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

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

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

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

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

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

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

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

我已经阅读了谷歌提供的有关此错误的所有内容，但我不知所措。有人可以告诉我为什么会发生这种情况，并为我如何实现简单链接到公共共享库的最初目标提供额外的互联网积分吗？

相关代码

    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
            }
        }
    }
}

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 core 中使用 Roslyn 跨平台动态编译代码。