Làm cách nào để kiểm tra xem IEnumerable là null hay rỗng?

Tôi yêu string.IsNullOrEmptyphương pháp. Tôi muốn có một cái gì đó cho phép chức năng tương tự cho IEnumerable. Có như vậy không? Có lẽ một số lớp người trợ giúp bộ sưu tập? Lý do tôi hỏi là trong các ifcâu lệnh, mã có vẻ lộn xộn nếu patter là (mylist != null && mylist.Any()). Nó sẽ sạch hơn nhiều để có Foo.IsAny(myList).

Bài đăng này không đưa ra câu trả lời: IEnumerable trống? .

Chắc chắn bạn có thể viết rằng:

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

tuy nhiên, hãy thận trọng rằng không phải tất cả các chuỗi đều có thể lặp lại; nói chung tôi thích chỉ đi bộ một lần, trong trường hợp.

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

Đây là phiên bản sửa đổi của câu trả lời hữu ích của @Matt Greer bao gồm lớp trình bao bọc tĩnh để bạn có thể sao chép-dán tệp này vào tệp nguồn mới, không phụ thuộc vào Linq và thêm IEnumerable<T>tình trạng quá tải chung , để tránh các loại giá trị Điều đó sẽ xảy ra với phiên bản không chung chung. [EDIT: Lưu ý rằng việc sử dụng IEnumerable<T>không ngăn cản quyền anh của điều tra viên, gõ vịt không thể ngăn chặn điều đó, nhưng ít nhất các yếu tố trong bộ sưu tập đánh giá trị sẽ không được đóng hộp.]

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

Một cách khác là lấy Trình liệt kê và gọi phương thức MoveNext () để xem có mục nào không:

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

Điều này hoạt động cho IEnumerable cũng như IEnumerable <T>.

Cách tôi làm, tận dụng một số tính năng C # hiện đại:

Lựa chọn 1)

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

Lựa chọn 2)

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

Và nhân tiện, không bao giờ sử dụng Count == 0hoặc Count() == 0chỉ để kiểm tra nếu một bộ sưu tập trống. Luôn luôn sử dụng Linq's.Any()

Điều này có thể giúp

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

Bắt đầu với C # 6, bạn có thể sử dụng tuyên truyền null :myList?.Any() == true

Nếu bạn vẫn thấy điều này quá tắc hoặc thích một phương pháp mở rộng tốt, tôi sẽ đề xuất câu trả lời của Matt Greer và Marc Gravell, nhưng với một chút chức năng mở rộng để hoàn thiện.

Câu trả lời của họ cung cấp các chức năng cơ bản giống nhau, nhưng mỗi người từ một quan điểm khác. Câu trả lời của Matt sử dụng tính string.IsNullOrEmptychất -mentality, trong khi câu trả lời của Marc đưa .Any()con đường của Linq hoàn thành công việc.

Cá nhân tôi có xu hướng sử dụng .Any()đường, nhưng muốn thêm chức năng kiểm tra điều kiện từ tình trạng quá tải khác của phương thức :

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

Vì vậy, bạn vẫn có thể làm những việc như: myList.AnyNotNull(item=>item.AnswerToLife == 42);như bạn có thể với thường xuyên .Any()nhưng với kiểm tra null được thêm vào

Lưu ý rằng với cách C # 6: myList?.Any()trả về một bool?thay vì a bool, đó là hiệu ứng thực tế của việc truyền null

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
}

Đây là mã từ câu trả lời của Marc Gravell , cùng với một ví dụ về việc sử dụng nó.

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

Như ông nói, không phải tất cả các chuỗi đều có thể lặp lại, do đó mã đôi khi có thể gây ra vấn đề, bởi vì IsAny()bắt đầu bước qua chuỗi. Tôi nghi ngờ câu trả lời của Robert Harvey có nghĩa là bạn thường không cần kiểm tra null và bỏ trống. Thông thường, bạn chỉ có thể kiểm tra null và sau đó sử dụng foreach.

Để tránh bắt đầu chuỗi hai lần và tận dụng foreach, tôi chỉ viết một số mã như thế này:

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

Tôi đoán phương thức mở rộng giúp bạn tiết kiệm một vài dòng gõ, nhưng mã này có vẻ rõ ràng hơn đối với tôi. Tôi nghi ngờ rằng một số nhà phát triển sẽ không ngay lập tức nhận ra rằng IsAny(items)sẽ thực sự bắt đầu bước qua chuỗi. (Tất nhiên nếu bạn đang sử dụng nhiều trình tự, bạn sẽ nhanh chóng học cách suy nghĩ về những bước qua chúng.)

Tôi sử dụng Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);. Hi vọng điêu nay co ich.

Phá vỡ:

Collection?.Any()sẽ trả về nullnếu Bộ sưu tập là null và falsenếu Bộ sưu tập trống.

Collection?.Any()??falsesẽ cung cấp cho chúng tôi falsenếu Bộ sưu tập trống và falsenếu Bộ sưu tập là null.

Bổ sung điều đó sẽ cung cấp cho chúng tôi IsEmptyOrNull.

Anwser của Jon Skeet ( https://stackoverflow.com/a/28904021/8207463 ) có một cách tiếp cận tốt khi sử dụng Phương thức mở rộng - Bất kỳ () cho NULL và EMPTY. NHƯNG anh ấy đã xác nhận các câu hỏi trong trường hợp KHÔNG phải là NULL. Vì vậy, hãy cẩn thận thay đổi cách tiếp cận Jon Jons để xác thực AS NULL thành:

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

KHÔNG sử dụng (sẽ không xác nhận AS NULL):

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

Trong trường hợp bạn cũng có thể xác thực AS KHÔNG NULL (KHÔNG được kiểm tra như ví dụ nhưng không có lỗi trình biên dịch) làm một cái gì đó như sử dụng vị ngữ:

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

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

Đối với phiên bản .NET nào bạn có thể sử dụng, vui lòng kiểm tra:

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

Tôi đã có cùng một vấn đề và tôi giải quyết nó như sau:

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

"c => c! = null" sẽ bỏ qua tất cả các thực thể null.

Tôi đã xây dựng câu trả lời này bởi @Matt Greer

Anh ấy trả lời câu hỏi của OP một cách hoàn hảo.

Tôi muốn một cái gì đó như thế này trong khi duy trì các khả năng ban đầu của Any trong khi cũng kiểm tra null. Tôi đang đăng bài này trong trường hợp bất cứ ai khác cần một cái gì đó tương tự.

Cụ thể tôi muốn vẫn có thể vượt qua trong một vị ngữ.

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

Việc đặt tên của phương thức mở rộng có thể tốt hơn.

Các giải pháp tốt nhất khác như dưới đây để kiểm tra trống hay không?

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

Tôi sử dụng cái này:

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

Vì một số tài nguyên đã cạn kiệt sau một lần đọc, tôi nghĩ tại sao không kết hợp giữa kiểm tra và đọc, thay vì kiểm tra riêng biệt truyền thống, sau đó đọc.

Đầu tiên chúng ta có một phần mở rộng nội tuyến check-for-null đơn giản hơn:

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

Sau đó, chúng tôi có thêm một chút liên quan (ít nhất là cách tôi đã viết nó) kiểm tra phần mở rộng nội tuyến rỗng-và-rỗng:

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

Tất nhiên bạn vẫn có thể gọi cả hai mà không cần tiếp tục chuỗi cuộc gọi. Ngoài ra, tôi đã bao gồm paramName, để người gọi có thể bao gồm một tên thay thế cho lỗi nếu đó không phải là "nguồn" đang được kiểm tra, ví dụ "nameof (đích)".

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

phương pháp mở rộng của riêng tôi để kiểm tra Không null và Bất kỳ

Nếu không có người trợ giúp tùy chỉnh, tôi khuyên bạn nên ?.Any() ?? falsehoặc ?.Any() == truetương đối ngắn gọn và chỉ cần xác định trình tự một lần.

Khi tôi muốn xử lý một bộ sưu tập bị thiếu như một bộ trống, tôi sử dụng phương pháp mở rộng sau:

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

Hàm này có thể được kết hợp với tất cả các phương thức LINQ và foreach, không chỉ .Any(), đó là lý do tại sao tôi thích nó hơn các hàm trợ giúp chuyên biệt hơn mà mọi người đang đề xuất ở đây.

tôi sử dụng

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

Kết quả sẽ là null nếu không khớp, nếu không thì trả về một trong các đối tượng

Nếu bạn muốn danh sách, tôi tin rằng việc rời First () hoặc gọi ToList () sẽ cung cấp danh sách hoặc null.

Hãy xem thư viện mã nguồn mở này: Nzr.ToolBox

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

chỉ cần thêm using System.Linqvà xem điều kỳ diệu xảy ra khi bạn cố gắng truy cập các phương thức có sẵn trong IEnumerable. Thêm điều này sẽ cung cấp cho bạn quyền truy cập vào phương thức có tên Count()đơn giản như vậy. chỉ cần nhớ kiểm tra null valuetrước khi gọi count():)

Tôi đã sử dụng đơn giản nếu để kiểm tra nó

kiểm tra giải pháp của tôi

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