我对 C# 中 dynamic 的性能有疑问。我读过 dynamic 让编译器再次运行，但它有什么作用？

是否必须使用用作参数的 dynamic 变量或仅那些具有动态行为/上下文的行重新编译整个方法？

我注意到使用 dynamic 变量会使简单的 for 循环减慢 2 个数量级。

我玩过的代码:

internal class Sum2
{
    public int intSum;
}

internal class Sum
{
    public dynamic DynSum;
    public int intSum;
}

class Program
{
    private const int ITERATIONS = 1000000;

    static void Main(string[] args)
    {
        var stopwatch = new Stopwatch();
        dynamic param = new Object();
        DynamicSum(stopwatch);
        SumInt(stopwatch);
        SumInt(stopwatch, param);
        Sum(stopwatch);

        DynamicSum(stopwatch);
        SumInt(stopwatch);
        SumInt(stopwatch, param);
        Sum(stopwatch);

        Console.ReadKey();
    }

    private static void Sum(Stopwatch stopwatch)
    {
        var sum = 0;
        stopwatch.Reset();
        stopwatch.Start();
        for (int i = 0; i < ITERATIONS; i++)
        {
            sum += i;
        }
        stopwatch.Stop();

        Console.WriteLine(string.Format("Elapsed {0}", stopwatch.ElapsedMilliseconds));
    }

    private static void SumInt(Stopwatch stopwatch)
    {
        var sum = new Sum();
        stopwatch.Reset();
        stopwatch.Start();
        for (int i = 0; i < ITERATIONS; i++)
        {
            sum.intSum += i;
        }
        stopwatch.Stop();

        Console.WriteLine(string.Format("Class Sum int Elapsed {0}", stopwatch.ElapsedMilliseconds));
    }

    private static void SumInt(Stopwatch stopwatch, dynamic param)
    {
        var sum = new Sum2();
        stopwatch.Reset();
        stopwatch.Start();
        for (int i = 0; i < ITERATIONS; i++)
        {
            sum.intSum += i;
        }
        stopwatch.Stop();

        Console.WriteLine(string.Format("Class Sum int Elapsed {0} {1}", stopwatch.ElapsedMilliseconds, param.GetType()));
    }

    private static void DynamicSum(Stopwatch stopwatch)
    {
        var sum = new Sum();
        stopwatch.Reset();
        stopwatch.Start();
        for (int i = 0; i < ITERATIONS; i++)
        {
            sum.DynSum += i;
        }
        stopwatch.Stop();

        Console.WriteLine(String.Format("Dynamic Sum Elapsed {0}", stopwatch.ElapsedMilliseconds));
    }

最佳答案

I've read dynamic makes the compiler run again, but what it does. Does it have to recompile whole method with the dynamic used as a parameter or rather those lines with dynamic behavior/context(?)

这是交易。

对于程序中每个动态类型的表达式，编译器都会发出代码，生成一个表示操作的“动态调用站点对象”。因此，例如，如果您有:

class C
{
    void M()
    {
        dynamic d1 = whatever;
        dynamic d2 = d1.Foo();

然后编译器将生成道德上像这样的代码。 (实际代码要复杂得多；为了演示目的，这里进行了简化。)

class C
{
    static DynamicCallSite FooCallSite;
    void M()
    {
        object d1 = whatever;
        object d2;
        if (FooCallSite == null) FooCallSite = new DynamicCallSite();
        d2 = FooCallSite.DoInvocation("Foo", d1);

看看到目前为止这是如何运作的？我们生成调用站点一次，无论您调用 M 多少次。调用站点在您生成一次后永远存在。调用站点是一个对象，表示“这里将动态调用 Foo”。

好的，现在您已经有了调用站点，调用是如何工作的？

调用站点是动态语言运行时的一部分。 DLR 说“嗯，有人正试图在此对象上动态调用方法 foo。我对此一无所知吗？不知道。那我最好找出答案。”

然后 DLR 询问 d1 中的对象，看它是否有任何特殊之处。也许它是一个遗留的 COM 对象，或者一个 Iron Python 对象，或者一个 Iron Ruby 对象，或者一个 IE DOM 对象。如果它不是其中任何一个，那么它一定是一个普通的 C# 对象。

这是编译器再次启动的地方。不需要词法分析器或解析器，因此 DLR 启动了一个特殊版本的 C# 编译器，它只有元数据分析器、表达式的语义分析器和一个发射表达式树而不是 IL 的发射器。

元数据分析器使用反射来确定 d1 中对象的类型，然后将其传递给语义分析器以询问在方法 Foo 上调用此类对象时会发生什么。重载解析分析器会弄清楚这一点，然后构建一个表达式树——就像您在表达式树 lambda 中调用 Foo 一样——代表该调用。

然后，C# 编译器将该表达式树连同缓存策略一起传回 DLR。该策略通常是“第二次看到这种类型的对象时，您可以重新使用这个表达式树而不是再次给我回电话”。然后，DLR 在表达式树上调用 Compile，这会调用表达式树到 IL 的编译器，并在委托(delegate)中吐出一 block 动态生成的 IL。

然后，DLR 将此委托(delegate)缓存在与调用站点对象关联的缓存中。

然后它调用委托(delegate)，并发生 Foo 调用。

第二次调用 M 时，我们已经有了一个调用站点。 DLR 再次询问该对象，如果该对象与上次的类型相同，它将从缓存中取出委托(delegate)并调用它。如果对象是不同的类型，那么缓存就会丢失，整个过程会重新开始；我们对调用进行语义分析并将结果存储在缓存中。

对于涉及动态的每个表达式，都会发生这种情况。例如，如果您有:

int x = d1.Foo() + d2;

然后有三个 动态调用站点。一种用于动态调用 Foo，一种用于动态加法，一种用于从 dynamic 到 int 的动态转换。每个都有自己的运行时分析和分析结果缓存。

有道理吗？

关于c# - 动态变量如何影响性能？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7478387/