นับรายการจาก IE ที่นับได้โดยไม่ต้องวนซ้ำ?

private IEnumerable<string> Tables
{
    get
    {
        yield return "Foo";
        yield return "Bar";
    }
}

สมมติว่าฉันต้องการทำซ้ำในสิ่งเหล่านั้นและเขียนสิ่งที่ต้องการประมวลผล #n ของ #m

มีวิธีที่ฉันสามารถหาค่าของ m โดยไม่ต้องทำซ้ำก่อนการทำซ้ำหลักของฉันหรือไม่?

ฉันหวังว่าฉันทำให้ตัวเองชัดเจน

IEnumerableไม่รองรับสิ่งนี้ นี่คือโดยการออกแบบ IEnumerableใช้การประเมินแบบขี้เกียจเพื่อให้ได้องค์ประกอบที่คุณต้องการก่อนที่คุณจะต้องการ

หากคุณต้องการทราบจำนวนรายการโดยไม่ต้องวนซ้ำพวกเขาคุณสามารถใช้ICollection<T>มันมีCountคุณสมบัติ

System.Linq.Enumerable.CountวิธีขยายบนIEnumerable<T>มีการดำเนินการดังต่อไปนี้:

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<T>ซึ่งมีCountทรัพย์สินและใช้มันหากเป็นไปได้ มิฉะนั้นจะวนซ้ำ

ดังนั้นทางออกที่ดีที่สุดของคุณคือการใช้Count()วิธีการขยายบนIEnumerable<T>วัตถุของคุณเนื่องจากคุณจะได้รับประสิทธิภาพที่ดีที่สุดเท่าที่จะเป็นไปได้

เพียงเพิ่มข้อมูลพิเศษ:

Count()นามสกุลไม่เคยย้ำ พิจารณา Linq ถึง Sql โดยที่การนับไปที่ฐานข้อมูล แต่แทนที่จะนำแถวกลับมาทั้งหมดมันจะออกCount()คำสั่งSql และส่งกลับผลลัพธ์นั้นแทน

นอกจากนี้คอมไพเลอร์ (หรือรันไทม์) นั้นฉลาดพอที่จะเรียกใช้Count()เมธอดobject ถ้ามี ดังนั้นจึงไม่เหมือนที่ผู้เผชิญเหตุคนอื่นพูดว่าไม่รู้อย่างสมบูรณ์และวนซ้ำเสมอเพื่อนับองค์ประกอบ

ในหลายกรณีที่โปรแกรมเมอร์กำลังตรวจสอบif( enumerable.Count != 0 )โดยใช้Any()วิธีการขยายเนื่องจากif( enumerable.Any() ) มีประสิทธิภาพมากกว่าด้วยการประเมินที่ขี้เกียจของ linq เนื่องจากสามารถลัดวงจรเมื่อสามารถตรวจสอบได้ว่ามีองค์ประกอบใดบ้าง นอกจากนี้ยังสามารถอ่านได้มากขึ้น

เพื่อนของฉันมีชุดบทความบล็อกที่แสดงภาพประกอบว่าทำไมคุณถึงทำไม่ได้ เขาสร้างฟังก์ชั่นที่คืนค่า IEnumerable โดยที่การวนซ้ำแต่ละครั้งส่งคืนหมายเลขเฉพาะถัดไปตลอดทางจนถึงulong.MaxValueและรายการถัดไปจะไม่ถูกคำนวณจนกว่าคุณจะขอ คำถามป๊อปอัพอย่างรวดเร็ว: มีรายการกี่รายการที่ส่งคืน

นี่คือโพสต์ แต่มันยาว:

1. Beyond Loops (จัดเตรียมคลาส EnumerableUtility เริ่มต้นที่ใช้ในโพสต์อื่น ๆ )
2. แอพพลิเคชั่นของ Iterate (การติดตั้งครั้งแรก)
3. วิธีการ Extention บ้า: ToLazyList (การเพิ่มประสิทธิภาพประสิทธิภาพ)

IEnumerable ไม่สามารถนับได้หากไม่วนซ้ำ

ภายใต้สถานการณ์ "ปกติ" อาจเป็นไปได้สำหรับคลาสที่ใช้ IEnumerable หรือ IEnumerable <T> เช่น List <T> เพื่อใช้เมธอด Count โดยส่งกลับคุณสมบัติ List <T> .Count อย่างไรก็ตามวิธีการนับนั้นไม่ใช่วิธีที่กำหนดไว้ใน IEnumerable <T> หรืออินเทอร์เฟซ IEnumerable (อันที่จริงอันเดียวคือในความเป็นจริงคือ GetEnumerator) และนี่หมายความว่าไม่สามารถให้การใช้งานเฉพาะคลาสได้

ค่อนข้างนับเป็นวิธีการขยายที่กำหนดไว้ในคลาสคงที่ Enumerable ซึ่งหมายความว่าสามารถเรียกใช้บนอินสแตนซ์ใด ๆ ของคลาสที่ได้รับมา IEnumerable <T> โดยไม่คำนึงถึงการใช้งานของคลาสนั้น แต่มันก็หมายความว่ามันจะถูกนำไปใช้ในสถานที่เดียวภายนอกใด ๆ ของชั้นเรียนเหล่านั้น ซึ่งแน่นอนหมายความว่าจะต้องมีการดำเนินการในลักษณะที่เป็นอิสระจากการฝึกงานของคลาสเหล่านี้ วิธีเดียวที่จะทำการนับคือผ่านการวนซ้ำ

หรือคุณสามารถทำสิ่งต่อไปนี้:

Tables.ToList<string>().Count;

ไม่ไม่โดยทั่วไป จุดหนึ่งในการใช้ enumerables คือไม่ทราบชุดของวัตถุที่แท้จริงในการแจงนับ (ล่วงหน้าหรือแม้แต่ทั้งหมด)

คุณสามารถใช้ 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
      };

ฉันใช้วิธีดังกล่าวภายในวิธีการตรวจสอบIEnumberableเนื้อหาที่ส่งผ่าน

if( iEnum.Cast<Object>().Count() > 0) 
{

}

ภายในวิธีการเช่นนี้:

GetDataTable(IEnumberable iEnum)
{  
    if (iEnum != null && iEnum.Cast<Object>().Count() > 0) //--- proceed further

}

ขึ้นอยู่กับ. Net รุ่นใดและการใช้งาน IEnumerable object ของคุณ Microsoft ได้แก้ไขวิธี IEnumerable.Count เพื่อตรวจสอบการใช้งานและใช้ ICollection.Count หรือ ICollection <TSource> .Count ดูรายละเอียดได้ที่นี่https://connect.microsoft.com/VisualStudio/feedback/details/454130

และด้านล่างคือ MSIL จาก Ildasm สำหรับ System.Core ซึ่ง 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<T> enumList = ReturnFromSomeFunction();

int count = new List<T>(enumList).Count;

ฉันขอแนะนำให้โทร ToList ใช่คุณกำลังทำการแจงนับ แต่ยังคงสามารถเข้าถึงรายการของคุณได้

อาจไม่ได้ประสิทธิภาพที่ดีที่สุด แต่คุณสามารถใช้ LINQ เพื่อนับองค์ประกอบใน IEnumerable:

public int GetEnumerableCount(IEnumerable Enumerable)
{
    return (from object Item in Enumerable
            select Item).Count();
}

ฉันคิดว่าวิธีที่ง่ายที่สุดในการทำเช่นนี้

Enumerable.Count<TSource>(IEnumerable<TSource> source)

การอ้างอิง: system.linq.enumerable

ฉันใช้IEnum<string>.ToArray<string>().Lengthและใช้งานได้ดี

ฉันใช้รหัสดังกล่าวหากฉันมีรายการสตริง:

((IList<string>)Table).Count