如何检查 IEnumerable 是否为 null 或为空？

Question

我喜欢 string.IsNullOrEmpty 方法。我希望有一些东西可以为 IEnumerable 提供相同的功能。有这样的吗？也许是一些集合助手类？我问的原因是，在 if 语句中，如果模式是 (mylist != null && mylist.Any())，代码看起来会很混乱。使用 Foo.IsAny(myList) 会更干净。

这篇文章没有给出这个答案：IEnumerable 是空的？。

Answer 1

当然，您可以这样写：

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

但是，请注意并非所有序列都是可重复的； 通常我宁愿只走一次，以防万一。

Answer 2

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

Answer 3

这是 @Matt Greer 的有用答案的修改版本，其中包含一个静态包装类，因此您只需将其复制粘贴到新的源文件中，不依赖于 Linq，并添加一个通用的 IEnumerable重载，以避免非泛型版本中发生的值类型装箱。 [编辑：请注意，使用 IEnumerable 不会阻止枚举器装箱，鸭子类型 无法阻止这种情况，但至少值类型集合中的元素不会被装箱。]

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

Answer 4

if (collection?.Any() == true)
{
    // if collection contains one or more items
}
if (collection?.Any() != true) // note == false won't work
{
    // if collection is null
    // if collection does not contain any item
}

Answer 5

另一种方法是获取 Enumerator 并调用 MoveNext() 方法来查看是否有任何项目：

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

这适用于 IEnumerable 以及 IEnumerable。

Answer 6

我这样做的方式是利用一些现代 C# 功能：

选项 1)

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

选项 2)

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

顺便说一下，永远不要使用 Count == 0 或 Count() == 0 code> 只是检查集合是否为空。始终使用 Linq 的 .Any()

Answer 7

从 C#6 开始，您可以使用 空传播< /a>: myList?.Any() == true

如果您仍然觉得这太堵塞或者更喜欢好的 ol' 扩展方法，我会推荐 Matt Greer 和 Marc Gravell 的答案，但有一点扩展功能的完整性。

他们的答案提供了相同的基本功能，但各自从不同的角度来看。马特的答案使用 string.IsNullOrEmpty-心态，而 Marc 的答案则采用 Linq 的 .Any() 方式来完成工作。

我个人倾向于使用 。 Any() 道路，但希望从该方法的 其他重载：

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

因此您仍然可以执行以下操作：
myList.AnyNotNull(item=>item.AnswerToLife == 42); 就像使用常规 .Any() 一样，但添加了 null 检查

请注意，使用C#6方式：myList?.Any()返回的是bool?而不是bool，这是的实际效果传播 null

Answer 8

这可能有帮助

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

Answer 9

当涉及引用（可为空）类型并且项目中不存在空项目时，可以使用这一行进行验证

myCollection?.FirstOrDefault() == null

Answer 10

Jon Skeet 的 anwser (https://stackoverflow.com/a/28904021/8207463) 有一个使用扩展方法的好方法 - Any() 表示 NULL 和 EMPTY。但他正在验证问题的所有者以防 NOT NULL。
因此，请小心地将 Jon 验证 AS NULL 的方法更改为：

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

请勿使用（不会验证 AS NULL）：

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

您还可以在验证 AS NOT NULL 的情况下（未作为示例进行测试，但没有编译器错误）执行类似于使用谓词的操作：

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

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

对于您可以使用的 .NET 版本，请检查：

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

Answer 11

以下是 Marc Gravell 的回答中的代码，以及使用它的示例。

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

正如他所说，并非所有序列都是可重复的，因此代码有时可能会导致问题，因为 IsAny() 开始逐步执​​行序列。我怀疑 Robert Harvey 的回答 的意思是您通常不需要检查 null 和空。通常，您可以只检查 null，然后使用 foreach。

为了避免启动序列两次并利用 foreach，我只编写了一些如下代码：

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

我猜扩展方法可以为您节省几行输入，但这段代码对我来说似乎更清晰。我怀疑一些开发人员不会立即意识到 IsAny(items) 实际上会开始逐步执​​行该序列。 （当然，如果您使用大量序列，您很快就会学会思考其中的步骤。）

Answer 12

我使用 Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);。希望这有帮助。

细分：

如果 Collection 为 null，则 Collection?.Any() 将返回 null；如果 Collection 为空，则返回 false。

如果 Collection 为空，Collection?.Any()??false 将为我们提供 false；如果 Collection 为 null，则为 false代码>.

对此的补充将为我们提供 IsEmptyOrNull。

Answer 13

我遇到了同样的问题，我解决它的方式如下：

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

“c=>c!=null”将忽略所有空实体。

Answer 14

我是根据@Matt Greer的回答构建的，

他完美地回答了OP的问题。

我想要这样的东西，同时保持 Any 的原始功能，同时检查 null 。我发布这个以防其他人需要类似的东西。

具体来说，我希望仍然能够传递谓词。

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

扩展方法的命名可能会更好。

Answer 15

只需添加 using System.Linq 并在您尝试访问 IEnumerable 中的可用方法时看到奇迹发生。添加它将使您能够访问名为 Count() 的方法，就这么简单。只需记住在调用 count() 之前检查 null 值 :)

Answer 16

我使用简单的 if 来检查它，

看看我的解决方案

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

Answer 17

下面的另一个最佳解决方案来检查是否为空？

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

Answer 18

我用的是这个：

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

Answer 19

由于有些资源读完就耗尽了，我想为什么不把检查和读结合起来，而不是传统的单独检查，然后读。

首先，我们有一个更简单的 check-for-null 内联扩展：

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

然后我们有更多的参与（嗯，至少是我编写的方式） check-for-null-and-empty 内联扩展：

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

你当然仍然可以调用两者而不继续调用链。另外，我还包含了 paramName，以便调用者可以在未检查“源”的情况下包含错误的备用名称，例如“nameof(target)”。

Answer 20

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

我自己的扩展方法来检查 Not null 和 Any

Answer 21

如果没有自定义助手，我推荐 ?.Any() ?? false 或 ?.Any() == true 比较简洁，只需要指定一次序列。

---

当我想将丢失的集合视为空集合时，我使用以下扩展方法：

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

此函数可以与所有 LINQ 方法和 foreach 结合使用，而不仅仅是 .Any()，这就是为什么我更喜欢它而不是人们在这里提出的更专业的帮助函数。

Answer 22

我使用

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

如果不匹配，结果将为 null，否则返回对象之一

如果您想要列表，我相信离开 First() 或调用 ToList() 将提供列表或 null。

Answer 23

it null 将

enter    public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable)
    {

        try
        {
            return enumerable?.Any() != true;
        }
        catch (Exception)
        {

            return true;
        }
   
    }

在此处返回 true 代码