C＃具有泛型的类的性能

Question

Consider a set of elements that derive from a base element.

// "Abstract" general element class
class AElement {
  public int Key;
}

// Specific element class implementation
class BElement : AElement {
}

That I want to store in a list. The two options:

List<AElement> aData = new List<AElement>();
List<BElement> bData = new List<BElement>();

If adding BElement's to both the aData and bData lists, and doing operations on the two, the bData version is significantly faster than the aData version. For example if using a dump generic BubbleSort, sorting of the "Key" of AElement:

static void BubbleSort<TElement>(List<TElement> Data) where TElement : AElement {
  for (int i = 0; i < Data.Count; i++)  {
    for (int j = 0; j < Data.Count; j++)  {
      if (Data[i].Key< Data[j].Key)         {
        TElement tmp = Data[i];
        Data[i] = Data[j];
        Data[j] = tmp;
      }
    }
  }
}

In my case with 5000 data elements I see up to 20% difference in favor of the bData compared to the aData.

Why is the bData faster than the aData here?

Edit: Added complete code:

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

namespace TemplateClassPerformance
{
  class Program {

    // "Abstract" general element class
    class AElement {
      public int Index;
    }

    // Specific element class implementation
    class BElement : AElement { }

    static void Main(string[] args)
    {
      Random random = new Random();
      Stopwatch stopwatch = new Stopwatch();

      for (int j = 0; j < 10; j++) {
        List<AElement> aData = new List<AElement>();
        List<BElement> bData = new List<BElement>();

        // Put the same elements in both lists
        for (int i = 0; i < 5000; i++)
        {
          BElement element = new BElement();
          element.Index = random.Next(1000000);
          aData.Add(element);
          bData.Add(element);
        }

        stopwatch.Reset();
        stopwatch.Start();
        BubbleSort(bData);
        stopwatch.Stop();
        long sbTicks = stopwatch.ElapsedTicks;

        stopwatch.Reset();
        stopwatch.Start();
        BubbleSort(aData);
        stopwatch.Stop();
        long saTicks = stopwatch.ElapsedTicks;

        Console.Out.WriteLine("sb: {0}, sa: {1}", sbTicks, saTicks);
      }
    }

    static void BubbleSort<TElement>(List<TElement> data) where TElement : AElement {
      for (int i = 0; i < data.Count; i++) {
        for (int j = 0; j < data.Count; j++) {
          if (data[i].Index < data[j].Index)   {
            TElement tmp = data[i];
            data[i] = data[j];
            data[j] = tmp;
          }
        }
      }
    }
  }
}

Answer 1

1. Public fields are not a good idea.
2. Bubble sort is not a very good bench-mark
3. It is still a strange result. Did you eliminate JIT and GC effects? Ran the tests multiple times in different order? Did you use the Stopwatch?

Why is the bData faster than the aData here?

Answer: It shouldn't be. I'm suspecting some measurement artefact.

---

Edit, after seeing the full code:

There is a difference, and I can't fault the benchmarking. So there is something to this.

When I change the initialization to :

int k = random.Next(1000000);
aData.Add(new AElement() { Index = k });
bData.Add(new BElement() { Index = k });

The difference goes away. But I realize this is not a complete answer.

Answer 2

Please replace:

for (int i = 0; i < 5000; i++)
    {
      BElement element = new BElement();
      element.Index = random.Next(1000000);
      aData.Add(element);
      bData.Add(element);
    }

with:

int index_;
    for (int i = 0; i < 5000; i++)
    {
      BElement belement = new BElement();
      AElement aelement = new AElement();
      index_=random.Next(1000000);
      Belement.Index =Aelement.Index = index_;
      aData.Add(Aelement);
      bData.Add(Belement);
    }

And report the result.