การปรับปรุง C # foreach?

ฉันพบปัญหานี้บ่อยครั้งในระหว่างการเขียนโปรแกรมซึ่งฉันต้องการให้มีการนับดัชนีแบบวนซ้ำภายใน foreach และต้องสร้างจำนวนเต็มใช้การเพิ่มขึ้น ฯลฯ จะไม่เป็นการดีถ้ามีคำหลักที่แนะนำ วงนับภายใน foreach หรือไม่? มันสามารถใช้กับลูปอื่นได้เช่นกัน

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

หากคุณต้องการการนับลูปภายในforeachลูปทำไมคุณไม่ใช้forลูปปกติ การforeachวนซ้ำนั้นตั้งใจจะทำให้การใช้งานforลูปง่ายขึ้นโดยเฉพาะ ดูเหมือนคุณจะมีสถานการณ์ที่ความเรียบง่ายของforeachมันไม่มีประโยชน์อีกต่อไป

คุณสามารถใช้ประเภทที่ไม่ระบุชื่อเช่นนี้

foreach (var item in items.Select((v, i) => new { Value = v, Index = i }))
{
    Console.WriteLine("Item value is {0} and index is {1}.", item.Value, item.Index);
}

คล้ายกับenumerateฟังก์ชั่นของ Python

for i, v in enumerate(items):
    print v, i

ฉันแค่เพิ่มคำตอบของ Dan Finchที่นี่ตามที่ร้องขอ

อย่าให้คะแนนกับฉันให้คะแนนกับ Dan Finch :-)

การแก้ปัญหาคือการเขียนวิธีการขยายทั่วไปต่อไปนี้:

public static void Each<T>( this IEnumerable<T> ie, Action<T, int> action )
{
    var i = 0;
    foreach ( var e in ie ) action( e, i++ );
}

ซึ่งใช้เช่น:

var strings = new List<string>();
strings.Each( ( str, n ) =>
{
    // hooray
} );

ฉันอาจจะผิดเกี่ยวกับเรื่องนี้ แต่ฉันคิดเสมอว่าจุดหลักของการวนรอบ foreach คือการทำซ้ำง่ายจาก STL วันของ C ++ คือ

for(std::stltype<typename>::iterator iter = stl_type_instance.begin(); iter != stl_type_instance.end(); iter++)
{
   //dereference iter to use each object.
}

เปรียบเทียบสิ่งนี้กับ. NET การใช้ IEnumerable ใน foreach

foreach(TypeName instance in DescendentOfIEnumerable)
{
   //use instance to use the object.
}

หลังนั้นง่ายกว่ามากและหลีกเลี่ยงหลุมพรางเก่า ๆ นอกจากนี้พวกเขาดูเหมือนจะปฏิบัติตามกฎเกือบเหมือนกัน ตัวอย่างเช่นคุณไม่สามารถเปลี่ยนเนื้อหา IEnumerable ในขณะที่อยู่ในลูป (ซึ่งทำให้รู้สึกมากขึ้นถ้าคุณคิดว่ามันเป็นวิธี STL) อย่างไรก็ตามการวนซ้ำมักจะมีวัตถุประสงค์เชิงตรรกะที่แตกต่างจากการวนซ้ำ

หากการรวบรวมที่เป็นปัญหาIList<T>คุณสามารถใช้forกับการจัดทำดัชนีได้:

for (int i = 0; i < collection.Count; i++)
{
    var item = collection[i];
    // …
}

ถ้าไม่เช่นนั้นคุณสามารถใช้Select()มันมีโอเวอร์โหลดที่ให้ดัชนีกับคุณ

หากนั่นยังไม่เหมาะสมฉันคิดว่าการรักษาดัชนีด้วยตนเองนั้นง่ายพอมันเป็นเพียงโค้ดสั้น ๆ สองบรรทัด การสร้างคำหลักเฉพาะสำหรับสิ่งนี้จะเป็นการ overkill

int i = 0;
foreach (var item in collection)
{
    // …
    i++;
}

หากคุณรู้ว่าคอลเล็กชันนั้นมีจำนวน IEnumerable แต่จำเป็นต้องติดตามจำนวนองค์ประกอบที่คุณประมวลผลจนถึงตอนนี้ (และเมื่อรวมทั้งหมดเมื่อคุณทำเสร็จแล้ว) คุณสามารถเพิ่มสองบรรทัดเป็นพื้นฐานสำหรับลูป:

var coll = GetMyCollectionAsAnIEnumerable();
var idx = 0;
for(var e = coll.GetEnumerator(); e.MoveNext(); idx++)
{
   var elem = e.Current;

   //use elem and idx as you please
}

คุณยังสามารถเพิ่มตัวแปรดัชนีแบบเพิ่มหน่วยลงใน foreach:

var i=0;
foreach(var elem in coll)
{
   //do your thing, then...
   i++;
}

หากคุณต้องการทำให้ลุคนี้ดูหรูหรายิ่งขึ้นคุณสามารถกำหนดวิธีการขยายหรือสองเพื่อ "ซ่อน" รายละเอียดเหล่านี้:

public static void ForEach<T>(this IEnumerable<T> input, Action<T> action)
{
    foreach(T elem in input)
        action(elem);
}

public static void ForEach<T>(this IEnumerable<T> input, Action<T, int> action)
{
    var idx = 0;
    foreach(T elem in input)
        action(elem, idx++); //post-increment happens after parameter-passing
}

//usage of the index-supporting method
coll.ForEach((e, i)=>Console.WriteLine("Element " + (i+1) + ": " + e.ToString()));

การกำหนดขอบเขตยังใช้งานได้หากคุณต้องการรักษาความสะอาดของการชนด้วยชื่ออื่น ...

{ int index = 0; foreach(var el in List) { Console.WriteLine(el + " @ " + index++); } }

สำหรับเรื่องนี้ฉันใช้whileวง ลูปที่มีการใช้forงานด้วยและหลาย ๆ คนดูเหมือนจะชอบพวกเขา แต่ฉันชอบที่จะใช้forกับบางสิ่งที่จะมีจำนวนการทำซ้ำที่แน่นอน IEnumerables อาจถูกสร้างขึ้นในเวลาทำงานดังนั้นในความคิดของฉันwhileทำให้มีเหตุผลมากขึ้น เรียกว่าเป็นแนวทางการเข้ารหัสอย่างไม่เป็นทางการหากคุณต้องการ