C# 在运行时动态创建函数

Creating a function dynamically at run-time

提问by Leahn Novash

It probably isn't even possible to do this, but I will ask anyway. Is it possible to create a function that receives a string and then uses it as a right side argument for the goes to operator (=>) used in lambda?

甚至可能无法做到这一点，但无论如何我都会问。是否可以创建一个函数来接收字符串，然后将其用作 lambda 中使用的 go to 运算符 (=>) 的右侧参数？

Actually, what I want to do is to be able to redefine an specific method of a specific class during runtime. I want to be write down a function with the program running and attaching it to a delegate. Is it possible?

其实我想做的是能够在运行时重新定义特定类的特定方法。我想在程序运行时写下一个函数并将其附加到委托。是否可以？

采纳答案by TcKs

The easiest way to do it is probably DLINQ as TcKs suggested.

最简单的方法可能是 TcKs 建议的 DLINQ。

The fastest (I believe, in 3.5) is to create a DynamicMethod. Its also the scariest method as well. You're essentially building a method using IL, which has about the same feel as writing code in machine language.

最快的（我相信，在 3.5 中）是创建一个DynamicMethod。这也是最可怕的方法。您实际上是在使用 IL 构建一个方法，这与用机器语言编写代码的感觉大致相同。

I needed to do this to dynamically attach event handlers in some thing or another (well, I didn't need to do it, I just wanted to make unit testing events easier). It seemed a bit daunting at the time because I don't know crap about IL, but I figured out a simple way to accomplish this.

我需要这样做以动态地附加事件处理程序（好吧，我不需要这样做，我只是想让单元测试事件更容易）。当时这似乎有点令人生畏，因为我对 IL 一无所知，但我想出了一个简单的方法来实现这一点。

What you do is create a method that does exactly what you want. The more compact the better. I'd provide an example if I could figure out exactly what you're trying to do. You write this method in a class within a DLL project and compile it in release mode. Then you open the DLL in Reflector and disassemble your method. Reflector gives you the option of what language you wish to disassemble to--select IL. You now have the exact calls you need to add to your dynamic method. Just follow the example on MSDN, switching out the example's IL for your reflected methods' code.

您所做的是创建一个完全符合您要求的方法。越紧凑越好。如果我能确切地弄清楚你想要做什么，我会提供一个例子。您在 DLL 项目中的类中编写此方法并在发布模式下编译它。然后在 Reflector 中打开 DLL 并反汇编您的方法。Reflector 为您提供了您希望反汇编为哪种语言的选项——选择 IL。您现在拥有了需要添加到动态方法中的确切调用。只需按照 MSDN 上的示例，为反射方法的代码切换示例的 IL。

Dynamic methods, once constructed, invoke at about the same speed as compiled methods (saw a test where dynamic methods could be called in ~20ms where reflection took over 200ms).

动态方法一旦被构造，调用速度与编译方法大致相同（看到一个测试，动态方法可以在大约 20 毫秒内被调用，而反射花费超过 200 毫秒）。

回答by Jon Skeet

Your question is pretty unclear, but you can certainly use expression trees to create delegates dynamically at execution time. (There are other ways of doing it such as CodeDOM, but expression trees are handier ifthey do all you need. There are significant restrictions to what you can do, however.)

您的问题很不清楚，但您当然可以使用表达式树在执行时动态创建委托。（还有其他方法，例如 CodeDOM，但是如果表达式树可以满足您的所有需要​​，它们会更方便。但是，您可以执行的操作有很大的限制。）

It's often easier to use a lambda expression with some captured variables though.

不过，将 lambda 表达式与一些捕获的变量一起使用通常更容易。

For example, to create a function which will add the specified amount to any integer, you could write:

例如，要创建一个将指定数量添加到任何整数的函数，您可以编写：

static Func<int, int> CreateAdder(int amountToAdd)
{
    return x => x + amountToAdd;
}

...
var adder = CreateAdder(10);
Console.WriteLine(adder(5)); // Prints 15

If this doesn't help, please clarify your question.

如果这没有帮助，请澄清您的问题。

回答by TcKs

You have several ways how to do it:

您有几种方法可以做到：

• dynamically create lambda expression (look at Dynamic LINQ: Part 1)
• dynamically create CodeDom model and compile it at run-time (look at CodeDom.Compiler namespace
• dynamically create C#/VB.NET source code and compile it at run-time (look at CSharpCodeProviderand VBCodeProviderclasses )
• dynamically create object model, which can do same things like the method (look at Strategy Design Pattern

• 动态创建 lambda 表达式（查看动态 LINQ：第 1 部分）
• 动态创建 CodeDom 模型并在运行时编译它（查看CodeDom.Compiler 命名空间
• 动态创建 C#/VB.NET 源代码并在运行时编译它（查看CSharpCodeProvider和VBCodeProvider类）
• 动态创建对象模型，它可以做与方法相同的事情（查看策略设计模式

回答by Jake

Not that I am recommending this over the other betteroptions, but there is a 7^thmethod and thats to use AssemblyBuilder,ModuleBuilder,TypeBuilder, and MethodBuilderin the System.Reflection.Emitnamespace to create a dynamic assembly. This is the same similar voodoo as using DynamicMethod.

这并不是说我建议这个比其他更好的选择，但有7^个方法和多数民众来使用AssemblyBuilder，ModuleBuilder，TypeBuilder，和MethodBuilder在System.Reflection.Emit命名空间组件创建动态。这与使用DynamicMethod.

For example you could use these to, at runtime, create a proxy class for a type and override virtual methods on that type.

例如，您可以在运行时使用它们为类型创建代理类并覆盖该类型的虚拟方法。

To get you started here is some code...

为了让你开始这里是一些代码......

using System;
using System.Reflection;
using System.Reflection.Emit;

var myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
        new AssemblyName("Test"), AssemblyBuilderAccess.RunAndSave);
var myModule = myAssembly.DefineDynamicModule("Test.dll");
var myType = myModule.DefineType("ProxyType", TypeAttributes.Public | TypeAttributes.Class,
                        typeof(TypeToSeverelyModifyInAnUglyWayButItsNecessary));
var myMethod = myType.DefineMethod("MethodNameToOverride", 
                        MethodAttributes.HideBySig | MethodAttributes.Public,
                        typeof(void),Type.EmptyTypes);
var myIlGenerator = myMethod.GetILGenerator();
myIlGenerator.Emit(OpCodes.Ret);
var type = myType.CreateType();

回答by Jacob

If you declare the method as virtual, you might be able to use Castle's DynamicProxyto substitute a dynamically-generated (with one of the other answer's methods) implementation at runtime:

如果将该方法声明为虚拟方法，则可以使用 Castle 的DynamicProxy在运行时替换动态生成的（使用其他答案的方法之一）实现：

Castle DynamicProxy is a library for generating lightweight .NET proxies on the fly at runtime. Proxy objects allow calls to members of an object to be intercepted without modifying the code of the class. Both classes and interfaces can be proxied, however only virtual members can be intercepted.

Castle DynamicProxy 是一个用于在运行时动态生成轻量级 .NET 代理的库。代理对象允许在不修改类代码的情况下拦截对对象成员的调用。类和接口都可以被代理，但是只能拦截虚拟成员。

回答by Chris Simpson

The second paragraph in your question suggests that really what you might be after is straightforward IOC(Inversion of Control)

您问题中的第二段表明您可能真正追求的是简单的IOC（控制反转）

Instead of declaring an instance of your class, you declare an instance of an interface and based on whatever condition you choose, you use the particular overriding class with the correct method in it. Hope that makes sense.

您不是声明类的实例，而是声明接口的实例，并根据您选择的任何条件，使用具有正确方法的特定覆盖类。希望这是有道理的。

回答by clemahieu

You should check to see if your problem can be solved with simple polymorphism first. Unless you're defining abstract interoperability to another language or editing the compiler, trying to change a method at runtime is probably the wrong solution to the problem.

您应该首先检查您的问题是否可以通过简单的多态性解决。除非您正在定义与另一种语言的抽象互操作性或编辑编译器，否则尝试在运行时更改方法可能是解决问题的错误方法。