3

我正在为Enumerable.Count() == n. 我能想到的最好的是：

static class EnumerableExtensions
{
    public static bool CountEquals<T>(this IEnumerable<T> items, int n)
    {
        if (n <= 0) throw new ArgumentOutOfRangeException("n"); // use Any()

        var iCollection = items as System.Collections.ICollection;
        if (iCollection != null)
            return iCollection.Count == n;

        int count = 0;
        bool? retval = null;
        foreach (var item in items)
        {
            count++;

            if (retval.HasValue)
                return false;

            if (count == n)
                retval = true;
        }

        if (retval.HasValue)
            return retval.Value;

        return false;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var items0 = new List<int>();
        var items1 = new List<int>() { 314 };
        var items3 = new List<int>() { 1, 2, 3 };
        var items5 = new List<int>() { 1, 2, 3, 4, 5 };
        var items10 = Enumerable.Range(0, 10);
        var itemsLarge = Enumerable.Range(0, Int32.MaxValue);

        Console.WriteLine(items0.CountEquals(3));
        Console.WriteLine(items1.CountEquals(3));
        Console.WriteLine(items3.CountEquals(3));
        Console.WriteLine(items5.CountEquals(3));
        Console.WriteLine(itemsLarge.CountEquals(3));
    }
}

我还能做得更好吗？有没有办法更概括这一点——通过比较？

4

3 回答 3

2

使用Enumerable.Count会比你上面的代码好得多。它已经针对ICollection内部进行了优化。

话虽如此，如果你必须保留你的扩展，你可以稍微简化一下循环：

int count = 0;
foreach (var item in items)
{
    count++;
    if(count > n)
        return false;
}
return count == n;
于 2011-02-02T00:46:33.543 回答
2

您可以使用Take和的组合Count来完全摆脱循环：

public static bool CountEquals<T>(this IEnumerable<T> items, int n)
{
  var iCollection = items as System.Collections.ICollection;
  if (iCollection != null)
    return iCollection.Count == n;
  return items.Take(n + 1).Count() == n;
}
于 2011-02-02T01:29:19.640 回答
0

“更好”到底是什么意思？快点？更轻松？

从本质上讲，您似乎所做的是编写了一种针对一项特定任务进行了优化的专门方法。您提到对其进行概括，但它的性能优势源于它如此具体的事实（假设有性能优势 - 像这样的方法Count已经为性能进行了非常努力的调整，并且编译器非常擅长优化这样的东西）。

过早的优化是万恶之源。如果这个特定操作的性能如此重要以至于值得用xyz.Count() == abc几十行代码替换二十多个字符的表达式，您可能想尝试其他提高性能的方法，例如重构。在大多数情况下，仅使用托管代码的开销就会使您获得的性能奖励（如果有的话）相形见绌。

话虽这么说——如果你有 1000 万件物品，而你的目标数量要少得多，我很确定下面会缩短迭代：

int count = 0;
var subset = items.TakeWhile(x => count++ < n + 1);
return count == n + 1;

易于阅读，易于维护，并且可能同样快。

于 2011-02-02T01:57:44.420 回答