Как я могу сделать свою функцию выполненной с такой скоростью, как “Содержит” на ArrayList?

Во-первых, вы не запускаете его много раз и не сравниваете средние значения.

Во-вторых, ваш метод не будет изменен до тех пор, пока он не будет запущен. Таким образом, время своевременной компиляции добавляется ко времени его выполнения.

Настоящий тест будет запускаться каждый несколько раз и усреднять результаты (любое количество вещей может привести к тому, что один или другой будет медленнее для выполнения X из общего количества Y), и ваши сборки должны быть предварительно настроены с использованием ngen.exe .

С действительно оптимизатором не должно быть никакой разницы, потому что семантика кажется одинаковой. Однако существующий оптимизатор может оптимизировать вашу функцию не так хорошо, как оптимизированный жестко запрограммированный Contains . Некоторые моменты для оптимизации:

1. сравнение со свойством каждый раз может быть медленнее, чем обратный отсчет, а сравнение с 0
2. сам вызов функции имеет снижение производительности
3. использование итераторов вместо явной индексации может быть быстрее ( цикл foreach вместо простого for )

Используйте SortedList , Dictionary или System. Collections.ObjectModel.KeyedCollection для быстрого доступа на основе ключа.

var list = new List<myObject>(); // Search is sequential
var dictionary = new Dictionary<myObject, myObject>(); // key based lookup, but no sequential lookup, Contains fast
var sortedList = new SortedList<myObject, myObject>(); // key based and sequential lookup, Contains fast

KeyedCollection также работает быстро и позволяет индексированный поиск, однако его необходимо унаследовать, поскольку он является абстрактным. Следовательно, вам нужна конкретная коллекция. Однако с помощью следующего вы можете создать общий KeyedCollection .

public class GenericKeyedCollection<TKey, TValue> : KeyedCollection<TKey, TValue> {
   public GenericKeyedCollection(Func<TValue, TKey> keyExtractor) {
      this.keyExtractor = keyExtractor;
   }

   private Func<TValue, TKey> keyExtractor;

   protected override TKey GetKeyForItem(TValue value) {
      return this.keyExtractor(value);
   }
}

Преимущество использования KeyedCollection заключается в том, что метод Add не требует указания ключа.

Я не уверен, разрешено ли вам публиковать код Reflector, но если вы откроете метод с помощью Reflector, вы увидите, что это по сути то же самое (есть некоторые оптимизации для нулевых значений, но ваш тестовый набор не включает нули).

Единственное различие, которое я вижу, это то, что вызов list[i] делает проверку границ для i, тогда как метод Contains этого не делает.

Во-первых, если вы используете типы, которые знаете заранее, я бы посоветовал использовать дженерики. Итак, List вместо ArrayList. Под капотом ArrayList.Contains на самом деле делает немного больше, чем то, что вы делаете. Следующее получено от отражателя:

public virtual bool Contains(object item)
{
    if (item == null)
    {
        for (int j = 0; j < this._size; j++)
        {
            if (this._items[j] == null)
            {
                return true;
            }
        }
        return false;
    }
    for (int i = 0; i < this._size; i++)
    {
        if ((this._items[i] != null) && this._items[i].Equals(item))
        {
            return true;
        }
    }
    return false;
}

Обратите внимание, что он разветвляется при передаче нулевого значения для элемента. Однако, поскольку все значения в вашем примере не равны нулю, дополнительная проверка нуля в начале и во втором цикле теоретически должна занять больше времени.

Вы уверены, что имеете дело с полностью скомпилированным кодом? То есть, когда ваш код запускается в первый раз, он компилируется JIT, поскольку структура, очевидно, уже скомпилирована.

После вашего редактирования я скопировал код и сделал в нем несколько улучшений.
Разница не была воспроизведена, оказалось, что это проблема измерения/округления.

Чтобы увидеть это, измените свои прогоны на такой вид:

    sw.Reset();
    sw.Start();
    for (int i = 0; i < nr; i++)
    {          
        DoesContain(list,"zzz");            
    }
    total += sw.ElapsedMilliseconds;
    Console.WriteLine(total / nr);

Я просто передвинул несколько строк. Проблема JIT оказалась незначительной при таком количестве повторений.

Мое предположение заключается в том, что ArrayList написан на C++ и может использовать преимущества некоторых микрооптимизаций (примечание: это предположение).

Например, в C++ вы можете использовать арифметику указателей (в частности, инкрементирование указателя для итерации массива), чтобы быть быстрее, чем использование индекса.

Поскольку вы используете .NET 3.5, почему вы используете для начала ArrayList , а не List ?

Несколько вещей, которые стоит попробовать:

• Вы могли видеть, помогает ли использование foreach вместо for цикла

• Вы можете кэшировать счетчик:

   public bool DoesContain (список ArrayList, элемент объекта) {{ 1}} {
  int count = list.Count; 
  for (int i = 0; i 

• Вы можете перевернуть сравнение:

   if (element.Equals (list [i]))