我在做一些性能指标时遇到了一些对我来说很奇怪的事情。我为以下两个函数计时:

  private static void DoOne()
      {
         List<int> A = new List<int>();
         for (int i = 0; i < 200; i++) A.Add(i);
          int s=0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < A.Count; c++) s += A[c];
         }

      }

   private static void DoTwo()
      {
         List<int> A = new List<int>();
         for (int i = 0; i < 200; i++) A.Add(i);
         IList<int> L = A;
         int s = 0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < L.Count; c++) s += L[c];
         }

      }

即使在 Release模式下编译，计时结果始终显示 DoTwo 比 DoOne 花费大约 100 倍的时间:

 DoOne took 0.06171706 seconds.
 DoTwo took 8.841709 seconds.

鉴于 List 直接实现 IList 这一事实，我对结果感到非常惊讶。谁能澄清这种行为？

血淋淋的细节

回答问题，这里是完整的代码和项目构建首选项的图像:

Dead Image Link

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Collections;

namespace TimingTests
{
   class Program
   {
      static void Main(string[] args)
      {
         Stopwatch SW = new Stopwatch();
         SW.Start();
         DoOne();
         SW.Stop();

         Console.WriteLine(" DoOne took {0} seconds.", ((float)SW.ElapsedTicks) / Stopwatch.Frequency);
         SW.Reset();
         SW.Start();
         DoTwo();
         SW.Stop();

         Console.WriteLine(" DoTwo took {0} seconds.", ((float)SW.ElapsedTicks) / Stopwatch.Frequency);

      }

      private static void DoOne()
      {
         List<int> A = new List<int>();
         for (int i = 0; i < 200; i++) A.Add(i);
         int s=0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < A.Count; c++) s += A[c];
         }

      }
      private static void DoTwo()
      {
         List<int> A = new List<int>();
         for (int i = 0; i < 200; i++) A.Add(i);
         IList<int> L = A;
         int s = 0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < L.Count; c++) s += L[c];
         }

      }
   }
}

感谢所有好的答案(尤其是@kentamiura)。我会关闭这个问题，尽管我觉得我们仍然错过了这个难题的重要部分。为什么通过它实现的接口(interface)访问一个类会慢得多？我能看到的唯一区别是，通过接口(interface)访问函数意味着使用虚拟表，而通常可以直接调用函数。为了查看是否是这种情况，我对上面的代码进行了一些更改。首先我介绍了两个几乎相同的类:

  public class VC
  {
     virtual public int f() { return 2; }
     virtual public int Count { get { return 200; } }

  }

  public class C
  {
      public int f() { return 2; }
      public int Count { get { return 200; } }

  }

如您所见，VC 使用虚函数而 C 不使用。现在做 DoOne 和 DoTwo:

    private static void DoOne()
      {  C a = new C();
         int s=0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < a.Count; c++) s += a.f();
         }

      }
      private static void DoTwo()
      {
           VC a = new VC();
         int s = 0;
         for (int j = 0; j < 100000; j++)
         {
            for (int c = 0; c < a.Count; c++) s +=  a.f();
         }

      }

确实:

DoOne took 0.01287789 seconds.
DoTwo took 8.982396 seconds.

这更可怕——虚函数调用慢了800倍？？所以有几个问题要问社区:

1. 你能重现吗？ (鉴于 事实上，所有人的表现都更差 以前，但没有我的那么糟糕)
2. 你能解释一下吗？
3. (这可能是 最重要的)-你能想到 避免的方法？

波阿斯

最佳答案

致所有尝试对此类内容进行基准测试的人的注意事项。

不要忘记代码在第一次运行之前不会被调整。这意味着您第一次运行一个方法时，运行该方法的成本可能主要取决于加载 IL、分析 IL 以及将其编译为机器代码所花费的时间，尤其是当它是一个普通方法时。

如果您要做的是比较两种方法的“边际”运行时成本，最好将这两种方法都运行两次，并且只考虑第二次运行以进行比较。

关于c# - 为什么将 List<T> 转换为 IList<T> 会导致性能下降？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/854959/