Насколько быстр и количество?

Я часто пишу код следующим образом:

if ( list.Count > 0 ) { }

Является ли это эффективным? Как выглядит эта операция:

Итерации по списку и подсчет его элементов
Результат: 986 000 элементов
Является ли 986 000 больше, чем 0?
return true

Или вот так:

Получить сохраненное количество элементов в списке (986 000)
Является ли 986 000 больше, чем 0?
return true

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

Как насчет Capacity списка?

Ответ 1

Я часто пишу код следующим образом: if ( list.Count > 0 ) { } Является ли это эффективным?

Да. Это возвращает счет в списке, который хранится в поле внутри списка и сравнивает его с нолем.

Теперь вопрос, который вы не спрашивали:

Как насчет if ( sequence.Count() > 0 ) { }? (Обратите внимание на круглые скобки на Count().)

Мы проводим опрос последовательности во время выполнения, чтобы узнать, является ли это списком, обладающим свойством Count, которое может быть эффективно рассчитано. Если это так, мы называем это. Если нет, мы подсчитываем всю последовательность по одному элементу за раз, а затем сравниваем это с нолем.

Разве это невероятно неэффективно?

Да.

Что было бы более эффективным?

if (sequence.Any())

Почему это более эффективно?

Потому что он пытается перебрать один элемент. Если это удается, то Any - true; если он терпит неудачу, то Any является ложным. Вам не нужно подсчитывать количество jellybeans в банке, чтобы узнать, есть ли больше нуля. Вам нужно только посмотреть, есть ли хотя бы один.

В дополнение к значительно более эффективному, код теперь читается, как предполагаемый смысл кода. Если вы намереваетесь спросить "есть ли какие-либо элементы в списке?" затем спросите: "Есть ли какие-либо предметы в списке?" а не "- количество элементов в списке больше нуля?"

Как насчет свойства Capacity списка?

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

Ответ 2

Свойство Count в List<T> - и все другие реализации ICollection<T> в BCL - это операция O (1), что означает, что она быстрая и независимая от числа числа элементов в списке.

Также существует метод расширения Count(), который можно вызвать на любом IEnumerable<T>. Этот метод O (n), что означает, что его время выполнения зависит от количества элементов в перечислимом. Однако есть одно исключение: если перечислимое действительно является реализацией ICollection<T> или ICollection, оно использует свойство Count, которое снова делает операцию O (1).

Свойству Capacity, как правило, ничего не нужно беспокоиться.

Ответ 3

Вместо этого используйте этот код: list.Any(). Он может быть медленнее, чем List<>.Count, но будет работать для любого IEnumerable < > наиболее эффективным способом.

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

Перемещение List.Count следующее (это действительно O (1)):

public int Count
{
  get
  {
    return this._size; // this is a field
  }
}

Ответ 4

Count - это O(1) операция в списке.

Это самый быстрый способ.

Подсчитать. Это список элементов, присутствующих в списке.

Capcity: объясняет лучшую документацию:

Получает или задает общее количество элементов внутренней структуры данных может сохраняться без изменения размера.

Ответ 5

Емкость не говорит вам, сколько объектов в вашем списке - насколько он готов.

Из MSDN:

Capacity is the number of elements that the List<T> can store before resizing is required, while Count is the number of elements that are actually in the List<T>.

List.Count является супер быстрым и является доступным свойством, тогда как List.Count() - из IEnumerable, и я считаю, что вам нужно сделать полное перечисление через список.