C# 脚本化实现方式探究
C# 脚本化
.NET 编译平台介绍：
https://docs.microsoft.com/zh-cn/dotnet/csharp/roslyn-sdk/
使用 CodeDom
CodeDOM 提供表示多种常见源代码元素的类型。 可以设计一个程序，它使用 CodeDOM 元素生成源代码模型来组合对象图。 对于支持的编程语言，可使用 CodeDOM 代码生成器将此对象图呈现为源代码。 还可使用 CodeDOM 将源代码编译为二进制程序集。
CodeDOM 的常见用途包括：
- 模板化代码生成：生成适用于 ASP.NET、XML Web 服务客户端代理、代码向导、设计器或其他代码发出机制的代码。
- 动态编译：支持一种或多种语言的代码编译。
相关介绍：https://docs.microsoft.com/zh-cn/dotnet/framework/reflection-and-codedom/using-the-codedom
Roslyn
Roslyn为开源C＃和Visual Basic编译器提供了丰富的代码分析API。 它支持使用Visual Studio使用的相同API构建代码分析工具
开源地址：https://github.com/dotnet/roslyn
Microsoft Roslyn vs. CodeDom
关于 Roslyn 和 CodeDom 不同可以参考地址：
https://*.com/questions/7852926/microsoft-roslyn-vs-codedom
第三方工具库
开源地址：https://github.com/oleg-shilo/cs-script
CS-Script是一个基于CLR的脚本系统，它使用符合ECMA的C＃作为编程语言。
CS-Script允许无缝切换底层编译技术，而不会影响代码库。 目前支持的编译器是Mono，Roslyn和CodeDOM
实现方式
参见接口 IEvaluator.cs 。具体实现在注释中有介绍
public interface IEvaluator
{
/// <summary>
/// Gets or sets a value indicating whether to compile script with debug symbols.
/// <para>Note, affect of setting <c>DebugBuild</c> will always depend on the compiler implementation:
/// <list type="bullet">
/// <item><term>CodeDom</term><description>Fully supports. Generates debugging symbols (script can be debugged) and defines <c>DEBUG</c> and <c>TRACE</c> conditional symbols</description> </item>
/// <item><term>Mono</term><description>Partially supports. Defines <c>DEBUG</c> and <c>TRACE</c> conditional symbols</description> </item>
/// <item><term>Roslyn</term><description>Doesn't supports at all.</description> </item>
/// </list>
/// </para>
/// </summary>
/// <value><c>true</c> if 'debug build'; otherwise, <c>false</c>.</value>
bool? DebugBuild { get; set; }
/// <summary>
/// Gets or sets the flag indicating if the script code should be analyzed and the assemblies
/// that the script depend on (via '//css_...' and 'using ...' directives) should be referenced.
/// </summary>
/// <value></value>
bool DisableReferencingFromCode { get; set; }
/// <summary>
/// Evaluates (compiles) C# code (script). The C# code is a typical C# code containing a single or multiple class definition(s).
/// </summary>
/// <example>
///<code>
/// Assembly asm = CSScript.Evaluator
/// .CompileCode(@"using System;
/// public class Script
/// {
/// public int Sum(int a, int b)
/// {
/// return a+b;
/// }
/// }");
///
/// dynamic script = asm.CreateObject("*");
/// var result = script.Sum(7, 3);
/// </code>
/// </example>
/// <param name="scriptText">The C# script text.</param>
/// <returns>The compiled assembly.</returns>
Assembly CompileCode(string scriptText);
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>) and evaluates it.
/// <para>
/// This method is a logical equivalent of <see cref="CSScriptLibrary.IEvaluator.CompileCode"/> but is allows you to define
/// your script class by specifying class method instead of whole class declaration.</para>
/// </summary>
/// <example>
///<code>
/// dynamic script = CSScript.Evaluator
/// .CompileCode(@"int Sum(int a, int b)
/// {
/// return a+b;
/// }")
/// .CreateObject("*");
///
/// var result = script.Sum(7, 3);
/// </code>
/// </example>
/// <param name="code">The C# code.</param>
/// <returns>The compiled assembly.</returns>
Assembly CompileMethod(string code);
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads the class to the current AppDomain.
/// <para>Returns non-typed <see cref="CSScriptLibrary.MethodDelegate"/> for class-less style of invoking.</para>
/// </summary>
/// <example>
/// <code>
/// var log = CSScript.Evaluator
/// .CreateDelegate(@"void Log(string message)
/// {
/// Console.WriteLine(message);
/// }");
///
/// log("Test message");
/// </code>
/// </example>
/// <param name="code">The C# code.</param>
/// <returns> The instance of a 'duck typed' <see cref="CSScriptLibrary.MethodDelegate"/></returns>
MethodDelegate CreateDelegate(string code);
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads the class to the current AppDomain.
/// <para>Returns typed <see cref="CSScriptLibrary.MethodDelegate{T}"/> for class-less style of invoking.</para>
/// </summary>
/// <typeparam name="T">The delegate return type.</typeparam>
/// <example>
/// <code>
/// var product = CSScript.Evaluator
/// .CreateDelegate<int>(@"int Product(int a, int b)
/// {
/// return a * b;
/// }");
///
/// int result = product(3, 2);
/// </code>
/// </example>
/// <param name="code">The C# code.</param>
/// <returns> The instance of a typed <see cref="CSScriptLibrary.MethodDelegate{T}"/></returns>
MethodDelegate<T> CreateDelegate<T>(string code);
/// <summary>
/// Analyses the script code and returns set of locations for the assemblies referenced from the code with CS-Script directives (//css_ref).
/// </summary>
/// <param name="code">The script code.</param>
/// <param name="searchDirs">The assembly search/probing directories.</param>
/// <returns>Array of the referenced assemblies</returns>
string[] GetReferencedAssemblies(string code, params string[] searchDirs);
/// <summary>
/// Returns set of referenced assemblies.
/// <para>
/// Notre: the set of assemblies is cleared on Reset.
/// </para>
/// </summary>
/// <returns></returns>
Assembly[] GetReferencedAssemblies();
/// <summary>
/// Evaluates and loads C# code to the current AppDomain. Returns instance of the first class defined in the code.
/// </summary>
/// <example>The following is the simple example of the LoadCode usage:
///<code>
/// dynamic script = CSScript.Evaluator
/// .LoadCode(@"using System;
/// public class Script
/// {
/// public int Sum(int a, int b)
/// {
/// return a+b;
/// }
/// }");
/// int result = script.Sum(1, 2);
/// </code>
/// </example>
/// <param name="scriptText">The C# script text.</param>
/// <param name="args">The non default constructor arguments.</param>
/// <returns>Instance of the class defined in the script.</returns>
object LoadCode(string scriptText, params object[] args);
/// <summary>
/// Evaluates and loads C# code to the current AppDomain. Returns instance of the first class defined in the code.
/// After initializing the class instance it is aligned to the interface specified by the parameter <c>T</c>.
/// <para><c>Note:</c> Because the interface alignment is a duck typing implementation the script class doesn't have to
/// inherit from <c>T</c>.</para>
/// </summary>
/// <example>The following is the simple example of the interface alignment:
///<code>
/// public interface ICalc
/// {
/// int Sum(int a, int b);
/// }
/// ....
/// ICalc calc = CSScript.Evaluator
/// .LoadCode<ICalc>(@"using System;
/// public class Script
/// {
/// public int Sum(int a, int b)
/// {
/// return a+b;
/// }
/// }");
/// int result = calc.Sum(1, 2);
/// </code>
/// </example>
/// <typeparam name="T">The type of the interface type the script class instance should be aligned to.</typeparam>
/// <param name="scriptText">The C# script text.</param>
/// <param name="args">The non default type <c>T</c> constructor arguments.</param>
/// <returns>Aligned to the <c>T</c> interface instance of the class defined in the script.</returns>
T LoadCode<T>(string scriptText, params object[] args) where T : class;
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads
/// the class to the current AppDomain.
/// <para>Returns instance of <c>T</c> delegate for the first method in the auto-generated class.</para>
/// </summary>
/// <example>
/// <code>
/// var Product = CSScript.Evaluator
/// .LoadDelegate<Func<int, int, int>>(
/// @"int Product(int a, int b)
/// {
/// return a * b;
/// }");
///
/// int result = Product(3, 2);
/// </code>
/// </example>
/// <param name="code">The C# code.</param>
/// <returns>Instance of <c>T</c> delegate.</returns>
T LoadDelegate<T>(string code) where T : class;
/// <summary>
/// Evaluates and loads C# code from the specified file to the current AppDomain. Returns instance of the first
/// class defined in the script file.
/// </summary>
/// <example>The following is the simple example of the interface alignment:
///<code>
/// dynamic script = CSScript.Evaluator
/// .LoadFile("calc.cs");
///
/// int result = script.Sum(1, 2);
/// </code>
/// </example>/// <param name="scriptFile">The C# script file.</param>
/// <returns>Instance of the class defined in the script file.</returns>
object LoadFile(string scriptFile);
/// <summary>
/// Evaluates and loads C# code from the specified file to the current AppDomain. Returns instance of the first
/// class defined in the script file.
/// After initializing the class instance it is aligned to the interface specified by the parameter <c>T</c>.
/// <para><c>Note:</c> the script class does not have to inherit from the <c>T</c> parameter as the proxy type
/// will be generated anyway.</para>
/// </summary>
/// <example>The following is the simple example of the interface alignment:
///<code>
/// public interface ICalc
/// {
/// int Sum(int a, int b);
/// }
/// ....
/// ICalc calc = CSScript.Evaluator
/// .LoadFile<ICalc>("calc.cs");
///
/// int result = calc.Sum(1, 2);
/// </code>
/// </example>
/// <typeparam name="T">The type of the interface type the script class instance should be aligned to.</typeparam>
/// <param name="scriptFile">The C# script text.</param>
/// <returns>Aligned to the <c>T</c> interface instance of the class defined in the script file.</returns>
T LoadFile<T>(string scriptFile) where T : class;
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads
/// the class to the current AppDomain.
/// </summary>
/// <example>The following is the simple example of the LoadMethod usage:
/// <code>
/// dynamic script = CSScript.Evaluator
/// .LoadMethod(@"int Product(int a, int b)
/// {
/// return a * b;
/// }");
///
/// int result = script.Product(3, 2);
/// </code>
/// </example>
/// <param name="code">The C# script text.</param>
/// <returns>Instance of the first class defined in the script.</returns>
object LoadMethod(string code);
/// <summary>
/// Wraps C# code fragment into auto-generated class (type name <c>DynamicClass</c>), evaluates it and loads
/// the class to the current AppDomain.
/// <para>
/// After initializing the class instance it is aligned to the interface specified by the parameter <c>T</c>.
/// </para>
/// </summary>
/// <example>The following is the simple example of the interface alignment:
/// <code>
/// public interface ICalc
/// {
/// int Sum(int a, int b);
/// int Div(int a, int b);
/// }
/// ....
/// ICalc script = CSScript.Evaluator
/// .LoadMethod<ICalc>(@"public int Sum(int a, int b)
/// {
/// return a + b;
/// }
/// public int Div(int a, int b)
/// {
/// return a/b;
/// }");
/// int result = script.Div(15, 3);
/// </code>
/// </example>
/// <typeparam name="T">The type of the interface type the script class instance should be aligned to.</typeparam>
/// <param name="code">The C# script text.</param>
/// <returns>Aligned to the <c>T</c> interface instance of the auto-generated class defined in the script.</returns>
T LoadMethod<T>(string code) where T : class;
/// <summary>
/// References the assemblies from the script code.
/// <para>The method analyses and tries to resolve CS-Script directives (e.g. '//css_ref') and 'used' namespaces based on the
/// optional search directories.</para>
/// </summary>
/// <param name="code">The script code.</param>
/// <param name="searchDirs">The assembly search/probing directories.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssembliesFromCode(string code, params string[] searchDirs);
/// <summary>
/// References the given assembly by the assembly path.
/// <para>It is safe to call this method multiple times for the same assembly. If the assembly already referenced it will not
/// be referenced again.</para>
/// </summary>
/// <param name="assembly">The path to the assembly file.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssembly(string assembly);
/// <summary>
/// References the given assembly.
/// <para>It is safe to call this method multiple times
/// for the same assembly. If the assembly already referenced it will not
/// be referenced again.
/// </para>
/// </summary>
/// <param name="assembly">The assembly instance.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssembly(Assembly assembly);
/// <summary>
/// References the name of the assembly by its partial name.
/// <para>Note that the referenced assembly will be loaded into the host AppDomain in order to resolve assembly partial name.</para>
/// <para>It is an equivalent of <c>Evaluator.ReferenceAssembly(Assembly.LoadWithPartialName(assemblyPartialName))</c></para>
/// </summary>
/// <param name="assemblyPartialName">Partial name of the assembly.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssemblyByName(string assemblyPartialName);
/// <summary>
/// References the assembly by the given namespace it implements.
/// </summary>
/// <param name="namespace">The namespace.</param>
/// <param name="resolved">Set to <c>true</c> if the namespace was successfully resolved (found) and
/// the reference was added; otherwise, <c>false</c>.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator TryReferenceAssemblyByNamespace(string @namespace, out bool resolved);
/// <summary>
/// References the assembly by the given namespace it implements.
/// <para>Adds assembly reference if the namespace was successfully resolved (found) and, otherwise does nothing</para>
/// </summary>
/// <param name="namespace">The namespace.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssemblyByNamespace(string @namespace);
/// <summary>
/// References the assembly by the object, which belongs to this assembly.
/// <para>It is safe to call this method multiple times
/// for the same assembly. If the assembly already referenced it will not
/// be referenced again.
/// </para>
/// </summary>
/// <param name="obj">The object, which belongs to the assembly to be referenced.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssemblyOf(object obj);
/// <summary>
/// References the assembly by the object, which belongs to this assembly.
/// <para>It is safe to call this method multiple times
/// for the same assembly. If the assembly already referenced it will not
/// be referenced again.
/// </para>
/// </summary>
/// <typeparam name="T">The type which is implemented in the assembly to be referenced.</typeparam>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceAssemblyOf<T>();
/// <summary>
/// References the assemblies the are already loaded into the current <c>AppDomain</c>.
/// </summary>
/// <param name="assemblies">The type of assemblies to be referenced.</param>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
#if net35
IEvaluator ReferenceDomainAssemblies(DomainAssemblies assemblies);
#else
IEvaluator ReferenceDomainAssemblies(DomainAssemblies assemblies = DomainAssemblies.AllStaticNonGAC);
#endif
#if net35
/// <summary>
/// References the assemblies the are already loaded into the current <c>AppDomain</c>.
/// <para>This method is an equivalent of <see cref="CSScriptLibrary.IEvaluator.ReferenceDomainAssemblies"/>
/// with the hard codded <c>DomainAssemblies.AllStaticNonGAC</c> input parameter.
/// </para>
/// </summary>
/// <returns>The instance of the <see cref="CSScriptLibrary.IEvaluator"/> to allow fluent interface.</returns>
IEvaluator ReferenceDomainAssemblies();
#endif
/// <summary>
/// Resets Evaluator.
/// <para>
/// Resetting means clearing all referenced assemblies, recreating evaluation infrastructure (e.g. compiler setting)
/// and reconnection to or recreation of the underlying compiling services.
/// </para>
/// <para>Optionally the default current AppDomain assemblies can be referenced automatically with
/// <paramref name="referenceDomainAssemblies"/>.</para>
/// </summary>
/// <param name="referenceDomainAssemblies">if set to <c>true</c> the default assemblies of the current AppDomain
/// will be referenced (see <see cref="ReferenceDomainAssemblies(DomainAssemblies)"/> method).
/// </param>
/// <returns>The freshly initialized instance of the <see cref="CSScriptLibrary.IEvaluator"/>.</returns>
IEvaluator Reset(bool referenceDomainAssemblies = true);
/// <summary>
/// Clones the parent <see cref="CSScriptLibrary.IEvaluator"/>.
/// <para>
/// This method returns a freshly initialized copy of the <see cref="CSScriptLibrary.IEvaluator"/>.
/// The cloning 'depth' can be controlled by the <paramref name="copyRefAssemblies"/>.
/// </para>
/// <para>
/// This method is a convenient technique when multiple <see cref="CSScriptLibrary.IEvaluator"/> instances
/// are required (e.g. for concurrent script evaluation).
/// </para>
/// </summary>
/// <param name="copyRefAssemblies">if set to <c>true</c> all referenced assemblies from the parent <see cref="CSScriptLibrary.IEvaluator"/>
/// will be referenced in the cloned copy.</param>
/// <returns>The freshly initialized instance of the <see cref="CSScriptLibrary.IEvaluator"/>.</returns>
/// <example>
///<code>
/// var eval1 = CSScript.Evaluator.Clone();
/// var eval2 = CSScript.Evaluator.Clone();
///
/// var sub = eval1.LoadDelegate<Func<int, int, int>>(
/// @"int Sub(int a, int b) {
/// return a - b;
/// }");
///
/// var sum = eval2.LoadDelegate<Func<int, int, int>>(
/// @"int Sub(int a, int b) {
/// return a + b;
/// }");
///
/// var result = sum(7, sub(4,2));
/// </code>
/// </example>
IEvaluator Clone(bool copyRefAssemblies = true);
}
样例展示
源码链接: https://pan.baidu.com/s/1hGTA_ma2C3PAvdtaxnSg_g
提取码: v8jn