Bagaimana memeriksa apakah IEnumerable adalah nol atau kosong?

Saya suka string.IsNullOrEmptymetode. Saya ingin memiliki sesuatu yang memungkinkan fungsi yang sama untuk IEnumerable. Apakah ada? Mungkin beberapa kelas penolong koleksi? Alasan saya bertanya adalah bahwa dalam ifpernyataan kode terlihat berantakan jika derai itu (mylist != null && mylist.Any()). Akan jauh lebih bersih untuk dimiliki Foo.IsAny(myList).

Posting ini tidak memberikan jawaban itu: IEnumerable kosong? .

Tentu Anda bisa menulis itu:

public static class Utils {
    public static bool IsAny<T>(this IEnumerable<T> data) {
        return data != null && data.Any();
    }
}

Namun, berhati-hatilah agar tidak semua urutan dapat diulang; umumnya saya lebih suka hanya berjalan sekali, untuk berjaga-jaga.

public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable) {
    return enumerable == null || !enumerable.Any();
}

Inilah versi modifikasi dari jawaban bermanfaat @Matt Greer yang menyertakan kelas pembungkus statis sehingga Anda bisa menyalinnya ke file sumber baru, tidak bergantung pada Linq, dan menambahkan generik IEnumerable<T> overload , untuk menghindari tinju tipe nilai itu akan terjadi dengan versi non-generik. [EDIT: Perhatikan bahwa penggunaan IEnumerable<T>tidak mencegah tinju pencacah, pengetikan bebek tidak dapat mencegah hal itu, tetapi setidaknya elemen dalam koleksi yang diketik nilai tidak masing-masing akan dikotakkan.]

using System.Collections;
using System.Collections.Generic;

public static class IsNullOrEmptyExtension
{
    public static bool IsNullOrEmpty(this IEnumerable source)
    {
        if (source != null)
        {
            foreach (object obj in source)
            {
                return false;
            }
        }
        return true;
    }

    public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)
    {
        if (source != null)
        {
            foreach (T obj in source)
            {
                return false;
            }
        }
        return true;
    }
}

Cara lain adalah dengan mendapatkan Enumerator dan memanggil metode MoveNext () untuk melihat apakah ada item:

if (mylist != null && mylist.GetEnumerator().MoveNext())
{
    // The list is not null or empty
}

Ini berfungsi untuk IEnumerable dan juga IEnumerable <T>.

Cara saya melakukannya, memanfaatkan beberapa fitur C # modern:

Pilihan 1)

public static class Utils {
    public static bool IsNullOrEmpty<T>(this IEnumerable<T> list) {
        return !(list?.Any() ?? false);
    }
}

Pilihan 2)

public static class Utils {
    public static bool IsNullOrEmpty<T>(this IEnumerable<T> list) {
        return !(list?.Any()).GetValueOrDefault();
    }
}

Dan omong-omong, jangan pernah gunakan Count == 0atau Count() == 0hanya untuk memeriksa apakah koleksi kosong. Selalu gunakan Linq.Any()

Ini bisa membantu

public static bool IsAny<T>(this IEnumerable<T> enumerable)
{
    return enumerable?.Any() == true;
}

public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable)
{
    return enumerable?.Any() != true;
}

Dimulai dengan C # 6 Anda dapat menggunakan propagasi nol :myList?.Any() == true

Jika Anda masih menemukan ini terlalu tersumbat atau lebih suka metode ekstensi yang baik, saya akan merekomendasikan jawaban Matt Greer dan Marc Gravell, namun dengan sedikit fungsionalitas tambahan untuk kelengkapan.

Jawaban mereka menyediakan fungsionalitas dasar yang sama, tetapi masing-masing dari perspektif lain. Jawaban Matt menggunakan string.IsNullOrEmpty-mentality, sedangkan jawaban Marc mengambil .Any()jalan Linq untuk menyelesaikan pekerjaan.

Saya pribadi cenderung menggunakan .Any()jalan, tetapi ingin menambahkan fungsionalitas pengecekan kondisi dari kelebihan metode lainnya :

    public static bool AnyNotNull<T>(this IEnumerable<T> source, Func<T, bool> predicate = null)
    {
        if (source == null) return false;
        return predicate == null
            ? source.Any()
            : source.Any(predicate);
    }

Jadi Anda masih bisa melakukan hal-hal seperti: myList.AnyNotNull(item=>item.AnswerToLife == 42);seperti yang Anda bisa dengan reguler .Any()tetapi dengan cek nol ditambahkan

Perhatikan bahwa dengan cara C # 6: myList?.Any()mengembalikan a bool?daripada a bool, yang merupakan efek sebenarnya dari propagasi nol

if (collection?.Any() == true){
    // if collection contains more than one item
}
if (collection?.Any() != true){
    // if collection is null
    // if collection does not contain any item
}

Berikut kode dari jawaban Marc Gravell , bersama dengan contoh menggunakannya.

using System;
using System.Collections.Generic;
using System.Linq;

public static class Utils
{
    public static bool IsAny<T>(this IEnumerable<T> data)
    {
        return data != null && data.Any();
    }
}

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<string> items;
        //items = null;
        //items = new String[0];
        items = new String[] { "foo", "bar", "baz" };

        /*** Example Starts Here ***/
        if (items.IsAny())
        {
            foreach (var item in items)
            {
                Console.WriteLine(item);
            }
        }
        else
        {
            Console.WriteLine("No items.");
        }
    }
}

Seperti yang dia katakan, tidak semua urutan dapat diulang, sehingga kode kadang-kadang dapat menyebabkan masalah, karena IsAny()mulai melangkah melalui urutan. Saya menduga apa maksud jawaban Robert Harvey adalah bahwa Anda sering tidak perlu memeriksa null dan mengosongkan. Seringkali, Anda dapat memeriksa null dan kemudian menggunakannya foreach.

Untuk menghindari memulai urutan dua kali dan memanfaatkan foreach, saya hanya menulis beberapa kode seperti ini:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<string> items;
        //items = null;
        //items = new String[0];
        items = new String[] { "foo", "bar", "baz" };

        /*** Example Starts Here ***/
        bool isEmpty = true;
        if (items != null)
        {
            foreach (var item in items)
            {
                isEmpty = false;
                Console.WriteLine(item);
            }
        }
        if (isEmpty)
        {
            Console.WriteLine("No items.");
        }
    }
}

Saya kira metode ekstensi menghemat beberapa baris pengetikan, tetapi kode ini tampaknya lebih jelas bagi saya. Saya menduga bahwa beberapa pengembang tidak akan segera menyadari bahwa IsAny(items)sebenarnya akan mulai melangkah melalui urutan. (Tentu saja jika Anda menggunakan banyak urutan, Anda dengan cepat belajar untuk memikirkan langkah apa yang melaluinya.)

Saya menggunakan Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);. Semoga ini membantu.

Kerusakan:

Collection?.Any()akan kembali nulljika Koleksi adalah nol, dan falsejika Koleksi kosong.

Collection?.Any()??falseakan memberi kita falsejika Koleksi kosong, dan falsejika Koleksi adalah null.

Pelengkap itu akan memberi kita IsEmptyOrNull.

Anwser Jon Skeet ( https://stackoverflow.com/a/28904021/8207463 ) memiliki pendekatan yang baik menggunakan Metode Extension - Any () untuk NULL dan KOSONG. TETAPI dia memvalidasi pemilik pertanyaan untuk TIDAK NULL. Jadi hati-hati ubah pendekatan Jon untuk memvalidasi AS NULL ke:

If (yourList?.Any() != true) 
{
     ..your code...
}

JANGAN gunakan (tidak akan divalidasi SEBAGAI NULL):

If (yourList?.Any() == false) 
{
     ..your code...
}

Anda juga dapat dalam kasus memvalidasi SEBAGAI TIDAK NULL (TIDAK diuji hanya sebagai contoh tetapi tanpa kesalahan kompiler) melakukan sesuatu seperti menggunakan predikat:

If (yourList?.Any(p => p.anyItem == null) == true) 
{
     ..your code...
}

https://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs,8788153112b7ffd0

Untuk versi .NET yang dapat Anda gunakan, periksa:

https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.any?view=netframework-4.8#moniker-applies-to

Saya memiliki masalah yang sama dan saya menyelesaikannya seperti:

    public bool HasMember(IEnumerable<TEntity> Dataset)
    {
        return Dataset != null && Dataset.Any(c=>c!=null);
    }

"c => c! = null" akan mengabaikan semua entitas nol.

Saya membangun ini dari jawaban oleh @Matt Greer

Dia menjawab pertanyaan OP dengan sempurna.

Saya menginginkan sesuatu seperti ini sambil mempertahankan kemampuan asli Any sembari memeriksa nol. Saya memposting ini kalau-kalau ada yang membutuhkan sesuatu yang serupa.

Secara khusus saya ingin tetap bisa lulus dalam predikat.

public static class Utilities
{
    /// <summary>
    /// Determines whether a sequence has a value and contains any elements.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <param name="source">The <see cref="System.Collections.Generic.IEnumerable"/> to check for emptiness.</param>
    /// <returns>true if the source sequence is not null and contains any elements; otherwise, false.</returns>
    public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source)
    {
        return source?.Any() == true;
    }

    /// <summary>
    /// Determines whether a sequence has a value and any element of a sequence satisfies a condition.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <param name="source">An <see cref="System.Collections.Generic.IEnumerable"/> whose elements to apply the predicate to.</param>
    /// <param name="predicate">A function to test each element for a condition.</param>
    /// <returns>true if the source sequence is not null and any elements in the source sequence pass the test in the specified predicate; otherwise, false.</returns>
    public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
    {
        return source?.Any(predicate) == true;
    }
}

Penamaan metode ekstensi mungkin bisa lebih baik.

Solusi terbaik lain seperti di bawah ini untuk mengecek kosong atau tidak?

for(var item in listEnumerable)
{
 var count=item.Length;
  if(count>0)
  {
         // not empty or null
   }
  else
  {
       // empty
  }
}

Saya menggunakan ini:

    public static bool IsNotEmpty(this ICollection elements)
    {
        return elements != null && elements.Count > 0;
    }

Ejem:

List<string> Things = null;
if (Things.IsNotEmpty())
{
    //replaces ->  if (Things != null && Things.Count > 0) 
}

Karena beberapa sumber daya habis setelah dibaca, saya pikir mengapa tidak menggabungkan cek dan bacaan, alih-alih cek terpisah tradisional, lalu membaca.

Pertama, kami memiliki satu untuk ekstensi inline nol-sederhana yang lebih sederhana:

public static System.Collections.Generic.IEnumerable<T> ThrowOnNull<T>(this System.Collections.Generic.IEnumerable<T> source, string paramName = null) => source ?? throw new System.ArgumentNullException(paramName ?? nameof(source));

var first = source.ThrowOnNull().First();

Kemudian kita memiliki sedikit lebih banyak terlibat (well, setidaknya cara saya menulisnya) check-for-null-and-empty inline extension:

public static System.Collections.Generic.IEnumerable<T> ThrowOnNullOrEmpty<T>(this System.Collections.Generic.IEnumerable<T> source, string paramName = null)
{
  using (var e = source.ThrowOnNull(paramName).GetEnumerator())
  {
    if (!e.MoveNext())
    {
      throw new System.ArgumentException(@"The sequence is empty.", paramName ?? nameof(source));
    }

    do
    {
      yield return e.Current;
    }
    while (e.MoveNext());
  }
}

var first = source.ThrowOnNullOrEmpty().First();

Anda tentu saja masih dapat memanggil keduanya tanpa melanjutkan rantai panggilan. Juga, saya menyertakan paramName, sehingga pemanggil dapat menyertakan nama alternatif untuk kesalahan jika tidak "sumber" diperiksa, misalnya "nameof (target)".

 public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source)
    {
        return source != null && source.Any();
    }

metode ekstensi saya sendiri untuk memeriksa Tidak null dan Apa pun

Tanpa pembantu kustom saya sarankan salah satu ?.Any() ?? falseatau ?.Any() == trueyang relatif singkat dan hanya perlu menentukan urutannya sekali.

Ketika saya ingin memperlakukan koleksi yang hilang seperti yang kosong, saya menggunakan metode ekstensi berikut:

public static IEnumerable<T> OrEmpty<T>(this IEnumerable<T> sequence)
{
    return sequence ?? Enumerable.Empty<T>();
}

Fungsi ini dapat dikombinasikan dengan semua metode LINQ dan foreach, bukan hanya .Any(), itulah sebabnya saya lebih suka daripada fungsi pembantu yang lebih khusus yang diusulkan orang di sini.

saya menggunakan

    list.Where (r=>r.value == value).DefaultIfEmpty().First()

Hasilnya akan nol jika tidak cocok, jika tidak mengembalikan salah satu objek

Jika Anda menginginkan daftar tersebut, saya yakin meninggalkan First () atau memanggil ToList () akan memberikan daftar atau nol.

Lihatlah perpustakaan opensource ini: Nzr.ToolBox

public static bool IsEmpty(this System.Collections.IEnumerable enumerable)

cukup tambahkan using System.Linqdan lihat keajaiban yang terjadi ketika Anda mencoba mengakses metode yang tersedia di IEnumerable. Menambahkan ini akan memberi Anda akses ke metode bernama Count()sesederhana itu. hanya ingat untuk memeriksa null valuesebelum menelepon count():)

Saya menggunakan sederhana jika untuk memeriksanya

lihat solusi saya

foreach (Pet pet in v.Pets)
{
    if (pet == null)
    {
        Console.WriteLine(" No pet");// enumerator is empty
        break;
    }
    Console.WriteLine("  {0}", pet.Name);
}