Проверка пустого списка с помощью LINQ

Какой "лучший" (принимая во внимание скорость и удобочитаемость) способ определить, пуст ли список? Даже если список относится к типу IEnumerable<T>и не имеет свойства Count.

Прямо сейчас я бросаюсь между этим:

if (myList.Count() == 0) { ... }

и это:

if (!myList.Any()) { ... }

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

При этом второй вариант кажется вам читаемым? Что бы вы предпочли? Или вы можете придумать лучший способ проверить пустой список?

Ответ Edit @ lassevk кажется наиболее логичным, в сочетании с небольшой проверкой времени выполнения, чтобы использовать кешированный счетчик, если это возможно, например:

public static bool IsEmpty<T>(this IEnumerable<T> list)
{
    if (list is ICollection<T>) return ((ICollection<T>)list).Count == 0;

    return !list.Any();
}

Вы могли сделать это:

public static Boolean IsEmpty<T>(this IEnumerable<T> source)
{
    if (source == null)
        return true; // or throw an exception
    return !source.Any();
}

Изменить : обратите внимание, что простое использование метода .Count будет быстрым, если у базового источника действительно есть свойство fast Count. Допустимая оптимизация, приведенная выше, будет заключаться в обнаружении нескольких базовых типов и простом использовании их свойства .Count вместо подхода .Any (), но затем откат к .Any (), если нет гарантии.

Я бы сделал одно небольшое дополнение к коду, на котором вы, кажется, остановились: проверьте также ICollection, поскольку это реализовано даже некоторыми не устаревшими универсальными классами (например, Queue<T>и Stack<T>). Я бы также использовал asвместо этого, isпоскольку это более идиоматично и, как было показано, быстрее .

public static bool IsEmpty<T>(this IEnumerable<T> list)
{
    if (list == null)
    {
        throw new ArgumentNullException("list");
    }

    var genericCollection = list as ICollection<T>;
    if (genericCollection != null)
    {
        return genericCollection.Count == 0;
    }

    var nonGenericCollection = list as ICollection;
    if (nonGenericCollection != null)
    {
        return nonGenericCollection.Count == 0;
    }

    return !list.Any();
}

Сам LINQ должен как-то серьезно оптимизировать метод Count ().

Вас это удивляет? Я предполагаю, что для IListреализаций Countпросто считывает количество элементов напрямую, при этом Anyон должен запросить IEnumerable.GetEnumeratorметод, создать экземпляр и вызвать MoveNextхотя бы один раз.

/ РЕДАКТИРОВАТЬ @Matt:

Я могу только предположить, что метод расширения Count () для IEnumerable делает что-то вроде этого:

Да, конечно. Вот что я имел в виду. На самом деле он использует ICollectionвместо, IListно результат тот же.

Я только что написал небольшой тест, попробуйте следующее:

 IEnumerable<Object> myList = new List<Object>();

 Stopwatch watch = new Stopwatch();

 int x;

 watch.Start();
 for (var i = 0; i <= 1000000; i++)
 {
    if (myList.Count() == 0) x = i; 
 }
 watch.Stop();

 Stopwatch watch2 = new Stopwatch();

 watch2.Start();
 for (var i = 0; i <= 1000000; i++)
 {
     if (!myList.Any()) x = i;
 }
 watch2.Stop();

 Console.WriteLine("myList.Count() = " + watch.ElapsedMilliseconds.ToString());
 Console.WriteLine("myList.Any() = " + watch2.ElapsedMilliseconds.ToString());
 Console.ReadLine();

Второй почти в три раза медленнее :)

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

Думаю, это зависит от типа списка, который вы используете!

(Чтобы отметить, я поместил 2000+ объектов в список, и счет был еще быстрее, в отличие от других типов)

List.Countравно O (1) согласно документации Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

так что просто используйте List.Count == 0его намного быстрее, чем запрос

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

Второй вариант будет намного быстрее, если у вас несколько предметов.

• Any() возвращается, как только будет найден 1 предмет.
• Count() должен продолжать просматривать весь список.

Например, предположим, что в перечислении было 1000 элементов.

• Any() проверит первый, а затем вернет true.
• Count() вернет 1000 после прохождения всего перечисления.

Это потенциально хуже, если вы используете одно из переопределений предиката - Count () все равно должен проверять каждый элемент, даже если есть только одно совпадение.

Вы привыкаете использовать Any one - он имеет смысл и удобочитаем.

Одно предостережение - если у вас есть List, а не просто IEnumerable, используйте свойство Count этого списка.

@Konrad меня удивляет то, что в своих тестах я передаю список в метод, который принимает IEnumerable<T>, поэтому среда выполнения не может оптимизировать его, вызывая метод расширения Count () для IList<T>.

Я могу только предположить, что метод расширения Count () для IEnumerable делает что-то вроде этого:

public static int Count<T>(this IEnumerable<T> list)
{
    if (list is IList<T>) return ((IList<T>)list).Count;

    int i = 0;
    foreach (var t in list) i++;
    return i;
}

... другими словами, небольшая оптимизация времени выполнения для особого случая IList<T> .

/ EDIT @Konrad +1 приятель - вы правы, скорее всего, он включен ICollection<T>.

Хорошо, а что насчет этого?

public static bool IsEmpty<T>(this IEnumerable<T> enumerable)
{
    return !enumerable.GetEnumerator().MoveNext();
}

РЕДАКТИРОВАТЬ: Я только что понял, что кто-то уже набросал это решение. Было упомянуто, что это сделает метод Any (), но почему бы не сделать это самому? С уважением

Еще одна идея:

if(enumerable.FirstOrDefault() != null)

Однако мне больше нравится подход Any ().

Это было критически важно, чтобы заставить это работать с Entity Framework:

var genericCollection = list as ICollection<T>;

if (genericCollection != null)
{
   //your code 
}

Если я проверяю с помощью Count (), Linq выполняет «SELECT COUNT (*) ..» в базе данных, но мне нужно проверить, содержат ли результаты данные, я решил ввести FirstOrDefault () вместо Count ();

Перед

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>()

if (cfop.Count() > 0)
{
    var itemCfop = cfop.First();
    //....
}

После

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>()

var itemCfop = cfop.FirstOrDefault();

if (itemCfop != null)
{
    //....
}

private bool NullTest<T>(T[] list, string attribute)

    {
        bool status = false;
        if (list != null)
        {
            int flag = 0;
            var property = GetProperty(list.FirstOrDefault(), attribute);
            foreach (T obj in list)
            {
                if (property.GetValue(obj, null) == null)
                    flag++;
            }
            status = flag == 0 ? true : false;
        }
        return status;
    }


public PropertyInfo GetProperty<T>(T obj, string str)

    {
        Expression<Func<T, string, PropertyInfo>> GetProperty = (TypeObj, Column) => TypeObj.GetType().GetProperty(TypeObj
            .GetType().GetProperties().ToList()
            .Find(property => property.Name
            .ToLower() == Column
            .ToLower()).Name.ToString());
        return GetProperty.Compile()(obj, str);
    }

Вот моя реализация ответа Дэна Тао с учетом предиката:

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null) throw new ArgumentNullException();
    if (IsCollectionAndEmpty(source)) return true;
    return !source.Any(predicate);
}

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source)
{
    if (source == null) throw new ArgumentNullException();
    if (IsCollectionAndEmpty(source)) return true;
    return !source.Any();
}

private static bool IsCollectionAndEmpty<TSource>(IEnumerable<TSource> source)
{
    var genericCollection = source as ICollection<TSource>;
    if (genericCollection != null) return genericCollection.Count == 0;
    var nonGenericCollection = source as ICollection;
    if (nonGenericCollection != null) return nonGenericCollection.Count == 0;
    return false;
}

List<T> li = new List<T>();
(li.First().DefaultValue.HasValue) ? string.Format("{0:yyyy/MM/dd}", sender.First().DefaultValue.Value) : string.Empty;

myList.ToList().Count == 0, Вот и все

У меня работает этот метод расширения:

public static bool IsEmpty<T>(this IEnumerable<T> enumerable)
{
    try
    {
        enumerable.First();
        return false;
    }
    catch (InvalidOperationException)
    {
        return true;
    }
}