Перевірка, чи список порожній за допомогою LINQ

Який "найкращий" (враховуючи швидкість і читабельність) спосіб визначити, чи список порожній? Навіть якщо список має тип IEnumerable<T>і не має властивості Count.

Зараз я кидаюся між цим:

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

і це:

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

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

Як сказано, другий варіант виглядає як читабельний для вас? Якому б ви віддали перевагу? Або ви можете придумати кращий спосіб перевірити наявність порожнього списку?

Відповідь редагування @ 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 буде швидким, якщо базове джерело насправді має властивість швидкого підрахунку. Дійсною оптимізацією, описаною вище, було б виявити кілька базових типів і просто використовувати властивість .Count з них замість підходу .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хоча б один раз.

/ EDIT @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();

Другий майже втричі повільніше :)

Повторне спробу тестування секундоміра за допомогою стека чи масиву чи інших сценаріїв, це дійсно залежить від типу списку, який здається - адже вони виявляють, що кількість рахунків повільніше.

Тож я думаю, це залежить від типу списку, який ви використовуєте!

(Тільки для того, щоб зазначити, я помістив до списку 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() перевірив би перший, а потім поверне справжній.
• Count() поверне 1000 після проходження всього перерахунку.

Це потенційно гірше, якщо ви використовуєте одне з переваг предикатів - Count () все одно повинен перевіряти кожен окремий елемент, навіть якщо це лише одна відповідність.

Ви звикаєте до використання будь-якого - це має сенс і читається.

Одне застереження - якщо у вас є Список, а не просто 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();
}

EDIT: Я щойно зрозумів, що хтось уже замальовував це рішення. Згадувалося, що метод Any () зробить це, але чому б не зробити цього самостійно? З повагою

Ще одна ідея:

if(enumerable.FirstOrDefault() != null)

Однак мені більше подобається будь-який () підхід.

Це було надзвичайно важливим для того, щоб це працювало з 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;
    }
}