Количество Linq () быстрее или медленнее, чем Список. Количество или Массив. Длина?

Метод Enumerable.Count () проверяет ICollection , используя .Count - так в случае массивов и списков, это ненамного неэффективнее (просто дополнительный уровень косвенности).

У Марка есть правильный ответ, но дьявол кроется в деталях.

На моей машине:

• Для массивов .Length примерно в 100 раз быстрее, чем .Count ()
• Для списков .Count примерно в 10 раз быстрее, чем .Count () - Примечание: я ожидал бы аналогичной производительности от все Коллекции, реализующие IList

Массивы запускаются медленнее, так как .Length включает только одну операцию, .Count для массивов включает уровень косвенного обращения. Таким образом, .Count на массивах запускается в 10 раз медленнее (на моей машине), что может быть одной из тех причин, по которым интерфейс реализован явно. Представьте, что у вас есть объект с двумя общедоступными свойствами: .Count и .Length. Оба делают одно и то же, но .Count в 10 раз медленнее.

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

Код:

    static void TimeAction(string description, int times, Action func) {
        var watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < times; i++) {
            func();
        }
        watch.Stop();
        Console.Write(description);
        Console.WriteLine(" Time Elapsed {0} ms", watch.ElapsedMilliseconds);
    } 

    static void Main(string[] args) {
        var array = Enumerable.Range(0, 10000000).ToArray();
        var list = Enumerable.Range(0, 10000000).ToArray().ToList();

        // jit
        TimeAction("Ignore and jit", 1 ,() =>
        {
            var junk = array.Length;
            var junk2 = list.Count;
            array.Count();
            list.Count();
        });


        TimeAction("Array Length", 1000000, () => {
            var tmp1 = array.Length;
        });

        TimeAction("Array Count()", 1000000, () =>
        {
            var tmp2 = array.Count();
        });

        TimeAction("Array Length through cast", 1000000, () =>
        {
            var tmp3 = (array as ICollection<int>).Count;
        });


        TimeAction("List Count", 1000000, () =>
        {
            var tmp1 = list.Count;
        });

        TimeAction("List Count()", 1000000, () =>
        {
            var tmp2 = list.Count();
        });

        Console.ReadKey();
    }

Результаты:

Array Length Time Elapsed 3 ms
Array Count() Time Elapsed 264 ms
Array Length through cast Time Elapsed 16 ms
List Count Time Elapsed 3 ms
List Count() Time Elapsed 18 ms

Я бы сказал, это зависит от Списка. Если это IQueryable, который представляет собой таблицу где-то в базе данных, тогда Count () будет намного быстрее , потому что ему не нужно загружать все объекты. Но если список находится в памяти, я бы предположил, что свойство Count будет быстрее, если не примерно таким же.

Я считаю, что если вы вызовете Linq.Count () для ICollection или IList (например, для ArrayList или List), он просто вернет значение свойства Count. Так что производительность будет примерно такой же на простых коллекциях.