c# - IEnumerable 没有 Count 方法

Question

我有以下方法：

public bool IsValid
{
  get { return (GetRuleViolations().Count() == 0); }
}

public IEnumerable<RuleViolation> GetRuleViolations(){
  //code here
}

为什么当我在.Count()上面做时，它带有红色下划线？

我收到以下错误：

错误 1“System.Collections.Generic.IEnumerable”不包含“Count”的定义，并且找不到接受“System.Collections.Generic.IEnumerable”类型的第一个参数的扩展方法“Count”（您是否缺少使用指令或程序集引用？） c:\users\a\documents\visual studio 2010\Projects\NerdDinner\NerdDinner\Models\Dinner.cs 15 47 NerdDinner

Answer 1

您添加：

using System.Linq;

在源代码的顶部，并确保您有对 System.Core 程序集的引用。

Count()是System.Linq.Enumerable静态类为 LINQ to Objects 以及System.Linq.QueryableLINQ to SQL 和其他进程外提供程序提供的扩展方法。

编辑：事实上，Count()在这里使用效率相对较低（至少在 LINQ to Objects 中）。您只想知道是否有任何元素，对吗？在这种情况下，Any()更适合：

public bool IsValid
{
  get { return !GetRuleViolations().Any(); }
}

Answer 2

Any()或Count()Linq 中的方法仅适用于泛型类型。

IEnumerable<T>

如果您有一个IEnumerable没有类型的简单，请尝试使用

IEnumerable<object> 

反而。

Answer 3

IEnumeration没有一个方法叫做Count(). 它只是一种“元素序列”。例如List，如果您明确需要元素的数量，请使用。如果您使用 Linq 请记住，扩展方法Count()实际上可能会在您每次调用它时重新计算元素的数量。

Answer 4

关于 .Count() 的陷阱的简短而甜蜜的一般警告，以帮助将来偶然发现这篇文章的疲惫的旅行者！

短篇故事：

以下工作 - 毫无疑问 - 但如果可枚举没有得到方便/预先计算的“计数”的基础数组或列表的支持，则可能会有小的性能损失：

public bool IsValid
{
   get { return SomeMethodReturningEnumerable().Count() <= threshold; }  <--- small performance issue here
}

public IEnumerable<SomeObject> SomeMethodReturningEnumerable(){
   yield return foo;
   yield return bar; etc
}

对 .Count() 方法的调用可能会遍历可枚举中的每一项，然后将总计数与阈值进行比较。我们变得更聪明可以做得更好：

    public bool IsValid
    {
       get { return !SomeMethodReturningEnumerable().HasMoreThan(threshold); }  <--- neato!
    }

    public static bool HasLessThan<T>(this IEnumerable<T> sequence, int count) => !sequence.HasMoreThan(count - 1);

    public static bool HasLessOrEqualTo<T>(this IEnumerable<T> sequence, int count) => !sequence.HasMoreThan(count);

    public static bool HasMoreOrEqualTo<T>(this IEnumerable<T> sequence, int count) => sequence.HasMoreThan(count - 1);

    public static bool HasMoreThan<T>(this IEnumerable<T> sequence, int count) => sequence.EnumerationCounterImpl(count, equals_vs_greaterThan: false);

    public static bool HasExactly<T>(this IEnumerable<T> sequence, int count) => sequence.EnumerationCounterImpl(count, equals_vs_greaterThan: true);

    public static bool EnumerationCounterImpl<T>(this IEnumerable<T> sequence, int count, bool equals_vs_greaterThan = true) //0
    {
        if (equals_vs_greaterThan && count < 0)
            throw new ArgumentException($"{nameof(count)} is less than zero!");

        if (!equals_vs_greaterThan && count < 0)
            return true;

        var staticCount = (sequence as ICollection)?.Count                              
                          ?? (sequence as ICollection<T>)?.Count
                          ?? (sequence as IReadOnlyCollection<T>)?.Count;

        if (staticCount != null)
            return staticCount > count;

        using (var enumerator = sequence.GetEnumerator()) //1 optimization
        {
            for (int i = 0; i < count + 1; i++)
            {
                if (enumerator.MoveNext())
                    continue;

                return false;
            }

            return !equals_vs_greaterThan //     ==
                   || enumerator.MoveNext(); //  >
        }

        //0 https://blog.slaks.net/2015-01-12/linq-count-considered-occasionally-harmful/
        //1 using the enumerator directly is slightly faster than using LINQ methods   it avoids allocating an extra iterator
        //  state machine compared to using skip()
    }

那里！问题再次解决，但这次我们注重性能！

Answer 5

怎么样：

public bool IsValid
{
    get { return (GetRuleViolations().Cast<RuleViolation>().Count() == 0); }
}