Memeriksa apakah daftar kosong dengan LINQ

Apa cara "terbaik" (dengan mempertimbangkan kecepatan dan keterbacaan) untuk menentukan apakah sebuah daftar kosong? Meskipun daftarnya berjenis IEnumerable<T>dan tidak memiliki properti Hitungan.

Saat ini saya sedang memikirkan di antara ini:

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

dan ini:

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

Dugaan saya adalah bahwa opsi kedua lebih cepat, karena akan kembali dengan hasil segera setelah melihat item pertama, sedangkan opsi kedua (untuk IEnumerable) perlu mengunjungi setiap item untuk mengembalikan hitungan.

Karena itu, apakah opsi kedua terlihat dapat dibaca oleh Anda? Mana yang lebih kamu sukai? Atau dapatkah Anda memikirkan cara yang lebih baik untuk menguji daftar kosong?

Respons edit @ lassevk tampaknya yang paling logis, ditambah dengan sedikit pemeriksaan waktu proses untuk menggunakan jumlah cache jika memungkinkan, seperti ini:

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

    return !list.Any();
}

Anda bisa melakukan ini:

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

Edit : Perhatikan bahwa hanya menggunakan metode .Count akan cepat jika sumber yang mendasarinya sebenarnya memiliki properti Hitungan cepat. Pengoptimalan yang valid di atas adalah dengan mendeteksi beberapa jenis dasar dan cukup menggunakan properti .Count dari keduanya, bukan pendekatan .Any (), tetapi kemudian kembali ke .Any () jika tidak ada jaminan yang dapat dibuat.

Saya akan membuat satu tambahan kecil untuk kode yang tampaknya telah Anda selesaikan: periksa juga ICollection, karena ini diterapkan bahkan oleh beberapa kelas generik yang tidak usang juga (yaitu, Queue<T>dan Stack<T>). Saya juga akan menggunakan asalih-alih iskarena itu lebih idiomatis dan telah terbukti lebih cepat .

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 sendiri harus melakukan beberapa optimasi serius seputar metode Count ().

Apakah ini mengejutkan Anda? Saya membayangkan bahwa untuk IListimplementasi, Countcukup membaca jumlah elemen secara langsung sementara Anyharus menanyakan IEnumerable.GetEnumeratormetode, membuat instance dan memanggil MoveNextsetidaknya sekali.

/ EDIT @Matt:

Saya hanya dapat berasumsi bahwa metode ekstensi Count () untuk IEnumerable melakukan sesuatu seperti ini:

Ya, tentu saja. Ini yang saya maksud. Sebenarnya, ini menggunakan ICollectionalih-alih IListtetapi hasilnya sama.

Saya baru saja menulis tes singkat, coba ini:

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

Yang kedua hampir tiga kali lebih lambat :)

Mencoba uji stopwatch lagi dengan Stack atau array atau skenario lain, itu benar-benar tergantung pada jenis daftar yang terlihat - karena mereka membuktikan Hitungan lebih lambat.

Jadi saya kira itu tergantung pada jenis daftar yang Anda gunakan!

(Sekadar menunjukkan, saya memasukkan 2000+ objek dalam Daftar dan menghitung masih lebih cepat, berlawanan dengan jenis lainnya)

List.Countadalah O (1) menurut dokumentasi Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

jadi gunakan saja List.Count == 0 saja jauh lebih cepat daripada kueri

Ini karena ia memiliki anggota data yang disebut Hitungan yang diperbarui setiap kali ada sesuatu yang ditambahkan atau dihapus dari daftar, jadi ketika Anda memanggilnya List.Counttidak harus mengulang melalui setiap elemen untuk mendapatkannya, ia hanya mengembalikan anggota data.

Opsi kedua jauh lebih cepat jika Anda memiliki banyak item.

• Any() kembali segera setelah 1 item ditemukan.
• Count() harus terus menelusuri seluruh daftar.

Misalkan pencacahan memiliki 1000 item.

• Any() akan memeriksa yang pertama, lalu mengembalikan true.
• Count() akan mengembalikan 1000 setelah melewati seluruh pencacahan.

Ini berpotensi lebih buruk jika Anda menggunakan salah satu dari predicate overrides - Count () masih harus memeriksa setiap item, meskipun hanya ada satu yang cocok.

Anda terbiasa menggunakan Apa saja - ini masuk akal dan dapat dibaca.

Satu peringatan - jika Anda memiliki Daftar, bukan hanya IEnumerable, gunakan properti Hitung daftar itu.

@Konrad yang mengejutkan saya adalah bahwa dalam pengujian saya, saya meneruskan daftar ke metode yang menerima IEnumerable<T>, sehingga runtime tidak dapat mengoptimalkannya dengan memanggil metode ekstensi Count () untuk IList<T>.

Saya hanya dapat berasumsi bahwa metode ekstensi Count () untuk IEnumerable melakukan sesuatu seperti ini:

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

... dengan kata lain, sedikit pengoptimalan waktu proses untuk kasus khusus IList<T>.

/ EDIT @Konrad +1 sobat - Anda benar tentang hal itu kemungkinan besar ada di ICollection<T>.

Oke, jadi bagaimana dengan yang ini?

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

EDIT: Saya baru saja menyadari bahwa seseorang telah membuat sketsa solusi ini. Telah disebutkan bahwa metode Any () akan melakukan ini, tetapi mengapa tidak melakukannya sendiri? Salam

Ide lain:

if(enumerable.FirstOrDefault() != null)

Namun saya lebih suka pendekatan Any ().

Ini sangat penting agar ini berfungsi dengan Entity Framework:

var genericCollection = list as ICollection<T>;

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

Jika saya memeriksa dengan Count () Linq mengeksekusi "SELECT COUNT (*) .." dalam database, tetapi saya perlu memeriksa apakah hasilnya berisi data, saya memutuskan untuk memperkenalkan FirstOrDefault () daripada Count ();

Sebelum

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

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

Setelah

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

Inilah implementasi saya atas jawaban Dan Tao, memungkinkan untuk sebuah predikat:

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. Itu saja

Metode ekstensi ini berfungsi untuk saya:

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