使用LINQ检查列表是否为空

确定列表是否为空的“最佳”方式（兼顾速度和可读性）是什么？即使列表是类型IEnumerable<T>并且没有Count属性。

现在，我在这之间折腾：

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

还有这个：

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

我的猜测是第二个选项更快，因为它会在看到第一个项目后立即返回结果，而第二个选项（对于IEnumerable）将需要访问每个项目以返回计数。

话虽这么说，第二种选择对您来说可读吗？你更喜欢哪个？还是您可以想到一种更好的方法来测试空列表？

Edit @lassevk的响应似乎是最合乎逻辑的，再加上一些运行时检查，以便在可能的情况下使用缓存的计数，如下所示：

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

    return !list.Any();
}

您可以这样做：

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

编辑：请注意，如果基础源实际上具有快速的Count属性，则仅使用.Count方法将很快。上面的有效优化将是检测一些基本类型，并简单地使用这些基本类型的.Count属性，而不是.Any（）方法，但是如果无法保证，则退回到.Any（）。

我将对您似乎已定下的代码进行一些补充：还检查ICollection，因为即使某些非过时的泛型类（也就是Queue<T>and Stack<T>）也可以实现此功能。我也将使用as代替，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本身必须以某种方式对Count（）方法进行一些认真的优化。

这会让您感到惊讶吗？我想对于IList实现而言，Count只需直接读取元素数量，而Any必须查询IEnumerable.GetEnumerator方法，创建实例并MoveNext至少调用一次。

/编辑@Matt：

我只能假定IEnumerable的Count（）扩展方法正在执行以下操作：

是的，当然可以。这就是我的意思。实际上，它使用ICollection代替，IList但结果是相同的。

我刚刚写了一个快速测试，请尝试以下操作：

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

第二个几乎慢了三倍:)

再次尝试使用Stack或数组或其他方案进行秒表测试时，它实际上取决于显示的列表类型-因为它们证明Count较慢。

因此，我想这取决于您使用的列表类型！

（只需指出，我将2000多个对象放入列表中，并且计数仍然更快，与其他类型相反）

List.Count根据Microsoft的文档为O（1）：http :
//msdn.microsoft.com/zh-cn/library/27b47ht3.aspx

因此使用List.Count == 0它比查询要快得多

这是因为它有一个名为Count的数据成员，该成员List.Count在每次添加或删除列表时都会更新，因此当您调用它时，不必遍历每个元素来获取它，它只返回该数据成员。

如果您有多个项目，第二个选项会更快。

• Any() 找到1个项目后立即返回。
• Count() 必须继续浏览整个列表。

例如，假设枚举有1000个项目。

• Any() 将检查第一个，然后返回true。
• Count() 遍历整个枚举后将返回1000。

如果使用谓词替代之一，则可能会更糟-Count（）仍必须检查每个项目，即使只有一个匹配项也是如此。

您已经习惯了使用Any Any-它确实有意义并且可读。

一个警告-如果您有一个List，而不只是一个IEnumerable，则使用该列表的Count属性。

@Konrad让我感到惊讶的是，在我的测试中，我将列表传递给可以接受的方法IEnumerable<T>，因此运行时无法通过调用Count（）扩展方法来对其进行优化IList<T>。

我只能假定IEnumerable的Count（）扩展方法正在执行以下操作：

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

...换句话说，对于的特殊情况，需要进行一些运行时优化IList<T>。

/ EDIT @Konrad +1队友-你说对了，这很可能会发生ICollection<T>。

好的，那这个呢？

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

编辑：我刚刚意识到有人已经草绘了此解决方案。有人提到Any（）方法可以做到这一点，但是为什么不自己做呢？问候

另一个想法：

if(enumerable.FirstOrDefault() != null)

但是我更喜欢Any（）方法。

这对于与实体框架一起使用至关重要：

var genericCollection = list as ICollection<T>;

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

如果我用Count（）检查，Linq在数据库中执行了“ SELECT COUNT（*）..”，但是我需要检查结果是否包含数据，我决定引入FirstOrDefault（）而不是Count（）;。

之前

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

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

后

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

这是我对丹涛的回答的实现，允许一个谓词：

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。就这样

此扩展方法适用于我：

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