Làm thế nào để bạn có được chỉ số của lần lặp hiện tại của một vòng lặp foreach?

Is there some rare language construct I haven't encountered (like the few I've learned recently, some on Stack Overflow) in C# to get a value representing the current iteration of a foreach loop?

For instance, I currently do something like this depending on the circumstances:

int i = 0;
foreach (Object o in collection)
{
    // ...
    i++;
}

Đây foreachlà để lặp đi lặp lại trên các bộ sưu tập thực hiện IEnumerable. Nó thực hiện điều này bằng cách gọi GetEnumeratorvào bộ sưu tập, sẽ trả về một Enumerator.

Trình liệt kê này có một phương thức và thuộc tính:

• MoveNext ()
• Hiện hành

Currenttrả về đối tượng mà Enumerator hiện đang bật, MoveNextcập nhật Currentcho đối tượng tiếp theo.

Khái niệm về một chỉ số là xa lạ với khái niệm liệt kê, và không thể được thực hiện.

Do đó, hầu hết các bộ sưu tập có thể được duyệt qua bộ chỉ mục và cấu trúc vòng lặp for.

Tôi rất thích sử dụng vòng lặp for trong tình huống này so với theo dõi chỉ mục bằng một biến cục bộ.

Ian Mercer posted a similar solution as this on Phil Haack's blog:

foreach (var item in Model.Select((value, i) => new { i, value }))
{
    var value = item.value;
    var index = item.i;
}

Điều này giúp bạn có mục ( item.value) và chỉ mục của nó ( item.i) bằng cách sử dụng quá tải LINQ nàySelect :

tham số thứ hai của hàm [bên trong Chọn] biểu thị chỉ mục của phần tử nguồn.

Việc new { i, value }tạo ra một đối tượng ẩn danh mới .

Có thể tránh phân bổ heap bằng cách sử dụng ValueTuplenếu bạn đang sử dụng C # 7.0 trở lên:

foreach (var item in Model.Select((value, i) => ( value, i )))
{
    var value = item.value;
    var index = item.i;
}

Bạn cũng có thể loại bỏ item.bằng cách sử dụng tự động hủy:

<ol>
foreach ((MyType value, Int32 i) in Model.Select((value, i) => ( value, i )))
{
    <li id="item_@i">@value</li>
}
</ol>

Cuối cùng, C # 7 có một cú pháp hợp lý để lấy chỉ mục bên trong một foreachvòng lặp (ví dụ: bộ dữ liệu):

foreach (var (item, index) in collection.WithIndex())
{
    Debug.WriteLine($"{index}: {item}");
}

Một phương pháp mở rộng sẽ là cần thiết:

public static IEnumerable<(T item, int index)> WithIndex<T>(this IEnumerable<T> self)       
   => self.Select((item, index) => (item, index)); 

Could do something like this:

public static class ForEachExtensions
{
    public static void ForEachWithIndex<T>(this IEnumerable<T> enumerable, Action<T, int> handler)
    {
        int idx = 0;
        foreach (T item in enumerable)
            handler(item, idx++);
    }
}

public class Example
{
    public static void Main()
    {
        string[] values = new[] { "foo", "bar", "baz" };

        values.ForEachWithIndex((item, idx) => Console.WriteLine("{0}: {1}", idx, item));
    }
}

I disagree with comments that a for loop is a better choice in most cases.

foreach is a useful construct, and not replaceble by a for loop in all circumstances.

For example, if you have a DataReader and loop through all records using a foreach it automatically calls the Dispose method and closes the reader (which can then close the connection automatically). This is therefore safer as it prevents connection leaks even if you forget to close the reader.

(Sure it is good practise to always close readers but the compiler is not going to catch it if you don't - you can't guarantee you have closed all readers but you can make it more likely you won't leak connections by getting in the habit of using foreach.)

There may be other examples of the implicit call of the Dispose method being useful.

Literal Answer -- warning, performance may not be as good as just using an int to track the index. At least it is better than using IndexOf.

You just need to use the indexing overload of Select to wrap each item in the collection with an anonymous object that knows the index. This can be done against anything that implements IEnumerable.

System.Collections.IEnumerable collection = Enumerable.Range(100, 10);

foreach (var o in collection.OfType<object>().Select((x, i) => new {x, i}))
{
    Console.WriteLine("{0} {1}", o.i, o.x);
}

Using LINQ, C# 7, and the System.ValueTuple NuGet package, you can do this:

foreach (var (value, index) in collection.Select((v, i)=>(v, i))) {
    Console.WriteLine(value + " is at index " + index);
}

You can use the regular foreach construct and be able to access the value and index directly, not as a member of an object, and keeps both fields only in the scope of the loop. For these reasons, I believe this is the best solution if you are able to use C# 7 and System.ValueTuple.

Using @FlySwat's answer, I came up with this solution:

//var list = new List<int> { 1, 2, 3, 4, 5, 6 }; // Your sample collection

var listEnumerator = list.GetEnumerator(); // Get enumerator

for (var i = 0; listEnumerator.MoveNext() == true; i++)
{
  int currentItem = listEnumerator.Current; // Get current item.
  //Console.WriteLine("At index {0}, item is {1}", i, currentItem); // Do as you wish with i and  currentItem
}

You get the enumerator using GetEnumerator and then you loop using a for loop. However, the trick is to make the loop's condition listEnumerator.MoveNext() == true.

Since the MoveNext method of an enumerator returns true if there is a next element and it can be accessed, making that the loop condition makes the loop stop when we run out of elements to iterate over.

There's nothing wrong with using a counter variable. In fact, whether you use for, foreach while or do, a counter variable must somewhere be declared and incremented.

So use this idiom if you're not sure if you have a suitably-indexed collection:

var i = 0;
foreach (var e in collection) {
   // Do stuff with 'e' and 'i'
   i++;
}

Else use this one if you know that your indexable collection is O(1) for index access (which it will be for Array and probably for List<T> (the documentation doesn't say), but not necessarily for other types (such as LinkedList)):

// Hope the JIT compiler optimises read of the 'Count' property!
for (var i = 0; i < collection.Count; i++) {
   var e = collection[i];
   // Do stuff with 'e' and 'i'
}

It should never be necessary to 'manually' operate the IEnumerator by invoking MoveNext() and interrogating Current - foreach is saving you that particular bother ... if you need to skip items, just use a continue in the body of the loop.

And just for completeness, depending on what you were doing with your index (the above constructs offer plenty of flexibility), you might use Parallel LINQ:

// First, filter 'e' based on 'i',
// then apply an action to remaining 'e'
collection
    .AsParallel()
    .Where((e,i) => /* filter with e,i */)
    .ForAll(e => { /* use e, but don't modify it */ });

// Using 'e' and 'i', produce a new collection,
// where each element incorporates 'i'
collection
    .AsParallel()
    .Select((e, i) => new MyWrapper(e, i));

We use AsParallel() above, because it's 2014 already, and we want to make good use of those multiple cores to speed things up. Further, for 'sequential' LINQ, you only get a ForEach() extension method on List<T> and Array ... and it's not clear that using it is any better than doing a simple foreach, since you are still running single-threaded for uglier syntax.

You could wrap the original enumerator with another that does contain the index information.

foreach (var item in ForEachHelper.WithIndex(collection))
{
    Console.Write("Index=" + item.Index);
    Console.Write(";Value= " + item.Value);
    Console.Write(";IsLast=" + item.IsLast);
    Console.WriteLine();
}

Here is the code for the ForEachHelper class.

public static class ForEachHelper
{
    public sealed class Item<T>
    {
        public int Index { get; set; }
        public T Value { get; set; }
        public bool IsLast { get; set; }
    }

    public static IEnumerable<Item<T>> WithIndex<T>(IEnumerable<T> enumerable)
    {
        Item<T> item = null;
        foreach (T value in enumerable)
        {
            Item<T> next = new Item<T>();
            next.Index = 0;
            next.Value = value;
            next.IsLast = false;
            if (item != null)
            {
                next.Index = item.Index + 1;
                yield return item;
            }
            item = next;
        }
        if (item != null)
        {
            item.IsLast = true;
            yield return item;
        }            
    }
}

Here's a solution I just came up with for this problem

Original code:

int index=0;
foreach (var item in enumerable)
{
    blah(item, index); // some code that depends on the index
    index++;
}

Updated code

enumerable.ForEach((item, index) => blah(item, index));

Extension Method:

    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumerable, Action<T, int> action)
    {
        var unit = new Unit(); // unit is a new type from the reactive framework (http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx) to represent a void, since in C# you can't return a void
        enumerable.Select((item, i) => 
            {
                action(item, i);
                return unit;
            }).ToList();

        return pSource;
    }

Just add your own index. Keep it simple.

int i = 0;
foreach (var item in Collection)
{
    item.index = i;
    ++i;
}

It's only going to work for a List and not any IEnumerable, but in LINQ there's this:

IList<Object> collection = new List<Object> { 
    new Object(), 
    new Object(), 
    new Object(), 
    };

foreach (Object o in collection)
{
    Console.WriteLine(collection.IndexOf(o));
}

Console.ReadLine();

@Jonathan I didn't say it was a great answer, I just said it was just showing it was possible to do what he asked :)

@Graphain Tôi không mong đợi nó sẽ nhanh - Tôi không hoàn toàn chắc chắn về cách thức hoạt động của nó, nó có thể nhắc lại trong toàn bộ danh sách mỗi lần để tìm một đối tượng phù hợp, sẽ là một so sánh tuyệt vời.

Điều đó nói rằng, Danh sách có thể giữ một chỉ mục của từng đối tượng cùng với số lượng.

Jonathan dường như có một ý tưởng tốt hơn, nếu anh ta sẽ giải thích?

Mặc dù vậy, sẽ tốt hơn nếu chỉ giữ một số lượng nơi bạn sẽ đến trong buổi thuyết trình, đơn giản hơn và dễ thích nghi hơn.

C # 7 cuối cùng cũng cho chúng ta một cách thanh lịch để làm điều này:

static class Extensions
{
    public static IEnumerable<(int, T)> Enumerate<T>(
        this IEnumerable<T> input,
        int start = 0
    )
    {
        int i = start;
        foreach (var t in input)
        {
            yield return (i++, t);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var s = new string[]
        {
            "Alpha",
            "Bravo",
            "Charlie",
            "Delta"
        };

        foreach (var (i, t) in s.Enumerate())
        {
            Console.WriteLine($"{i}: {t}");
        }
    }
}

Tại sao lại thuyết minh?!

Cách đơn giản nhất là sử dụng cho thay vì foreach nếu bạn đang sử dụng Danh sách :

for (int i = 0 ; i < myList.Count ; i++)
{
    // Do something...
}

Hoặc nếu bạn muốn sử dụng foreach:

foreach (string m in myList)
{
     // Do something...
}

Bạn có thể sử dụng điều này để biết chỉ số của mỗi vòng lặp:

myList.indexOf(m)

int index;
foreach (Object o in collection)
{
    index = collection.indexOf(o);
}

Điều này sẽ làm việc cho các bộ sưu tập hỗ trợ IList.

This is how I do it, which is nice for its simplicity/brevity, but if you're doing a lot in the loop body obj.Value, it is going to get old pretty fast.

foreach(var obj in collection.Select((item, index) => new { Index = index, Value = item }) {
    string foo = string.Format("Something[{0}] = {1}", obj.Index, obj.Value);
    ...
}

This answer: lobby the C# language team for direct language support.

The leading answer states:

Obviously, the concept of an index is foreign to the concept of enumeration, and cannot be done.

While this is true of the current C# language version (2020), this is not a conceptual CLR/Language limit, it can be done.

The Microsoft C# language development team could create a new C# language feature, by adding support for a new Interface IIndexedEnumerable

foreach (var item in collection with var index)
{
    Console.WriteLine("Iteration {0} has value {1}", index, item);
}

//or, building on @user1414213562's answer
foreach (var (item, index) in collection)
{
    Console.WriteLine("Iteration {0} has value {1}", index, item);
}

Nếu foreach ()được sử dụng và with var indexcó mặt, thì trình biên dịch dự kiến ​​bộ sưu tập mục sẽ khai báo IIndexedEnumerablegiao diện. Nếu giao diện vắng mặt, trình biên dịch có thể polyfill bọc nguồn với một đối tượng IndexedEnumerable, bổ sung mã để theo dõi chỉ mục.

interface IIndexedEnumerable<T> : IEnumerable<T>
{
    //Not index, because sometimes source IEnumerables are transient
    public long IterationNumber { get; }
}

Sau đó, CLR có thể được cập nhật để có theo dõi chỉ mục nội bộ, chỉ được sử dụng nếu with từ khóa được chỉ định và nguồn không trực tiếp thực hiệnIIndexedEnumerable

Tại sao:

• Foreach trông đẹp hơn và trong các ứng dụng kinh doanh, các vòng lặp foreach hiếm khi là một nút cổ chai hiệu năng
• Foreach có thể hiệu quả hơn trên bộ nhớ. Có một hệ thống các chức năng thay vì chuyển đổi sang các bộ sưu tập mới ở mỗi bước. Ai quan tâm nếu nó sử dụng một vài chu kỳ CPU nữa khi có ít lỗi bộ đệm CPU hơn và ít bộ sưu tập rác hơn?
• Yêu cầu bộ mã hóa để thêm mã theo dõi chỉ mục, làm hỏng vẻ đẹp
• Nó khá dễ thực hiện (vui lòng Microsoft) và tương thích ngược

Mặc dù hầu hết mọi người ở đây không phải là nhân viên của Microsoft, đây là một câu trả lời đúng, bạn có thể vận động Microsoft để thêm một tính năng như vậy. Bạn đã có thể xây dựng trình lặp của riêng mình với chức năng mở rộng và sử dụng bộ dữ liệu , nhưng Microsoft có thể rắc đường cú pháp để tránh chức năng mở rộng

Nếu bộ sưu tập là một danh sách, bạn có thể sử dụng List.IndexOf, như trong:

foreach (Object o in collection)
{
    // ...
    @collection.IndexOf(o)
}

Tốt hơn nên sử dụng từ khóa continuexây dựng an toàn như thế này

int i=-1;
foreach (Object o in collection)
{
    ++i;
    //...
    continue; //<--- safe to call, index will be increased
    //...
}

Bạn có thể viết vòng lặp của bạn như thế này:

var s = "ABCDEFG";
foreach (var item in s.GetEnumeratorWithIndex())
{
    System.Console.WriteLine("Character: {0}, Position: {1}", item.Value, item.Index);
}

Sau khi thêm các cấu trúc và phương pháp mở rộng sau đây.

Phương thức struct và phần mở rộng đóng gói chức năng Enumerable.Select.

public struct ValueWithIndex<T>
{
    public readonly T Value;
    public readonly int Index;

    public ValueWithIndex(T value, int index)
    {
        this.Value = value;
        this.Index = index;
    }

    public static ValueWithIndex<T> Create(T value, int index)
    {
        return new ValueWithIndex<T>(value, index);
    }
}

public static class ExtensionMethods
{
    public static IEnumerable<ValueWithIndex<T>> GetEnumeratorWithIndex<T>(this IEnumerable<T> enumerable)
    {
        return enumerable.Select(ValueWithIndex<T>.Create);
    }
}

Giải pháp của tôi cho vấn đề này là một phương pháp mở rộng WithIndex(),

http://code.google.com.vn/p/ub-dotnet-utilities/source/browse/trunk/Src/Utilities/Extensions/EnumerableExtensions.cs

Sử dụng nó như

var list = new List<int> { 1, 2, 3, 4, 5, 6 };    

var odd = list.WithIndex().Where(i => (i.Item & 1) == 1);
CollectionAssert.AreEqual(new[] { 0, 2, 4 }, odd.Select(i => i.Index));
CollectionAssert.AreEqual(new[] { 1, 3, 5 }, odd.Select(i => i.Item));

Để thu hút sự chú ý, Phil Haack chỉ viết một ví dụ về điều này trong bối cảnh của một Đại biểu Templated ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx )

Thực tế, ông viết một phương thức mở rộng bao bọc phép lặp trong lớp "IteratedItem" (xem bên dưới) cho phép truy cập vào chỉ mục cũng như phần tử trong quá trình lặp.

public class IndexedItem<TModel> {
  public IndexedItem(int index, TModel item) {
    Index = index;
    Item = item;
  }

  public int Index { get; private set; }
  public TModel Item { get; private set; }
}

Tuy nhiên, mặc dù điều này sẽ ổn trong môi trường không có Dao cạo nếu bạn đang thực hiện một thao tác duy nhất (nghĩa là có thể được cung cấp dưới dạng lambda), nó sẽ không thay thế vững chắc cú pháp for / foreach trong ngữ cảnh không dao cạo .

Tôi không nghĩ rằng nó sẽ khá hiệu quả, nhưng nó hoạt động:

@foreach (var banner in Model.MainBanners) {
    @Model.MainBanners.IndexOf(banner)
}

Tôi đã xây dựng điều này trong LINQPad :

var listOfNames = new List<string>(){"John","Steve","Anna","Chris"};

var listCount = listOfNames.Count;

var NamesWithCommas = string.Empty;

foreach (var element in listOfNames)
{
    NamesWithCommas += element;
    if(listOfNames.IndexOf(element) != listCount -1)
    {
        NamesWithCommas += ", ";
    }
}

NamesWithCommas.Dump();  //LINQPad method to write to console.

Bạn cũng có thể chỉ cần sử dụng string.join:

var joinResult = string.Join(",", listOfNames);

Tôi không tin có một cách để có được giá trị của lần lặp hiện tại của vòng lặp foreach. Đếm chính mình, dường như là cách tốt nhất.

Tôi có thể hỏi, tại sao bạn muốn biết?

Có vẻ như bạn hầu như sẽ làm một trong ba điều sau:

1) Lấy đối tượng từ bộ sưu tập, nhưng trong trường hợp này bạn đã có nó.

2) Đếm các đối tượng để xử lý bài sau này ... các bộ sưu tập có thuộc tính Đếm mà bạn có thể sử dụng.

3) Đặt thuộc tính trên đối tượng dựa trên thứ tự của nó trong vòng lặp ... mặc dù bạn có thể dễ dàng thiết lập điều đó khi bạn thêm đối tượng vào bộ sưu tập.

Trừ khi bộ sưu tập của bạn có thể trả về chỉ mục của đối tượng thông qua một số phương thức, cách duy nhất là sử dụng bộ đếm như trong ví dụ của bạn.

Tuy nhiên, khi làm việc với các chỉ mục, câu trả lời hợp lý duy nhất cho vấn đề là sử dụng vòng lặp for. Bất cứ điều gì khác giới thiệu độ phức tạp của mã, chưa kể đến độ phức tạp về thời gian và không gian.

Còn những thứ như thế này thì sao? Lưu ý rằng myDelrictString có thể là null nếu myEnumerable trống.

IEnumerator enumerator = myEnumerable.GetEnumerator();
string myDelimitedString;
string current = null;

if( enumerator.MoveNext() )
    current = (string)enumerator.Current;

while( null != current)
{
    current = (string)enumerator.Current; }

    myDelimitedString += current;

    if( enumerator.MoveNext() )
        myDelimitedString += DELIMITER;
    else
        break;
}

Tôi chỉ gặp vấn đề này, nhưng suy nghĩ xung quanh vấn đề trong trường hợp của tôi đã đưa ra giải pháp tốt nhất, không liên quan đến giải pháp mong đợi.

Về cơ bản, đây có thể là một trường hợp phổ biến, tôi đang đọc từ một danh sách nguồn và tạo các đối tượng dựa trên chúng trong danh sách đích, tuy nhiên, tôi phải kiểm tra xem các mục nguồn có hợp lệ trước không và muốn trả về hàng bất kỳ lỗi. Thoạt nhìn, tôi muốn đưa chỉ mục vào trình liệt kê của đối tượng tại thuộc tính Hiện tại, tuy nhiên, khi tôi sao chép các phần tử này, tôi hoàn toàn biết chỉ mục hiện tại từ đích hiện tại. Rõ ràng nó phụ thuộc vào đối tượng đích của bạn, nhưng đối với tôi đó là Danh sách và rất có thể nó sẽ thực hiện ICollection.

I E

var destinationList = new List<someObject>();
foreach (var item in itemList)
{
  var stringArray = item.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries);

  if (stringArray.Length != 2)
  {
    //use the destinationList Count property to give us the index into the stringArray list
    throw new Exception("Item at row " + (destinationList.Count + 1) + " has a problem.");
  }
  else
  {
    destinationList.Add(new someObject() { Prop1 = stringArray[0], Prop2 = stringArray[1]});
  }
}

Không phải lúc nào cũng áp dụng, nhưng thường đủ để được đề cập, tôi nghĩ.

Dù sao đi nữa, vấn đề là đôi khi có một giải pháp không rõ ràng đã có trong logic mà bạn có ...

Tôi không chắc chắn những gì bạn đã cố gắng làm với thông tin chỉ mục dựa trên câu hỏi. Tuy nhiên, trong C #, bạn thường có thể điều chỉnh phương thức IEnumerable.Select để lấy chỉ mục ra khỏi bất cứ thứ gì bạn muốn. Chẳng hạn, tôi có thể sử dụng một cái gì đó như thế này cho dù giá trị là số lẻ hay số chẵn.

string[] names = { "one", "two", "three" };
var oddOrEvenByName = names
    .Select((name, index) => new KeyValuePair<string, int>(name, index % 2))
    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

Điều này sẽ cung cấp cho bạn một từ điển theo tên cho dù mục đó là số lẻ (1) hay thậm chí (0) trong danh sách.