LINQ ile bir listenin boş olup olmadığını kontrol etme

Bir listenin boş olup olmadığını belirlemenin "en iyi" (hem hızı hem de okunabilirliği hesaba katarak) yolu nedir? Liste türü olsa IEnumerable<T>ve Count özelliği olmasa bile.

Şu anda bunun arasında gidip geliyorum:

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

ve bu:

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

Tahminimce, ikinci seçenek daha hızlıdır, çünkü ilk öğeyi görür görmez bir sonuçla geri dönecektir, oysa ikinci seçeneğin (bir IEnumerable için) sayımı döndürmek için her öğeyi ziyaret etmesi gerekecektir.

Bununla birlikte, ikinci seçenek size okunabilir mi görünüyor? Hangisini tercih edersin? Veya boş bir listeyi test etmenin daha iyi bir yolunu düşünebilir misiniz?

Edit @ lassevk'in yanıtı en mantıklı gibi görünüyor, mümkünse önbelleğe alınmış bir sayımı kullanmak için biraz çalışma zamanı kontrolü ile birleştiğinde, şöyle:

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

    return !list.Any();
}

Bunu yapabilirsin:

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

Düzenleme : Temel alınan kaynak gerçekten hızlı bir Count özelliğine sahipse, .Count yöntemini kullanmanın hızlı olacağını unutmayın. Yukarıdaki geçerli bir optimizasyon, birkaç temel türü tespit etmek ve .Any () yaklaşımı yerine bunların .Count özelliğini kullanmak, ancak daha sonra garanti verilemezse .Any () 'ye geri dönmek olacaktır.

Koda karar verdiğinize dair küçük bir ekleme yapacağım: ayrıca kontrol edin ICollection, çünkü bu bazı eski olmayan jenerik sınıflar tarafından da uygulanıyor (yani, Queue<T>ve Stack<T>). Daha deyimsel olduğu ve daha hızlı olduğu görüldüğü içinas bunun yerine de kullanırdım .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'nun kendisi bir şekilde Count () yöntemi etrafında ciddi bir optimizasyon yapıyor olmalıdır.

Bu seni şaşırttı mı? Ben hayal IListuygulamaları, Countsadece doğrudan ederken elemanların sayısını okur Anysorgulamak zorundadır IEnumerable.GetEnumeratorörneği ve görüşmesi oluşturursa yöntemiMoveNext kez en azından.

/ EDIT @Matt:

Yalnızca IEnumerable için Count () uzantı yönteminin şöyle bir şey yaptığını varsayabilirim:

Evet, tabii ki öyle. Demek istediğim bu. Aslında ICollectionyerine kullanıyor IListama sonuç aynı.

Hızlı bir test yazdım, şunu dene:

 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();

İkincisi neredeyse üç kat daha yavaş :)

Kronometre testini bir Yığın veya dizi veya diğer senaryolarla tekrar denemek, gerçekten göründüğü listenin türüne bağlıdır - çünkü Saymanın daha yavaş olduğunu kanıtlarlar.

Sanırım bu, kullandığınız listenin türüne bağlı!

(Sadece belirtmek için Listeye 2000'den fazla nesne koydum ve sayım diğer türlerin aksine daha hızlıydı)

List.CountMicrosoft'un belgelerine göre O (1):
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

bu yüzden sadece kullan List.Count == 0 bir sorgudan çok daha hızlı

Bunun nedeni, listeye bir şey eklendiğinde veya listeden her kaldırıldığında güncellenen Count adında bir veri üyesine sahip olmasıdır, bu nedenle aradığınızda List.Count, onu almak için her öğeyi yinelemek zorunda kalmaz, yalnızca veri üyesini döndürür.

Birden çok öğeniz varsa ikinci seçenek çok daha hızlıdır.

• Any() 1 öğe bulunduğunda geri döner.
• Count() tüm listeyi gözden geçirmeye devam etmelidir.

Örneğin, numaralandırmanın 1000 maddeye sahip olduğunu varsayalım.

• Any() ilkini kontrol eder, sonra doğruya döner.
• Count() tüm numaralandırmayı geçtikten sonra 1000 döndürür.

Koşul geçersiz kılmalarından birini kullanırsanız, bu potansiyel olarak daha kötüdür - Count (), yalnızca bir eşleşme olsa bile her bir öğeyi kontrol etmek zorundadır.

Herhangi birini kullanmaya alışırsınız - mantıklı ve okunabilir.

Bir uyarı - sadece bir IEnumerable yerine bir Listeniz varsa, o listenin Count özelliğini kullanın.

@Konrad beni şaşırtan şey, testlerimde listeyi kabul eden bir yönteme geçiriyorum IEnumerable<T>, böylece çalışma zamanı Count () uzantı yöntemini çağırarak onu optimize edemez IList<T>.

Yalnızca IEnumerable için Count () uzantı yönteminin şöyle bir şey yaptığını varsayabilirim:

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;
}

... başka bir deyişle, özel durum için biraz çalışma zamanı optimizasyonu IList<T> .

/ EDIT @Konrad +1 mat - haklısınız daha büyük olasılıkla ICollection<T> .

Tamam, peki ya bu?

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

DÜZENLEME: Birisinin bu çözümü zaten çizdiğini fark ettim. Any () yönteminin bunu yapacağından bahsedildi, ancak neden kendiniz yapmıyorsunuz? Saygılarımızla

Diğer bir fikir:

if(enumerable.FirstOrDefault() != null)

Ancak Any () yaklaşımını daha çok seviyorum.

Bu, Entity Framework ile çalışmasını sağlamak için kritikti:

var genericCollection = list as ICollection<T>;

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

Count () Linq ile kontrol edersem, veritabanında bir "SELECT COUNT (*) .." çalıştırır, ancak sonuçların veri içerip içermediğini kontrol etmem gerekir, Count () yerine FirstOrDefault () kullanmaya karar verdim;

Önce

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

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

Sonra

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);
    }

İşte benim Dan Tao'nun cevabını uyguladığım, bir dayanağa izin veren:

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. Bu kadar

Bu uzantı yöntemi benim için çalışıyor:

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