C#动态执行脚本的3种方式详解

在C#中动态执行脚本是一种很常见的需求，在某些场景下它可以帮助我们实现更灵活的代码设计。本文将详细讲解C#中动态执行脚本的3种方式。

1. 使用CSharpCodeProvider

CSharpCodeProvider 是 .NET Framework 类库中的一种类型，可以用来在运行时编译、执行C#代码。其主要思路是将用户提供的代码字符串编译为在内存中的程序集，并在后续操作中执行这个程序集。下面是使用这种方式动态执行脚本的示例代码：

using Microsoft.CSharp;
using System;
using System.CodeDom.Compiler;
using System.Reflection;

namespace ScriptingExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 代码字符串，可以从数据库、文本文件、Web API 等地方获取
            string code = @"
            using System;
            public class Script
            {   
                public static void Execute()
                {
                    Console.WriteLine(""Hello Dynamic Scripting!"");
                }
            }";

            CSharpCodeProvider provider = new CSharpCodeProvider();
            CompilerParameters parameters = new CompilerParameters();
            parameters.GenerateExecutable = false;
            parameters.GenerateInMemory = true;

            CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
            if (results.Errors.HasErrors)
            {
                Console.WriteLine(results.Errors[0]);
            }
            else
            {
                Assembly assembly = results.CompiledAssembly;
                Type type = assembly.GetType("Script");
                MethodInfo method = type.GetMethod("Execute");
                method.Invoke(null, null);
            }
        }
    }
}

在以上示例中，我们定义了一个字符串变量 code，并将其作为参数传入了 CSharpCodeProvider 的 CompileAssemblyFromSource 方法中。这个方法的作用是将 code 字符串编译为一个程序集，而 parameters 则是编译的参数配置，其中 GenerateExecutable 属性表示是否生成可执行文件，GenerateInMemory 属性表示是否将程序集加载到内存中运行。

如果编译错误，我们可以通过 CompilerResults 类型的 Errors 属性获取错误信息，否则我们可以将编译好的程序集用 Assembly 类型表示，并通过反射获取其中的类型、方法等信息进行调用。

2. 使用Roslyn

Roslyn 是一个由 Microsoft 开源的 C# 和 VB.NET 的编译器，也提供了动态编译和执行C#代码的 API。相比于 CSharpCodeProvider，它的语法分析和错误提示更加友好，使用起来也更加灵活。

下面是使用 Roslyn 动态执行脚本的示例代码：

using System;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Scripting;

namespace ScriptingExample
{
    class Program
    {
        static async System.Threading.Tasks.Task Main(string[] args)
        {
            // 代码字符串，可以从数据库、文本文件、Web API 等地方获取
            string code = @"
            public class Script
            {   
                public static void Execute()
                {
                    Console.WriteLine(""Hello Roslyn!"");
                }
            }";

            ScriptOptions options = ScriptOptions.Default;
            options = options.AddReferences(typeof(Console).Assembly);
            options = options.AddReferences(typeof(System.Runtime.AssemblyTargetedPatchBandAttribute).Assembly);
            options = options.WithImports("System");

            Script script = CSharpScript.Create(code, options, typeof(ScriptHost));
            Compilation compilation = script.GetCompilation();
            if (compilation.GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error))
            {
                Console.WriteLine(compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error));
                return;
            }

            ScriptState state = await script.RunAsync(new ScriptHost());
        }
    }

    public class ScriptHost
    {
    }
}

在以上示例中，我们使用了 CSharpScript.Create 方法将代码字符串编译为一个脚本。使用 Roslyn 的时候需要注意，如果要使用大部分的命名空间和类型，需要在 ScriptOptions 对象中配置正确的引用和导入语句，否则会出现编译错误。在编译通过后，我们可以通过 script.RunAsync 方法运行这段脚本，同时可以配置好 ScriptHost 类型，为脚本提供必要的环境。

3. 使用动态编译器

除了 CSharpCodeProvider 和 Roslyn 外，还有一些动态编译器可以用来动态执行脚本，如 Mono.CSharp.Compiler 和 CodeDom.Compiler.CodeCompiler。

在这里着重介绍了一下 Mono.CSharp.Compiler 的使用，在此不再赘述其他动态编译器的使用方法，感兴趣的读者可以查阅相关文档。

using System;
using System.IO;
using System.Text;
using Mono.CSharp;

namespace ScriptingExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 代码字符串，可以从数据库、文本文件、Web API 等地方获取
            string code = @"
            using System;
            public class Script
            {   
                public static void Execute()
                {
                    Console.WriteLine(""Hello Mono.CSharp.Compiler!"");
                }
            }";

            Evaluator.Init(new string[0]);
            Evaluator.Evaluate(new MemoryStream(Encoding.UTF8.GetBytes(code)));
        }
    }
}

在上述 Mono.CSharp.Compiler 的示例中，我们首先使用 Evaluator.Init 初始化编译器，然后使用 Evaluator.Evaluate 执行代码字符串，这两个方法的作用和 CSharpCodeProvider 的 CompileAssemblyFromSource 相似，用于将代码字符串编译并执行。需要注意的是，Mono.CSharp.Compiler 在某些状况下会出现兼容性问题，应该根据实际需求进行选择。

总结

以上就是在C#中动态执行脚本的3种方式，每种方式都有各自的特点和优缺点，使用时应根据实际需求综合选择。