C# 一直被归类为静态类型语言，类型检查发生在编译阶段，而 Python、Ruby 这类动态语言则把类型检查推迟到运行时。要在同一个进程里同时使用这两种范式，传统的做法是通过进程间通信，比如启动一个 Python 解释器再通过管道传数据。这种方式不仅延迟高，而且对象序列化和反序列化会带来大量额外开销。DLR（Dynamic Language Runtime，动态语言运行时）的出现改变了这一局面。它构建在 CLR 之上，让动态语言和静态语言共享同一套类型系统和执行环境。IronPython 和 IronRuby 正是 DLR 上最著名的两个实现，它们允许开发者在 C# 代码中直接创建脚本引擎、执行 Python 或 Ruby 代码，并像操作本地对象一样操作脚本返回的结果。下面这张示意图展示了 DLR 在整个 .NET 运行时中的位置以及它与 IronPython、IronRuby 之间的关系。
DLR 的核心并不是简单地把脚本代码翻译成 C#，而是提供了一套动态调用的基础设施。当你在 C# 中调用一个动态对象的方法时，DLR 会创建一个 CallSite（调用点）对象，这个对象内部包含一个动态绑定的缓存。第一次调用时，DLR 会通过绑定器去解析真正的目标方法，然后把解析结果缓存起来。后续相同签名的调用会直接命中缓存，避免重复的查找过程。这种机制使得动态调用在大部分情况下可以接近静态调用的性能。接下来我们会深入分析 DLR 的绑定过程，并展示如何利用 IronPython 和 IronRuby 在 C# 项目里直接运行 Python 和 Ruby 脚本。
一、DLR 的核心机制与动态绑定
DLR 是 .NET Framework 4.0 引入的一个重要组件，它扩展了 CLR 的能力，让动态语言能够运行在 .NET 平台上。与 CLR 专注于静态类型不同，DLR 增加了一组服务，包括表达式树、动态调用点缓存、动态对象互操作等。其中最关键的概念就是 CallSite。可以把 CallSite 理解为一个动态方法调用的“槽位”，每个 CallSite 都与一个委托关联，这个委托负责执行实际的调用。当 C# 编译器遇到 dynamic 关键字时，就会生成一个 CallSite 并初始化一个绑定器。绑定器负责检查操作数的运行时类型，并决定调用哪个具体的方法或属性。
绑定过程由 DLR 的 DynamicMetaObject 机制完成。每个动态对象都有一个对应的元对象，它描述了该对象支持的操作，例如获取成员、设置成员、调用方法等。绑定器会向元对象请求一个表达式树，这个表达式树最终被编译成一个可执行的委托。由于编译后的委托会被缓存到 CallSite 中，因此第二次执行相同类型的调用时，几乎不会产生额外的绑定开销。这种设计使得 C# 中的动态调用既有灵活性，又能保持良好的性能。相比之下，直接使用反射进行调用通常要慢一个数量级，因为反射每次都要查询元数据。
DLR 还提供了 DynamicObject 基类，开发者可以继承它来实现自定义的动态行为。例如，可以创建一个动态对象，当访问不存在的属性时返回一个默认值，或者把属性名映射到字典的键。不过，在与 IronPython 和 IronRuby 交互的场景中，我们通常不需要自己实现 DynamicObject，因为脚本引擎返回的对象本身就是 DLR 兼容的。只需要理解动态绑定缓存机制，就能在后续的性能调优中做出正确的决策。
二、通过 IronPython 在 C# 中执行 Python 代码
要在 C# 项目中使用 IronPython，第一步是安装 NuGet 包。在 Visual Studio 的包管理控制台执行 Install-Package IronPython 即可。IronPython 3.4 目前支持 Python 3.x 语法，并且完全运行在 .NET 上。安装完成后，就可以通过 ScriptEngine、ScriptScope 和 ScriptSource 这三个核心类来执行 Python 代码。ScriptEngine 代表一个 Python 解释器实例，ScriptScope 相当于一个命名空间，用来存放变量和函数，ScriptSource 则封装了一段待执行的脚本。
下面的代码演示了如何创建一个 Python 引擎，执行一段简单的 Python 脚本，并从 C# 中获取返回值。
using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
public static void RunPythonBasic()
{
// 创建 Python 引擎
var engine = Python.CreateEngine();
// 创建一个作用域
var scope = engine.CreateScope();
// 执行 Python 代码
string script = @"
def greet(name):
return 'Hello, ' + name
result = greet('DLR')
";
engine.Execute(script, scope);
// 从作用域中获取变量
string result = scope.GetVariable<string>("result");
Console.WriteLine(result); // 输出 Hello, DLR
}
如果希望调用 Python 中定义的函数，并把 C# 对象作为参数传递进去，可以通过 ScriptScope.GetVariable 获取函数对象，然后使用 Func<object, object> 委托进行调用。IronPython 会自动完成 CLR 类型与 Python 类型之间的转换，例如 C# 的 string 会变成 Python 的 str，int 会变成 Python 的 int。但是需要注意，像 DateTime 这样的复杂对象不会自动转换成 Python 的 datetime，而是保持为 CLR 对象。如果 Python 脚本中使用了需要原生类型的库，就可能会出现类型不匹配的问题。
处理复杂对象时，可以借助 IronPython 提供的 Operations 类。例如，要调用一个 Python 函数并传入一个 C# 列表，可以先创建一个 IronPython.Runtime.List 对象，或者使用 engine.Operations.CreateList 方法。另一种更灵活的做法是把 C# 对象包装成动态对象，让 Python 代码通过属性访问来交互。一般来说，简单的标量类型和字符串传递是最稳妥的，复杂的对象建议先序列化为 JSON 字符串，再在 Python 端反序列化，这样可以避免很多隐式转换带来的问题。
using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
using System;
public static void CallPythonFunctionWithArguments()
{
var engine = Python.CreateEngine();
var scope = engine.CreateScope();
engine.Execute("def add(a, b):\n return a + b", scope);
var addFunc = scope.GetVariable("add");
// 通过 Operations 调用 Python 函数
var operations = engine.Operations;
object result = operations.Invoke(addFunc, 10, 20);
Console.WriteLine(result); // 输出 30
}
IronPython 的一个显著优势是可以直接访问 .NET 类库。在 Python 脚本中，可以 import clr 然后加载任意 .NET 程序集，使用其中的类。例如，可以在 Python 脚本中创建 System.Text.StringBuilder 对象，或调用 System.IO.File.ReadAllText。这种双向互操作能力让 IronPython 成为非常灵活的嵌入脚本方案。但要注意，IronPython 默认使用 Unicode 字符串，而 .NET 的 byte[] 类型在传递时需要显式转换，否则可能出现编码错误。
三、通过 IronRuby 在 C# 中执行 Ruby 代码
IronRuby 是 Ruby 语言在 DLR 上的实现，它允许 Ruby 代码运行在 .NET 运行时之上。不过需要说明的是，IronRuby 项目近年来已经不再积极维护，最新的稳定版本停留在 1.1.3，对应的 Ruby 版本是 1.9.2。如果你的项目必须使用最新版的 Ruby 语法，IronRuby 可能不适用。但对于一些遗留系统或者简单的脚本嵌入需求，IronRuby 依然可以发挥作用。安装方式同样是通过 NuGet，包名为 IronRuby。
使用 IronRuby 的方式与 IronPython 非常相似。核心类同样是 ScriptEngine、ScriptScope 和 ScriptSource，只是创建引擎时使用 Ruby.CreateEngine()。下面的代码展示了在 C# 中执行一段 Ruby 脚本并获取返回值。
using IronRuby;
using Microsoft.Scripting.Hosting;
public static void RunRubyBasic()
{
var engine = Ruby.CreateEngine();
var scope = engine.CreateScope();
string script = @"
def multiply(a, b)
return a * b
end
result = multiply(6, 7)
";
engine.Execute(script, scope);
int result = scope.GetVariable<int>("result");
Console.WriteLine(result); // 输出 42
}
与 IronPython 类似，IronRuby 也支持在 Ruby 代码中访问 .NET 类型。在 Ruby 脚本里可以使用 require 'mscorlib' 或者直接使用 .NET 类，比如 System::Console.WriteLine("hello")。不过 IronRuby 的类型转换规则和 IronPython 略有不同。例如，Ruby 的整数在 DLR 中对应的是 BigInteger，而 C# 的 int 是 Int32，直接赋值时需要显式转换。调用 Ruby 函数时，推荐使用 engine.Operations.Invoke 方法，DLR 会自动处理大部分类型映射。
另一个值得注意的点是 IronRuby 的异常处理。当 Ruby 代码抛出异常时，它在 .NET 侧表现为 RubyException 类型，而不是标准的 System.Exception。因此，在 C# 中捕获异常时需要特别处理，否则可能得到的信息不够直观。可以通过 RubyException.GetRubyException 方法获取原始的 Ruby 异常对象。这一点在实际项目中很容易被忽视，导致错误排查困难。
四、跨语言交互的注意事项与性能优化
跨语言调用最大的性能消耗在于动态绑定的首次解析。如果在一段循环里反复调用同一个动态方法，DLR 的缓存机制可以保证只有第一次调用会触发绑定，后续调用直接走编译后的委托。但是，如果调用时的参数类型频繁变化，就会导致缓存频繁失效，性能会急剧下降。因此，尽量保持参数类型稳定是优化动态调用的基本原则。此外，避免在性能敏感的代码路径中使用 dynamic 关键字，改用强类型的包装类来封装脚本调用，可以把动态调用限制在边界处。
关于 GIL（全局解释器锁）的问题，IronPython 和 IronRuby 都没有 GIL，因为它们运行在 .NET 线程模型上。这意味着多个线程可以同时执行 Python 或 Ruby 代码，而不会像 CPython 那样受到 GIL 的限制。但这也带来了新的挑战：脚本引擎本身不是线程安全的。如果多个线程需要同时执行脚本，应该为每个线程创建独立的 ScriptEngine 实例，或者使用锁来同步对共享引擎的访问。内存管理方面，DLR 对象由 CLR 垃圾回收器统一管理，不会出现脚本对象泄漏的问题，但要注意跨语言循环引用可能导致对象无法被及时回收。
异常传递也是一个容易被忽略的细节。当在 C# 中调用 Python 函数时，如果 Python 代码抛出了异常，DLR 会把它包装成 Microsoft.Scripting.Runtime.Exceptions 命名空间下的异常类型。为了更好地诊断问题，建议在 C# 代码中捕获 Exception 后，检查 exception.Data 集合或者调用 engine.GetService<ExceptionOperations>().FormatException 来获取带堆栈信息的详细描述。另外，字符编码问题也需要注意。IronPython 默认使用 UTF-8 处理字符串，但如果你在 Windows 上使用非 Unicode 代码页的文件，加载脚本时可能会乱码。推荐始终使用 UTF-8 编码保存脚本文件，并在读取时显式指定编码。
最后，关于应用场景的选择。DLR 交互非常适合以下场景：需要在 .NET 应用中提供用户自定义脚本能力、需要复用大量已有的 Python 或 Ruby 库、或者需要在同一进程内进行快速原型验证。对于高并发、低延迟的核心业务逻辑，建议还是使用原生 C# 实现，把动态脚本调用限制在边缘模块。合理利用 DLR 的缓存机制和类型转换规则，可以在灵活性和性能之间取得很好的平衡。