Различие в производительности для управляющих структур 'для' и 'foreach' в C#

Простой тест для полуутверждения. Я сделал небольшой тест, просто чтобы увидеть. Вот код:

static void Main(string[] args)
{
    List<int> intList = new List<int>();

    for (int i = 0; i < 10000000; i++)
    {
        intList.Add(i);
    }

    DateTime timeStarted = DateTime.Now;
    for (int i = 0; i < intList.Count; i++)
    {
        int foo = intList[i] * 2;
        if (foo % 2 == 0)
        {
        }
    }

    TimeSpan finished = DateTime.Now - timeStarted;

    Console.WriteLine(finished.TotalMilliseconds.ToString());
    Console.Read();

}

А вот секция foreach:

foreach (int i in intList)
{
    int foo = i * 2;
    if (foo % 2 == 0)
    {
    }
}

Когда я заменил for на foreach - foreach был на 20 миллисекунд быстрее - последовательно . Значение for составляло 135–139 мс, а значение foreach - 113–119 мс. Я несколько раз менял местами, чтобы убедиться, что это не какой-то процесс, который только что запустился.

Однако, когда я удалил foo и оператор if, for было быстрее на 30 мс (foreach было 88 мс, а for было 59 мс). Оба были пустыми снарядами. Я предполагаю, что foreach действительно передал переменную, в то время как for просто увеличивал переменную. Если я добавил

int foo = intList[i];

, то for станет медленнее примерно на 30 мс. Я предполагаю, что это было связано с созданием foo, захватом переменной в массиве и присвоением ее foo. Расчет для цикла: 2458 мс Вычисление цикла foreach: 2005 мс

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

Примечание: этот ответ больше относится к Java, чем к C #, поскольку в C # нет индексатора для LinkedLists , но я думаю, что общая точка зрения все еще сохраняется.

Если список , с которым вы работаете, оказывается LinkedList , производительность кода индексатора (доступ в стиле массива ) является намного хуже, чем использование IEnumerator из foreach для больших списков.

При доступе к элементу 10.000 в LinkedList с использованием синтаксиса индексатора: ] list [10000] , связанный список начнется с головного узла и пройдет десять тысяч раз по указателю Next , пока не достигнет нужного объекта. Очевидно, если вы сделаете это в цикле, вы получите:

list[0]; // head
list[1]; // head.Next
list[2]; // head.Next.Next
// etc.

Когда вы вызываете GetEnumerator (неявно используя синтаксис forach ), вы получаете объект IEnumerator , который имеет указатель на головной узел. Каждый раз, когда вы вызываете MoveNext , этот указатель перемещается на следующий узел, например:

IEnumerator em = list.GetEnumerator();  // Current points at head
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
// etc.

Как видите, в случае LinkedList s метод индексатора массива становится чем медленнее и медленнее, тем длиннее цикл (он должен проходить через один и тот же указатель головы снова и снова). В то время как IEnumerable просто работает в постоянное время.

Конечно, как сказал Джон, это действительно зависит от типа списка , если список не a LinkedList , но массив, поведение совершенно другое.

Я получу объект IEnumerator , который имеет указатель на головной узел. Каждый раз, когда вы вызываете MoveNext , этот указатель перемещается на следующий узел, например:

IEnumerator em = list.GetEnumerator();  // Current points at head
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
// etc.

Как видите, в случае LinkedList s метод индексатора массива становится чем медленнее и медленнее, тем длиннее цикл (он должен проходить через один и тот же указатель головы снова и снова). В то время как IEnumerable просто работает в постоянное время.

Конечно, как сказал Джон, это действительно зависит от типа списка , если список не a LinkedList , но массив, поведение совершенно другое.

Я получу объект IEnumerator , который имеет указатель на головной узел. Каждый раз, когда вы вызываете MoveNext , этот указатель перемещается на следующий узел, например:

IEnumerator em = list.GetEnumerator();  // Current points at head
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
em.MoveNext(); // Update Current to .Next
// etc.

Как видите, в случае LinkedList s метод индексатора массива становится чем медленнее и медленнее, тем длиннее цикл (он должен проходить через один и тот же указатель головы снова и снова). В то время как IEnumerable просто работает в постоянное время.

Конечно, как сказал Джон, это действительно зависит от типа списка , если список не a LinkedList , но массив, поведение совершенно другое.

метод индексатора массива становится все медленнее и медленнее, чем длиннее цикл (он должен проходить через один и тот же указатель заголовка снова и снова). В то время как IEnumerable просто работает в постоянное время.

Конечно, как сказал Джон, это действительно зависит от типа списка , если список не a LinkedList , но массив, поведение совершенно другое.

метод индексатора массива становится все медленнее и медленнее, чем длиннее цикл (он должен проходить через один и тот же указатель заголовка снова и снова). В то время как IEnumerable просто работает в постоянное время.

Конечно, как сказал Джон, это действительно зависит от типа списка , если список не a LinkedList , но массив, поведение совершенно другое.

Как уже упоминали другие люди, хотя производительность на самом деле не имеет большого значения, foreach всегда будет немного медленнее из-за IEnumerable / IEnumerator использование в цикле. Компилятор переводит эту конструкцию в вызовы этого интерфейса, и для каждого шага в конструкции foreach вызываются функция + свойство

IEnumerator iterator = ((IEnumerable)list).GetEnumerator();
while (iterator.MoveNext()) {
  var item = iterator.Current;
  // do stuff
}

. Это эквивалентное расширение конструкции в C #. Вы можете себе представить, как влияние на производительность может варьироваться в зависимости от реализации MoveNext и Current. В то время как при доступе к массиву у вас нет этих зависимостей.

Это ситуация, когда «научите человека ловить рыбу» - гораздо более полезный подход, чем «дай человеку рыбу». Как только вы поймете основные принципы и API NSDictionary, станет намного проще разработать собственное решение. Вот несколько наблюдений и моментов для обучения:

• Метод + dictionaryWithObject: forKey: используется для создания NSDictionary с одной парой ключ-значение. Он не будет принимать аргументы, разделенные запятыми, после каждого двоеточия (:) в вызове метода, только один. Чтобы создать словарь с несколькими парами «ключ-значение», используйте один из двух связанных методов: + dictionaryWithObjects: forKeys: , который принимает два объекта NSArray, содержащих значения и ключи, или + dictionaryWithObjectsAndKeys: , который заменяет (объект, ключ, объект, ключ) завершающим аргументом nil .
• Упростите код создания. Ты не Чтобы создать вещь, нужен миллион локальных переменных. Используйте встроенные аргументы там, где это имеет смысл. Один из способов сделать это - создать свой словарь в коде как NSMutableDictionary , а затем (при необходимости) сделать его неизменяемую копию, вызвав для него -copy . (Помните, что метод копирования возвращает новый объект, который вы должны освободить, чтобы избежать утечки памяти.) Таким образом, вам не нужно иметь переменную для каждого отдельного значения, поэтому вы можете выполнить «одноразовое» создание структуры (s ) на каждом уровне.
• Используйте + arrayWithObject: для создания NSArray с одним объектом.
• (Рекомендации по стилю) Никогда не используйте заглавную букву в начале имени переменной, метода или функция. (Обратите внимание, что SO выделяет переменные с заглавными буквами, такие как имена классов. Как оказалось, перечислитель для типов, основанных на массивах, обычно записывается примерно так:

  private static IEnumerable<T> MyEnum(List<T> list)
  {
      for (int i = 0; i < list.Count; i++)
      {
          yield return list[i];
      }
  }
  

  Итак, как вы можете видеть, в этом случае это не будет иметь большого значения, однако перечислитель для связанного списка, вероятно, будет что-то искать примерно так:

  private static IEnumerable<T> MyEnum(LinkedList<T> list)
  {
      LinkedListNode<T> current = list.First;
      do
      {
          yield return current.Value;
          current = current.Next;
      }
      while (current != null);
  }
  

  В .NET вы обнаружите, что класс LinkedList даже не имеет индексатора, поэтому вы не сможете выполнить цикл for в связанном списке; но если бы вы могли, индексатор должен был быть написан так:

  public T this[int index]
  {
         LinkedListNode<T> current = this.First;
         for (int i = 1; i <= index; i++)
         {
              current = current.Next;
         }
         return current.value;
  }
  

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

  однако перечислитель для связанного списка, вероятно, будет выглядеть примерно так:

  private static IEnumerable<T> MyEnum(LinkedList<T> list)
  {
      LinkedListNode<T> current = list.First;
      do
      {
          yield return current.Value;
          current = current.Next;
      }
      while (current != null);
  }
  

  В .NET вы обнаружите, что класс LinkedList даже не имеет индексатора, поэтому вы не сможете выполнить цикл for в связанном списке; но если бы вы могли, индексатор должен был быть написан так:

  public T this[int index]
  {
         LinkedListNode<T> current = this.First;
         for (int i = 1; i <= index; i++)
         {
              current = current.Next;
         }
         return current.value;
  }
  

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

  однако перечислитель для связанного списка, вероятно, будет выглядеть примерно так:

  private static IEnumerable<T> MyEnum(LinkedList<T> list)
  {
      LinkedListNode<T> current = list.First;
      do
      {
          yield return current.Value;
          current = current.Next;
      }
      while (current != null);
  }
  

  В .NET вы обнаружите, что класс LinkedList даже не имеет индексатора, поэтому вы не сможете выполнить цикл for в связанном списке; но если бы вы могли, индексатор должен был быть написан так:

  public T this[int index]
  {
         LinkedListNode<T> current = this.First;
         for (int i = 1; i <= index; i++)
         {
              current = current.Next;
         }
         return current.value;
  }
  

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