计算 IEnumerable<T> 中的项目而不进行迭代?
-
05-07-2019 - |
题
private IEnumerable<string> Tables
{
get
{
yield return "Foo";
yield return "Bar";
}
}
假设我想迭代这些并编写类似处理 #n of #m 的内容。
有没有一种方法可以在主迭代之前找到 m 的值而无需迭代?
我希望我说清楚了。
解决方案
IEnumerable
不支持此功能。这是设计的。 IEnumerable
使用延迟评估来获取您需要的元素。
如果你想知道没有迭代它们的项目数量,你可以使用 ICollection&lt; T&gt;
,它有一个 Count
属性。
其他提示
IEnumerable&lt; T&gt;
上的 System.Linq.Enumerable.Count
扩展方法具有以下实现:
ICollection<T> c = source as ICollection<TSource>;
if (c != null)
return c.Count;
int result = 0;
using (IEnumerator<T> enumerator = source.GetEnumerator())
{
while (enumerator.MoveNext())
result++;
}
return result;
因此它尝试转换为 ICollection&lt; T&gt;
,它具有 Count
属性,并在可能的情况下使用它。否则它会迭代。
因此,最好的办法是在 IEnumerable&lt; T&gt;
对象上使用 Count()
扩展方法,因为这样可以获得最佳性能。
只需添加额外的一些信息:
Count()
扩展名并不总是迭代。考虑Linq to Sql,其中计数进入数据库,但不是返回所有行,而是发出Sql Count()
命令并返回该结果。
此外,编译器(或运行时)足够智能,如果它有一个,它将调用对象 Count()
方法。所以它是不,正如其他响应者所说,完全无知并且总是迭代以便计算元素。
在许多情况下,程序员只是使用 Any()
扩展方法检查 if(enumerable.Count!= 0)
,如 if(对于linq的惰性求值,enumerable.Any())
效率要高得多,因为一旦确定有任何元素,它就会短路。它也更具可读性
我的一位朋友有一系列博客文章,说明了为什么你不能这样做。他创建了返回IEnumerable的函数,其中每次迭代返回下一个素数,一直到 ulong.MaxValue
,并且直到你要求它才计算下一个项目。快速流行问题:返回了多少项?
以下是帖子,但它们有点长:
- 超越循环(提供其他帖子中使用的初始EnumerableUtility类)
- Iterate的应用(初步实施)
- 疯狂扩展方法:ToLazyList (性能优化) 醇>
IEnumerable 无法在不迭代的情况下进行计数。
在“正常”情况下,实现 IEnumerable 或 IEnumerable<T> 的类(例如 List<T>)可以通过返回 List<T>.Count 属性来实现 Count 方法。但是,Count 方法实际上并不是 IEnumerable<T> 或 IEnumerable 接口上定义的方法。(事实上,唯一的一个是 GetEnumerator。)这意味着无法为其提供特定于类的实现。
相反,Count 是一个扩展方法,定义在静态类 Enumerable 上。这意味着可以在 IEnumerable<T> 派生类的任何实例上调用它,无论该类的实现如何。但这也意味着它是在任何这些类外部的单个位置实现的。这当然意味着它必须以完全独立于这些类内部的方式实现。唯一进行计数的方法是通过迭代。
或者,您可以执行以下操作:
Tables.ToList<string>().Count;
不,不是一般的。使用枚举的一点是,枚举中的实际对象集是未知的(事先,甚至根本不知道)。
您可以使用System.Linq。
using System;
using System.Collections.Generic;
using System.Linq;
public class Test
{
private IEnumerable<string> Tables
{
get {
yield return "Foo";
yield return "Bar";
}
}
static void Main()
{
var x = new Test();
Console.WriteLine(x.Tables.Count());
}
}
你会得到结果'2'。
超越您的直接问题(已经完全回答了否定),如果您希望在处理可枚举时报告进度,您可能需要查看我的博客文章在Linq查询期间报告进度。
它可以让你这样做:
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += (sender, e) =>
{
// pretend we have a collection of
// items to process
var items = 1.To(1000);
items
.WithProgressReporting(progress => worker.ReportProgress(progress))
.ForEach(item => Thread.Sleep(10)); // simulate some real work
};
我在方法中使用这种方式检查传入的 IEnumerable
内容
if( iEnum.Cast<Object>().Count() > 0)
{
}
在这样的方法中:
GetDataTable(IEnumberable iEnum)
{
if (iEnum != null && iEnum.Cast<Object>().Count() > 0) //--- proceed further
}
这取决于.Net的哪个版本和IEnumerable对象的实现。 Microsoft已修复IEnumerable.Count方法以检查实现,并使用ICollection.Count或ICollection&lt; TSource&gt; .Count,请在此处查看详细信息 https://connect.microsoft.com/VisualStudio/反馈/信息/ 454130
以下是来自Ildasm的System.Core的MSIL,System.Linq所在的位置。
.method public hidebysig static int32 Count<TSource>(class
[mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource> source) cil managed
{
.custom instance void System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 )
// Code size 85 (0x55)
.maxstack 2
.locals init (class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource> V_0,
class [mscorlib]System.Collections.ICollection V_1,
int32 V_2,
class [mscorlib]System.Collections.Generic.IEnumerator`1<!!TSource> V_3)
IL_0000: ldarg.0
IL_0001: brtrue.s IL_000e
IL_0003: ldstr "source"
IL_0008: call class [mscorlib]System.Exception System.Linq.Error::ArgumentNull(string)
IL_000d: throw
IL_000e: ldarg.0
IL_000f: isinst class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>
IL_0014: stloc.0
IL_0015: ldloc.0
IL_0016: brfalse.s IL_001f
IL_0018: ldloc.0
IL_0019: callvirt instance int32 class [mscorlib]System.Collections.Generic.ICollection`1<!!TSource>::get_Count()
IL_001e: ret
IL_001f: ldarg.0
IL_0020: isinst [mscorlib]System.Collections.ICollection
IL_0025: stloc.1
IL_0026: ldloc.1
IL_0027: brfalse.s IL_0030
IL_0029: ldloc.1
IL_002a: callvirt instance int32 [mscorlib]System.Collections.ICollection::get_Count()
IL_002f: ret
IL_0030: ldc.i4.0
IL_0031: stloc.2
IL_0032: ldarg.0
IL_0033: callvirt instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<!!TSource>::GetEnumerator()
IL_0038: stloc.3
.try
{
IL_0039: br.s IL_003f
IL_003b: ldloc.2
IL_003c: ldc.i4.1
IL_003d: add.ovf
IL_003e: stloc.2
IL_003f: ldloc.3
IL_0040: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
IL_0045: brtrue.s IL_003b
IL_0047: leave.s IL_0053
} // end .try
finally
{
IL_0049: ldloc.3
IL_004a: brfalse.s IL_0052
IL_004c: ldloc.3
IL_004d: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_0052: endfinally
} // end handler
IL_0053: ldloc.2
IL_0054: ret
} // end of method Enumerable::Count
IEnumerable.Count()函数的结果可能有误。这是一个非常简单的测试样本:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
namespace Test
{
class Program
{
static void Main(string[] args)
{
var test = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
var result = test.Split(7);
int cnt = 0;
foreach (IEnumerable<int> chunk in result)
{
cnt = chunk.Count();
Console.WriteLine(cnt);
}
cnt = result.Count();
Console.WriteLine(cnt);
Console.ReadLine();
}
}
static class LinqExt
{
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int chunkLength)
{
if (chunkLength <= 0)
throw new ArgumentOutOfRangeException("chunkLength", "chunkLength must be greater than 0");
IEnumerable<T> result = null;
using (IEnumerator<T> enumerator = source.GetEnumerator())
{
while (enumerator.MoveNext())
{
result = GetChunk(enumerator, chunkLength);
yield return result;
}
}
}
static IEnumerable<T> GetChunk<T>(IEnumerator<T> source, int chunkLength)
{
int x = chunkLength;
do
yield return source.Current;
while (--x > 0 && source.MoveNext());
}
}
}
结果必须是(7,7,3,3),但实际结果是(7,7,3,17)
快速计数的唯一方法是原始集合具有索引器(如数组)。为了创建具有最低要求的通用代码,您可以使用IEnumerable,但如果您还需要计数,那么我首选的方法是使用此接口:
public interface IEnumAndCount<out T> : IEnumerable<T>
{
int Count { get; }
}
如果您的原始集合没有任何索引器,则您的Count实现可以迭代集合,其中已知性能为O(n)。
如果你不想使用类似于IEnumAndCount的东西,你最好的选择是使用Linq.Count,理由是Daniel Earwicker在这个问题的顶部附近给出的理由。
祝你好运!没有
您是否在您编写的代码中的任何位置看到了这些信息?
你可能会争辩说编译器可以“看到”只有两个,但这意味着它需要分析每个迭代器方法,只查找特定的病态情况。即使它确实如此,考虑到IEnumerable的限制,你会怎么看?
我建议调用ToList。是的,您提前进行了枚举,但仍然可以访问您的项目列表。
它可能无法产生最佳性能,但您可以使用LINQ来计算IEnumerable中的元素:
public int GetEnumerableCount(IEnumerable Enumerable)
{
return (from object Item in Enumerable
select Item).Count();
}
我使用 IEnum&lt; string&gt; .ToArray&lt; string&gt;()。Length
,它运行正常。
如果我有字符串列表,我会使用这样的代码:
((IList<string>)Table).Count