使用用户定义的名称创建一个新方法。反射 C#

发布于 2024-10-20 18:58:04 字数 418 浏览 0 评论 0原文

我想在运行时创建一个方法。我希望用户输入一个字符串，方法的名称将为 DynamicallyDefonedMethod_#### （以用户字符串结尾）。

我希望将相同的字符串嵌入到方法的主体中：它将调用 StaticallyDefinedMethod (####, a, b)

类似：

public MyClass1 DynamicallyDefonedMethod_#### (int a, int b)
{
return  StaticallyDefinedMethod (####, a, b)
}

这个想法是用户将在运行时创建一个新方法并随后调用它（使用 a, b 参数）。

我用 google 搜索了 C# 反射，但没有找到简单的方法。有人知道如何简单地做到这一点吗？

问候，

原文

I want to create a method on RunTime.
I want the user to enter a string and the method's name will be DynamicallyDefonedMethod_#### (ends with the user string).

i want the same string to be embeded in the method's body:
It will call StaticallyDefinedMethod (####, a, b)

Something like:

public MyClass1 DynamicallyDefonedMethod_#### (int a, int b)
{
return  StaticallyDefinedMethod (####, a, b)
}

The idea is that the user will create a new method on runtime and invoke it afterward (with a, b parameters).

i googled C# reflection but found no easy way of doing that.
Does someone knows how to do it simply ?

Regards,

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

始终不够 2024-10-27 18:58:04

正如已经指出的（评论），更简单的方法就是使用 lambda：

Func<int,int,Whatever> func = (a,b) => StaticallyDefinedMethod(s,a,b);

但您也可以为此使用元编程（如下）。在这里你可以控制方法名称，并且具有更大的灵活性（不是你在这里需要它）。但请注意，这并没有真正向类型添加方法 - 动态方法是独立且断开连接的。您无法真正在运行时向类型添加成员。

using System;
using System.Reflection.Emit;
public class MyClass1  {
    static void Main()
    {
        var foo = CreateMethod("Foo");
        string s = foo(123, 456);
        Console.WriteLine(s);
    }
    static Func<int,int,string> CreateMethod(string s)
    {
        var method = new DynamicMethod("DynamicallyDefonedMethod_" + s,
            typeof(string),
            new Type[] { typeof(int), typeof(int) });
        var il = method.GetILGenerator();
        il.Emit(OpCodes.Ldstr, s);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.EmitCall(OpCodes.Call, typeof(MyClass1).GetMethod("StaticallyDefinedMethod"), null);
        il.Emit(OpCodes.Ret);
        return (Func<int,int,string>)method.CreateDelegate(typeof(Func<int, int, string>));
    }
    public static string StaticallyDefinedMethod(string s, int a, int b)
    {
        return s + "; " + a + "/" + b;
    }
}

这里的最后一个想法可能是使用dynamic，但是使用dynamic在运行时选择名称非常困难。

As already noted (comments), the easier approach is just to use a lambda:

Func<int,int,Whatever> func = (a,b) => StaticallyDefinedMethod(s,a,b);

but you can also use meta-programming for this (below). Here you control the method name, and have more flexibility (not that you need it here). But note that this doesn't really add a method to the type - the dynamic method is separate and disconnected. You can't really add members to types at runtime.

using System;
using System.Reflection.Emit;
public class MyClass1  {
    static void Main()
    {
        var foo = CreateMethod("Foo");
        string s = foo(123, 456);
        Console.WriteLine(s);
    }
    static Func<int,int,string> CreateMethod(string s)
    {
        var method = new DynamicMethod("DynamicallyDefonedMethod_" + s,
            typeof(string),
            new Type[] { typeof(int), typeof(int) });
        var il = method.GetILGenerator();
        il.Emit(OpCodes.Ldstr, s);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.EmitCall(OpCodes.Call, typeof(MyClass1).GetMethod("StaticallyDefinedMethod"), null);
        il.Emit(OpCodes.Ret);
        return (Func<int,int,string>)method.CreateDelegate(typeof(Func<int, int, string>));
    }
    public static string StaticallyDefinedMethod(string s, int a, int b)
    {
        return s + "; " + a + "/" + b;
    }
}

A final thought here might be to use dynamic, but it is very hard to choose names at runtime with dynamic.

回复收藏 0 原文

~没有更多了~