Какой метод работает лучше: .Any () vs .Count () ›0?

Если вы начинаете с чего-то, что имеет .Length или .Count (например, ICollection<T>, IList<T>, List<T> и т. Д.), То это будет самый быстрый вариант, поскольку ему не нужно проходить последовательность _6 _ / _ 7 _ / _ 8_, требуемую Any() для проверки непустой IEnumerable<T> последовательности.

Всего лишь для IEnumerable<T>, тогда Any() будет в целом быстрее, так как нужно учитывать только одну итерацию. Однако обратите внимание, что реализация Count() LINQ-to-Objects действительно проверяет ICollection<T> (с использованием .Count в качестве оптимизации), поэтому, если ваш базовый источник данных напрямую является списком / коллекцией, не будет будет огромная разница. Не спрашивайте меня, почему он не использует неуниверсальный _16 _...

Конечно, если вы использовали LINQ для фильтрации и т. Д. (Where и т. Д.), У вас будет последовательность, основанная на блоках итератора, и поэтому такая ICollection<T> оптимизация бесполезна.

Обычно с IEnumerable<T>: придерживайтесь Any() ;-p

Примечание. Я написал этот ответ, когда еще существовала Entity Framework 4. Суть этого ответа заключалась не в том, чтобы вдаваться в тривиальное тестирование производительности .Any() vs .Count(). Дело было в том, чтобы сигнализировать о том, что EF далек от совершенства. Более новые версии лучше ... но если у вас есть часть кода, который медленный и использует EF, протестируйте с прямым TSQL и сравните производительность, а не полагайтесь на предположения (что .Any() ВСЕГДА быстрее, чем .Count() > 0).

Хотя я согласен с наиболее одобренными ответами и комментариями - особенно в отношении того, что Any сигнализирует о намерении разработчика лучше, чем Count() > 0, - у меня была ситуация, в которой Count на SQL Server на порядок быстрее (EntityFramework 4).

Вот запрос с Any, что исключение тайм-аута w (для ~ 200000 записей):

con = db.Contacts.
    Where(a => a.CompanyId == companyId && a.ContactStatusId <= (int) Const.ContactStatusEnum.Reactivated
        && !a.NewsletterLogs.Any(b => b.NewsletterLogTypeId == (int) Const.NewsletterLogTypeEnum.Unsubscr)
    ).OrderBy(a => a.ContactId).
    Skip(position - 1).
    Take(1).FirstOrDefault();

Count версия выполняется за миллисекунды:

con = db.Contacts.
    Where(a => a.CompanyId == companyId && a.ContactStatusId <= (int) Const.ContactStatusEnum.Reactivated
        && a.NewsletterLogs.Count(b => b.NewsletterLogTypeId == (int) Const.NewsletterLogTypeEnum.Unsubscr) == 0
    ).OrderBy(a => a.ContactId).
    Skip(position - 1).
    Take(1).FirstOrDefault();

Мне нужно найти способ увидеть, какой именно SQL выдают оба LINQ, но очевидно, что в некоторых случаях существует огромная разница в производительности между Count и Any, и, к сожалению, кажется, что вы не можете просто придерживаться Any во всех случаях.

РЕДАКТИРОВАТЬ: вот сгенерированные SQL-запросы. Красавицы как видите;)

ANY:

exec sp_executesql N'SELECT TOP (1) 
[Project2].[ContactId] AS [ContactId], 
[Project2].[CompanyId] AS [CompanyId], 
[Project2].[ContactName] AS [ContactName], 
[Project2].[FullName] AS [FullName], 
[Project2].[ContactStatusId] AS [ContactStatusId], 
[Project2].[Created] AS [Created]
FROM ( SELECT [Project2].[ContactId] AS [ContactId], [Project2].[CompanyId] AS [CompanyId], [Project2].[ContactName] AS [ContactName], [Project2].[FullName] AS [FullName], [Project2].[ContactStatusId] AS [ContactStatusId], [Project2].[Created] AS [Created], row_number() OVER (ORDER BY [Project2].[ContactId] ASC) AS [row_number]
    FROM ( SELECT 
        [Extent1].[ContactId] AS [ContactId], 
        [Extent1].[CompanyId] AS [CompanyId], 
        [Extent1].[ContactName] AS [ContactName], 
        [Extent1].[FullName] AS [FullName], 
        [Extent1].[ContactStatusId] AS [ContactStatusId], 
        [Extent1].[Created] AS [Created]
        FROM [dbo].[Contact] AS [Extent1]
        WHERE ([Extent1].[CompanyId] = @p__linq__0) AND ([Extent1].[ContactStatusId] <= 3) AND ( NOT EXISTS (SELECT 
            1 AS [C1]
            FROM [dbo].[NewsletterLog] AS [Extent2]
            WHERE ([Extent1].[ContactId] = [Extent2].[ContactId]) AND (6 = [Extent2].[NewsletterLogTypeId])
        ))
    )  AS [Project2]
)  AS [Project2]
WHERE [Project2].[row_number] > 99
ORDER BY [Project2].[ContactId] ASC',N'@p__linq__0 int',@p__linq__0=4

COUNT:

exec sp_executesql N'SELECT TOP (1) 
[Project2].[ContactId] AS [ContactId], 
[Project2].[CompanyId] AS [CompanyId], 
[Project2].[ContactName] AS [ContactName], 
[Project2].[FullName] AS [FullName], 
[Project2].[ContactStatusId] AS [ContactStatusId], 
[Project2].[Created] AS [Created]
FROM ( SELECT [Project2].[ContactId] AS [ContactId], [Project2].[CompanyId] AS [CompanyId], [Project2].[ContactName] AS [ContactName], [Project2].[FullName] AS [FullName], [Project2].[ContactStatusId] AS [ContactStatusId], [Project2].[Created] AS [Created], row_number() OVER (ORDER BY [Project2].[ContactId] ASC) AS [row_number]
    FROM ( SELECT 
        [Project1].[ContactId] AS [ContactId], 
        [Project1].[CompanyId] AS [CompanyId], 
        [Project1].[ContactName] AS [ContactName], 
        [Project1].[FullName] AS [FullName], 
        [Project1].[ContactStatusId] AS [ContactStatusId], 
        [Project1].[Created] AS [Created]
        FROM ( SELECT 
            [Extent1].[ContactId] AS [ContactId], 
            [Extent1].[CompanyId] AS [CompanyId], 
            [Extent1].[ContactName] AS [ContactName], 
            [Extent1].[FullName] AS [FullName], 
            [Extent1].[ContactStatusId] AS [ContactStatusId], 
            [Extent1].[Created] AS [Created], 
            (SELECT 
                COUNT(1) AS [A1]
                FROM [dbo].[NewsletterLog] AS [Extent2]
                WHERE ([Extent1].[ContactId] = [Extent2].[ContactId]) AND (6 = [Extent2].[NewsletterLogTypeId])) AS [C1]
            FROM [dbo].[Contact] AS [Extent1]
        )  AS [Project1]
        WHERE ([Project1].[CompanyId] = @p__linq__0) AND ([Project1].[ContactStatusId] <= 3) AND (0 = [Project1].[C1])
    )  AS [Project2]
)  AS [Project2]
WHERE [Project2].[row_number] > 99
ORDER BY [Project2].[ContactId] ASC',N'@p__linq__0 int',@p__linq__0=4

Кажется, что чистый Where с EXISTS работает намного хуже, чем вычисление Count, а затем выполнение Where с Count == 0.

Дайте мне знать, если вы заметите ошибку в моих выводах. Что можно извлечь из всего этого, независимо от обсуждения Any vs Count, так это то, что любой более сложный LINQ будет намного лучше, если его переписать как хранимую процедуру;).

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

Среда тестирования: EF 6.1.3, SQL Server, 300 КБ записей.

Настольная модель:

class TestTable
{
    [Key]
    public int Id { get; set; }

    public string Name { get; set; }

    public string Surname { get; set; }
}

Тестовый код:

class Program
{
    static void Main()
    {
        using (var context = new TestContext())
        {
            context.Database.Log = Console.WriteLine;

            context.TestTables.Where(x => x.Surname.Contains("Surname")).Any(x => x.Id > 1000);
            context.TestTables.Where(x => x.Surname.Contains("Surname") && x.Name.Contains("Name")).Any(x => x.Id > 1000);
            context.TestTables.Where(x => x.Surname.Contains("Surname")).Count(x => x.Id > 1000);
            context.TestTables.Where(x => x.Surname.Contains("Surname") && x.Name.Contains("Name")).Count(x => x.Id > 1000);

            Console.ReadLine();
        }
    }
}

Результаты:

Любой () ~ 3 мс

Count () ~ 230 мс для первого запроса, ~ 400 мс для второго

Примечания:

В моем случае EF не генерировал SQL, как @Ben, упомянутый в его сообщении.

Точные детали немного отличаются в .NET Framework от .NET Core, но это также в некоторой степени зависит от того, что вы делаете: если вы используете тип ICollection или ICollection<T> (например, с List<T>), есть дешевое свойство .Count. для доступа, тогда как для других типов может потребоваться перечисление.

TL;DR:

Используйте .Count > 0, если свойство существует, в противном случае .Any().

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

Это относится как к .NET Framework, так и к .NET Core.

Теперь мы можем углубиться в детали ..

Списки и коллекции

Начнем с очень распространенного случая: использования List<T> (который тоже ICollection<T>).

Свойство .Count реализовано как:

    private int _size;

    public int Count {
        get {
            Contract.Ensures(Contract.Result<int>() >= 0);
            return _size; 
        }
    }

Это означает, что _size поддерживается _13 _, _ 14_ и т. Д., И поскольку он просто обращается к полю, это чрезвычайно дешевая операция - нам не нужно перебирать значения.

ICollection и ICollection<T> имеют .Count и большинство типов, реализующих их, вероятно, будут делать это аналогичным образом.

Другие IEnumerables

Любые другие IEnumerable типы, которые также не ICollection требуют начала перечисления, чтобы определить, пусты они или нет. Ключевым фактором, влияющим на производительность, является то, если мы в конечном итоге перечисляем один элемент (идеально) или всю коллекцию (относительно дорого).

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

.NET Framework .Any()

В .NET Framework (4.8) реализация Any():

public static bool Any<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source");
    using (IEnumerator<TSource> e = source.GetEnumerator()) {
        if (e.MoveNext()) return true;
    }
    return false;
}

Это означает, что несмотря ни на что, он получит новый объект перечислителя и попытается выполнить итерацию один раз. Это дороже, чем вызов свойства List<T>.Count, но, по крайней мере, он не повторяет весь список.

.NET Framework .Count()

В .NET Framework (4.8) реализация Count() (в основном):

public static int Count<TSource>(this IEnumerable<TSource> source)
{
    ICollection<TSource> collection = source as ICollection<TSource>;
    if (collection != null)
    { 
        return collection.Count;
    }
    int num = 0;
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            num = checked(num + 1);
        }
        return num;
    }
}

Если доступно, используется ICollection.Count, но в противном случае перечисляется коллекция.

.NET Core .Any()

Реализация LINQ Any() в .NET Core намного умнее. Вы можете увидеть, что завершено источник здесь, но важные части этого обсуждения:

    public static bool Any<TSource>(this IEnumerable<TSource> source)
    {
        //..snip..
        
        if (source is ICollection<TSource> collectionoft)
        {
            return collectionoft.Count != 0;
        }
        
        //..snip..

        using (IEnumerator<TSource> e = source.GetEnumerator())
        {
            return e.MoveNext();
        }
    }

Поскольку List<T> - это ICollection<T>, это вызовет свойство Count (и хотя он вызывает другой метод, дополнительных выделений нет).

.NET Core .Count()

Реализация .NET Core (source) в основном совпадает с .NET Framework (см. выше), поэтому он будет использовать ICollection.Count, если он доступен, а в противном случае перечисляет коллекцию.

Резюме

.NET Framework

• С ICollection:

  • .Count > 0 is best
  • .Count() > 0 в порядке, но в конечном итоге просто звонит ICollection.Count
  • .Any() будет медленнее, так как перечисляет один элемент

• Без ICollection (без свойства .Count)

  • .Any() is best, as it only enumerates a single item
  • .Count() > 0 плохо, так как вызывает полное перечисление

.NET Core

• .Count > 0 лучше всего, если есть (ICollection)
• .Any() в порядке, он либо выполнит ICollection.Count > 0, либо перечислит отдельный элемент
• .Count() > 0 плохо, так как вызывает полное перечисление

РЕДАКТИРОВАТЬ: это было исправлено в EF версии 6.1.1. и этот ответ больше не актуален

Для SQL Server и EF4-6 Count () работает примерно в два раза быстрее, чем Any ().

Когда вы запускаете Table.Any (), он сгенерирует что-то вроде (предупреждение: не повредите мозг, пытаясь понять это)

SELECT 
CASE WHEN ( EXISTS (SELECT 
    1 AS [C1]
    FROM [Table] AS [Extent1]
)) THEN cast(1 as bit) WHEN ( NOT EXISTS (SELECT 
    1 AS [C1]
    FROM [Table] AS [Extent2]
)) THEN cast(0 as bit) END AS [C1]
FROM  ( SELECT 1 AS X ) AS [SingleRowTable1]

для этого требуется 2 сканирования строк с вашим состоянием.

Я не люблю писать Count() > 0, потому что это скрывает мои намерения. Я предпочитаю использовать для этого собственный предикат:

public static class QueryExtensions
{
    public static bool Exists<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
    {
        return source.Count(predicate) > 0;
    }
}

Это зависит от того, насколько велик набор данных и каковы ваши требования к производительности?

Если нет ничего гигантского, используйте наиболее читаемую форму, которая для меня любая, потому что она короче и удобочитаема, а не уравнение.

Вы можете провести простой тест, чтобы понять это:

var query = //make any query here
var timeCount = new Stopwatch();
timeCount.Start();
if (query.Count > 0)
{
}
timeCount.Stop();
var testCount = timeCount.Elapsed;

var timeAny = new Stopwatch();
timeAny.Start();
if (query.Any())
{
}
timeAny.Stop();
var testAny = timeAny.Elapsed;

Проверьте значения testCount и testAny.

Что касается метода Count (), если IEnumarable является ICollection, то мы не можем выполнять итерацию по всем элементам, потому что можем получить < strong> Count поля ICollection, если IEnumerable не является ICollection, мы должны выполнить итерацию по всем элементам, используя а с помощью MoveNext взгляните на код .NET Framework:

public static int Count<TSource>(this IEnumerable<TSource> source)
{
    if (source == null) 
        throw Error.ArgumentNull("source");

    ICollection<TSource> collectionoft = source as ICollection<TSource>;
    if (collectionoft != null) 
        return collectionoft.Count;

    ICollection collection = source as ICollection;
    if (collection != null) 
        return collection.Count;

    int count = 0;
    using (IEnumerator<TSource> e = source.GetEnumerator())
    {
        checked
        {
            while (e.MoveNext()) count++;
        }
    }
    return count;
}

Ссылка: Перечислимый справочный источник

Если вы используете Entity Framework и имеете огромную таблицу с большим количеством записей, Any () будет намного быстрее. Я помню, как однажды я хотел проверить, пуста ли таблица и есть ли в ней миллионы строк. Для завершения Count ()> 0 потребовалось 20-30 секунд. Это было мгновенно с помощью Any ().

Any () может повысить производительность, поскольку ему, возможно, не придется повторять сборку, чтобы получить количество вещей. Он просто должен поразить одного из них. Или, скажем, для LINQ-to-Entities сгенерированный SQL будет IF EXISTS (...), а не SELECT COUNT ... или даже SELECT * ....

Я создал образец приложения с использованием IList с 100 элементами на 1 миллион элементов, чтобы увидеть Count vs Any, который лучше всего.

Код

class Program
{
    static void Main()
    {

        //Creating List of customers
        IList<Customer> customers = new List<Customer>();
        for (int i = 0; i <= 100; i++)
        {
            Customer customer = new Customer
            {
                CustomerId = i,
                CustomerName = string.Format("Customer{0}", i)
            };
            customers.Add(customer);
        }

        //Measuring time with count
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        if (customers.Count > 0)
        {
            Console.WriteLine("Customer list is not empty with count");
        }
        stopWatch.Stop();
        Console.WriteLine("Time consumed with count: {0}", stopWatch.Elapsed);

        //Measuring time with any
        stopWatch.Restart();
        if (customers.Any())
        {
            Console.WriteLine("Customer list is not empty with any");
        }
        stopWatch.Stop();
        Console.WriteLine("Time consumed with count: {0}", stopWatch.Elapsed);
        Console.ReadLine();

    }
}

public class Customer
{
    public int CustomerId { get; set; }
    public string CustomerName { get; set; }
}

Результат:

Лучше любое, чем считать.