是否可以动态编译和执行c#代码片段?

我想知道是否有可能将c#代码片段保存到文本文件(或任何输入流)，然后动态执行这些?假设提供给我的内容将在任何Main()块内编译良好，是否有可能编译和/或执行此代码?出于性能考虑，我更愿意编译它。

至少，我可以定义他们需要实现的接口，然后他们将提供实现该接口的代码“部分”。

151869 次浏览
小开

为了编译，你可以对csc编译器发起一个shell调用。你可能会头疼试图保持你的路径和开关直，但这肯定是可以做到的。

c# Corner Shell Examples .

编辑:或者更好的是，像Noldorin建议的那样使用CodeDOM…

小开
最佳答案

c# /所有静态. net语言的最佳解决方案是使用CodeDOM来处理这些事情。(需要注意的是，它的另一个主要目的是动态构造代码位，甚至整个类。)

下面是来自LukeH的博客的一个很好的简短例子，它也使用了一些LINQ只是为了好玩。

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.CSharp;
using System.CodeDom.Compiler;


class Program
{
static void Main(string[] args)
{
var csc = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } });
var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.Core.dll" }, "foo.exe", true);
parameters.GenerateExecutable = true;
CompilerResults results = csc.CompileAssemblyFromSource(parameters,
@"using System.Linq;
class Program {
public static void Main(string[] args) {
var q = from i in Enumerable.Range(1,100)
where i % 2 == 0
select i;
}
}");
results.Errors.Cast<CompilerError>().ToList().ForEach(error => Console.WriteLine(error.ErrorText));
}
}

这里最重要的类是CSharpCodeProvider，它利用编译器动态编译代码。如果希望随后运行代码，只需要使用一些反射来动态加载程序集并执行它。

在这里是c#中的另一个例子，它(虽然稍微不那么简洁)还精确地展示了如何使用System.Reflection命名空间运行运行时编译的代码。

小开

关于如何在运行时生成代码，其他人已经给出了很好的答案，所以我想我应该谈谈你的第二段。我在这方面有一些经验，只是想分享我从中学到的一课。

至少，我可以定义一个 接口，它们将被要求 为了实现，他们会提供 代码“section”实现了这一点 接口。< / p >

如果使用interface作为基类型，可能会遇到问题。如果将来向interface添加一个新方法，所有现有的实现interface的客户端提供的类现在都变成了抽象类，这意味着您将无法在运行时编译或实例化客户端提供的类。

在发布旧接口大约1年之后，在分发了大量需要支持的“遗留”数据之后，需要添加新方法时，我遇到了这个问题。我最终创建了一个继承自旧接口的新接口，但这种方法使加载和实例化客户端提供的类变得更加困难，因为我必须检查哪个接口可用。

我当时想到的一个解决方案是使用一个实际的类作为基类型，如下所示。类本身可以被标记为抽象的，但是所有的方法都应该是空的虚方法(不是抽象方法)。然后，客户端可以重写他们想要的方法，我可以向基类添加新方法，而不会使现有的客户端提供的代码无效。

public abstract class BaseClass
{
public virtual void Foo1() { }
public virtual bool Foo2() { return false; }
...
}

不管这个问题是否适用，您都应该考虑如何对代码库和客户端提供的代码之间的接口进行版本控制。

小开

您可以将一段c#代码编译到内存中并生成程序集字节与罗斯林。上面已经提到过了，但是值得在这里添加一些Roslyn的例子。完整的示例如下:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Emit;


namespace RoslynCompileSample
{
class Program
{
static void Main(string[] args)
{
// define source code, then parse it (to the type used for compilation)
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@"
using System;


namespace RoslynCompileSample
{
public class Writer
{
public void Write(string message)
{
Console.WriteLine(message);
}
}
}");


// define other necessary objects for compilation
string assemblyName = Path.GetRandomFileName();
MetadataReference[] references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location)
};


// analyse and generate IL code from syntax tree
CSharpCompilation compilation = CSharpCompilation.Create(
assemblyName,
syntaxTrees: new[] { syntaxTree },
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));


using (var ms = new MemoryStream())
{
// write IL code into memory
EmitResult result = compilation.Emit(ms);


if (!result.Success)
{
// handle exceptions
IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);


foreach (Diagnostic diagnostic in failures)
{
Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
}
}
else
{
// load this 'virtual' DLL so that we can use
ms.Seek(0, SeekOrigin.Begin);
Assembly assembly = Assembly.Load(ms.ToArray());


// create instance of the desired class and call the desired function
Type type = assembly.GetType("RoslynCompileSample.Writer");
object obj = Activator.CreateInstance(type);
type.InvokeMember("Write",
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
obj,
new object[] { "Hello World" });
}
}


Console.ReadLine();
}
}
}
小开

发现这很有用-确保编译后的程序集引用你当前引用的所有内容，因为你很有可能希望你正在编译的c#在代码中使用一些类等。

(字符串code是正在编译的动态c#)

        var refs = AppDomain.CurrentDomain.GetAssemblies();
var refFiles = refs.Where(a => !a.IsDynamic).Select(a => a.Location).ToArray();
var cSharp = (new Microsoft.CSharp.CSharpCodeProvider()).CreateCompiler();
var compileParams = new System.CodeDom.Compiler.CompilerParameters(refFiles);
compileParams.GenerateInMemory = true;
compileParams.GenerateExecutable = false;


var compilerResult = cSharp.CompileAssemblyFromSource(compileParams, code);
var asm = compilerResult.CompiledAssembly;

在我的例子中，我发出了一个类，它的名称存储在字符串className中，它有一个名为Get()的公共静态方法，返回类型为StoryDataIds。下面是调用该方法的样子:

        var tempType = asm.GetType(className);
var ids = (StoryDataIds)tempType.GetMethod("Get").Invoke(null, null);

警告:编译可能会异常缓慢。在我们相对快速的服务器上，一小段相对简单的10行代码以正常优先级在2-10秒内编译完成。永远不要将对CompileAssemblyFromSource()的调用绑定到任何具有正常性能期望的东西上，比如web请求。相反，在低优先级线程上主动编译需要的代码，并有一种方法来处理需要该代码准备好的代码，直到它有机会完成编译。例如，您可以在批处理作业过程中使用它。

小开

我最近需要生成用于单元测试的进程。这篇文章很有用，因为我创建了一个简单的类来使用字符串代码或来自我的项目的代码来做到这一点。要构建这个类，你需要ICSharpCode.Decompiler和Microsoft.CodeAnalysis NuGet包。这是这个类:

using ICSharpCode.Decompiler;
using ICSharpCode.Decompiler.CSharp;
using ICSharpCode.Decompiler.TypeSystem;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;


public static class CSharpRunner
{
public static object Run(string snippet, IEnumerable<Assembly> references, string typeName, string methodName, params object[] args) =>
Invoke(Compile(Parse(snippet), references), typeName, methodName, args);


public static object Run(MethodInfo methodInfo, params object[] args)
{
var refs = methodInfo.DeclaringType.Assembly.GetReferencedAssemblies().Select(n => Assembly.Load(n));
return Invoke(Compile(Decompile(methodInfo), refs), methodInfo.DeclaringType.FullName, methodInfo.Name, args);
}


private static Assembly Compile(SyntaxTree syntaxTree, IEnumerable<Assembly> references = null)
{
if (references is null) references = new[] { typeof(object).Assembly, typeof(Enumerable).Assembly };
var mrefs = references.Select(a => MetadataReference.CreateFromFile(a.Location));
var compilation = CSharpCompilation.Create(Path.GetRandomFileName(), new[] { syntaxTree }, mrefs, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));


using (var ms = new MemoryStream())
{
var result = compilation.Emit(ms);
if (result.Success)
{
ms.Seek(0, SeekOrigin.Begin);
return Assembly.Load(ms.ToArray());
}
else
{
throw new InvalidOperationException(string.Join("\n", result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error).Select(d => $"{d.Id}: {d.GetMessage()}")));
}
}
}


private static SyntaxTree Decompile(MethodInfo methodInfo)
{
var decompiler = new CSharpDecompiler(methodInfo.DeclaringType.Assembly.Location, new DecompilerSettings());
var typeInfo = decompiler.TypeSystem.MainModule.Compilation.FindType(methodInfo.DeclaringType).GetDefinition();
return Parse(decompiler.DecompileTypeAsString(typeInfo.FullTypeName));
}


private static object Invoke(Assembly assembly, string typeName, string methodName, object[] args)
{
var type = assembly.GetType(typeName);
var obj = Activator.CreateInstance(type);
return type.InvokeMember(methodName, BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, args);
}


private static SyntaxTree Parse(string snippet) => CSharpSyntaxTree.ParseText(snippet);
}

要使用它，调用Run方法，如下所示:

void Demo1()
{
const string code = @"
public class Runner
{
public void Run() { System.IO.File.AppendAllText(@""C:\Temp\NUnitTest.txt"", System.DateTime.Now.ToString(""o"") + ""\n""); }
}";


CSharpRunner.Run(code, null, "Runner", "Run");
}


void Demo2()
{
CSharpRunner.Run(typeof(Runner).GetMethod("Run"));
}


public class Runner
{
public void Run() { System.IO.File.AppendAllText(@"C:\Temp\NUnitTest.txt", System.DateTime.Now.ToString("o") + "\n"); }
}
小开 
using System.CodeDom.Compiler;
using System.Diagnostics;
using Microsoft.CSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Reflection;


namespace ASL
{
class Program
{
[Obsolete]
static void Main(string[] args)
{
string code = @"
using System;


namespace First
{
public class Program
{
public static void Main()
{
" +
"Console.WriteLine(\"Hello, world!\");"
+ @"
}
}
}";
Console.WriteLine(code);
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters();
// Reference to System.Drawing library
parameters.ReferencedAssemblies.Add("System.Drawing.dll");
// True - memory generation, false - external file generation
parameters.GenerateInMemory = true;
// True - exe file generation, false - dll file generation
parameters.GenerateExecutable = true;
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();


foreach (CompilerError error in results.Errors)
{
sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
}


throw new InvalidOperationException(sb.ToString());
}
Assembly assembly = results.CompiledAssembly;
Type program = assembly.GetType("First.Program");
MethodInfo main = program.GetMethod("Main");
main.Invoke(null, null);
Console.ReadLine();
}
}
}

提交答案