9

我已经阅读了几篇关于编写和编译动态 C# 代码的文章。例如，这篇文章。我知道它可以通过多种方式完成。

但是，调用代码调用程序很慢。我做了一个简单的基准测试，它比调用本机方法慢了大约 500 倍。

我想要做的是相当于加载一个 DLL 并直接（“本机”）调用它的方法之一，这将带来我想要的速度优势。

解决这个问题的最简单方法是什么？将动态代码编译成dll然后加载？它可以在内存中完成吗？

编辑

我不在乎编译时间。只有执行。

编辑 2、3

这是我编写的基准代码：

    public static int Execute(int i) { return i * 2; }

    private void button30_Click(object sender, EventArgs e)
    {
        CSharpCodeProvider foo = new CSharpCodeProvider();

        var res = foo.CompileAssemblyFromSource(
            new System.CodeDom.Compiler.CompilerParameters()
            {
                GenerateInMemory = true,
                CompilerOptions = @"/optimize",                    
            },
            @"public class FooClass { public static int Execute(int i) { return i * 2; }}"
        );

        var type = res.CompiledAssembly.GetType("FooClass");
        var obj = Activator.CreateInstance(type);
        var method = type.GetMethod("Execute");
        int i = 0, t1 = Environment.TickCount, t2;
        //var input = new object[] { 2 };

        //for (int j = 0; j < 10000000; j++)
        //{
        //    input[0] = j;
        //    var output = method.Invoke(obj, input);
        //    i = (int)output;
        //}

        //t2 = Environment.TickCount;

        //MessageBox.Show((t2 - t1).ToString() + Environment.NewLine + i.ToString());

        t1 = Environment.TickCount;

        for (int j = 0; j < 100000000; j++)
        {
            i = Execute(j);
        }

        t2 = Environment.TickCount;

        MessageBox.Show("Native: " + (t2 - t1).ToString() + Environment.NewLine + i.ToString());

        var func = (Func<int, int>) Delegate.CreateDelegate(typeof (Func<int, int>), method);

        t1 = Environment.TickCount;

        for (int j = 0; j < 100000000; j++)
        {
            i = func(j);
        }

        t2 = Environment.TickCount;

        MessageBox.Show("Dynamic delegate: " + (t2 - t1).ToString() + Environment.NewLine + i.ToString());

        Func<int, int> funcL = Execute;

        t1 = Environment.TickCount;

        for (int j = 0; j < 100000000; j++)
        {
            i = funcL(j);
        }

        t2 = Environment.TickCount;

        MessageBox.Show("Delegate: " + (t2 - t1).ToString() + Environment.NewLine + i.ToString());
    }
4

3 回答 3

8

是的，如果您通过 aMethodInfo或 non-specific调用Delegate，那么它确实会很慢。诀窍是：不要那样做。各种方法：

  • 对于个别方法，通过一个基本但类型化的委托，例如Action，或作为一个通用的包罗万象，Func<object[], object>- 并用于Delegate.CreateDelegate创建一个类型化的委托：

    Action doSomething = (Action)Delegate.CreateDelegate(typeof(Action), method);

    另一个变体是使用ExpressionAPI（它有一个.Compile()方法），或者DynamicMethod（它有CreateDelegate()）。关键：您必须获得一个类型化委托并使用类型化调用（不是.DynamicInvoke）调用。

  • 对于生成整个类型的更复杂的情况，请考虑实现您知道的接口，即

    IFoo foo = (IFoo)Activator.CreateInstance(...);

    再次; 在初始演员（非常便宜）之后，您可以使用静态代码：

    foo.Bar();

不要使用someDelegate.DynamicInvoke(...)，或者someMethod.Invoke(...)如果您追求任何类型的表演。

于 2012-05-16T07:31:18.217 回答
3

除了 Marc 的建议之外，您还可以通过指定“优化”编译器选项来提高速度：

var res = foo.CompileAssemblyFromSource(
        new System.CodeDom.Compiler.CompilerParameters()
        {
            GenerateInMemory = true,
            CompilerOptions = "/optimize"
        },
于 2012-05-16T08:07:04.153 回答
1

认为值得展示所有潜在选项的外观及其性能特征。给定以下辅助类和函数：

public void Test(Func<int> func)
{        
    var watch = new Stopwatch();
    watch.Start();
    for (var i = 0; i <= 1000000; i++)
    {
        var test = func();
    }
    Console.WriteLine(watch.ElapsedMilliseconds);
}

public class FooClass { public int Execute() { return 1;}}

设置和执行：

using (Microsoft.CSharp.CSharpCodeProvider foo = 
       new Microsoft.CSharp.CSharpCodeProvider())
{
    var res = foo.CompileAssemblyFromSource(
        new System.CodeDom.Compiler.CompilerParameters() 
        {  
            GenerateInMemory = true 
        }, 
        "public class FooClass { public int Execute() { return 1;}}"
    );

    var real = new FooClass();
    Test(() => real.Execute());                   // benchmark, direct call

    var type = res.CompiledAssembly.GetType("FooClass");
    var obj = Activator.CreateInstance(type);    
    var method = type.GetMethod("Execute");
    var input = new object[] { };                
    Test(() => (int)method.Invoke(obj, input));   // reflection invoke  

    dynamic dyn = Activator.CreateInstance(type);  
    Test(() => dyn.Execute());                    // dynamic object invoke

    var action = (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), null, method); 
    Test(() => action());                         // delegate
}

结果是：

8     // direct
771   // reflection invoke
41    // dynamic object invoke
7     // delegate

所以在那些你不能使用委托的情况下（如果你还不够了解？），你可以试试dynamic.

于 2012-05-16T08:31:59.680 回答