foreach 루프의 현재 반복 색인을 어떻게 얻습니까?

foreach 루프의 현재 반복을 나타내는 값을 얻기 위해 C #에서 내가 경험하지 않은 희귀 언어 구조 (최근에 배운 소수, 스택 오버플로에 대한 일부)가 있습니까?

예를 들어, 현재 상황에 따라 이와 같은 작업을 수행합니다.

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

는 foreach구현 컬렉션을 통해 반복입니다 IEnumerable. GetEnumerator컬렉션 을 호출하여이 작업 을 수행하면을 반환합니다 Enumerator.

이 열거 자에는 메소드와 속성이 있습니다.

• MoveNext ()
• 흐름

Current열거자가 현재있는 개체를 반환하고 다음 개체로 MoveNext업데이트 Current합니다.

인덱스 개념은 열거 개념과는 다른 개념이므로 수행 할 수 없습니다.

이 때문에 대부분의 컬렉션은 인덱서와 for 루프 구문을 사용하여 순회 할 수 있습니다.

이 상황에서 로컬 변수로 색인을 추적하는 것과 비교하여 for 루프를 사용하는 것이 좋습니다.

Ian Mercer는 Phil Haack의 블로그 에 이와 유사한 솔루션을 게시했습니다 .

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

아이템을 얻습니다 (item.value LINQ의 오버로드를item.i 사용하여 )과 색인 ( )을 .Select

[inside Select] 함수의 두 번째 매개 변수는 소스 요소의 인덱스를 나타냅니다.

그만큼 new { i, value } 새로운 창조하고 익명의 개체를 .

다음을 사용하여 힙 할당을 피할 수 있습니다. ValueTupleC # 7.0 이상을 사용 경우 .

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

item.자동 파괴를 사용하여를 제거 할 수도 있습니다 .

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

마지막으로 C # 7에는 foreach루프 (예 : 튜플) 내부에 인덱스를 가져 오는 적절한 구문이 있습니다 .

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

약간의 확장 방법이 필요합니다.

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

다음과 같이 할 수 있습니다 :

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));
    }
}

for대부분의 경우 루프가 더 나은 선택 이라는 의견에 동의하지 않습니다 .

foreach유용한 구문이며 for모든 상황에서 루프로 대체 할 수 없습니다 .

예를 들어 DataReader가 있고 foreach이를 사용하여 모든 레코드를 반복하는 경우 자동으로 Dispose를 호출합니다. 메소드를 하고 리더를 닫습니다 (연결을 자동으로 닫을 수 있음). 따라서 리더를 닫는 것을 잊어 버린 경우에도 연결 누출을 방지하므로 더 안전합니다.

(항상 독자를 닫는 것이 좋지만 컴파일러가 그렇지 않은 경우 컴파일러가이를 포착하지는 않습니다. 모든 독자를 닫았다 고 보장 할 수는 없지만 연결을 통해 누수가 발생하지 않도록 할 수는 있습니다) foreach를 사용하는 습관.)

Dispose유용한 메소드 의 내재적 호출에 대한 다른 예가있을 수 있습니다 .

리터럴 답변-경고, 성능은 int인덱스를 추적 하는 데 사용하는 것만 큼 좋지 않을 수 있습니다 . 적어도를 사용하는 것보다 낫습니다 IndexOf.

컬렉션의 각 항목을 인덱스를 알고있는 익명의 개체로 감싸려면 Select의 인덱싱 오버로드를 사용해야합니다. 이것은 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);
}

LINQ, C # 7 및 System.ValueTupleNuGet 패키지를 사용하여 다음을 수행 할 수 있습니다.

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

일반 foreach구문을 사용하고 개체의 구성원이 아닌 값과 인덱스에 직접 액세스 할 수 있으며 두 필드를 모두 루프 범위에만 유지합니다. 이러한 이유로 C # 7 및을 사용할 수 있다면 이것이 최선의 해결책이라고 생각합니다 System.ValueTuple.

@ FlySwat의 답변을 사용 하여이 솔루션을 생각해 냈습니다.

//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
}

열거자를 사용 GetEnumerator하고 루프를 사용하여 for반복합니다. 그러나 트릭은 루프 조건을 만드는 것 listEnumerator.MoveNext() == true입니다.

MoveNext다음 요소가 있고 액세스 할 수있는 경우 열거 자의 메서드가 true를 반환하므로 반복 할 요소가 부족할 때 루프 조건으로 인해 루프가 중지됩니다.

카운터 변수를 사용하는 데 아무런 문제가 없습니다. 사실, 사용 여부 for, foreach while또는 do, 카운터 변수 어딘가에 선언 증가해야합니다.

적절하게 색인이 생성 된 모음이 있는지 확실하지 않은 경우이 관용구를 사용하십시오.

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

그렇지 않으면 색인 작성 가능 하다는 것을 알고 있다면 이것을 사용 하십시오. 컬렉션 인덱스 액세스에 대한 O (1)이다 (이것은이 될 것이다 Array아마를 위해 List<T>(설명서를 말하지 않는다), 그러나 반드시 (예 : 다른 유형 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'
}

'수동으로'작동 할 필요는 없습니다. IEnumerator 호출하여 MoveNext()및 심문하는 것은 Current- foreach특히 당신이 항목을 생략해야하는 경우, ... 귀찮게 단지를 사용하는 것이 당신을 저장 continue루프의 본문에.

그리고 당신이 무엇에 따라 완전성을 위해 을 위해 인덱스 수행 한 작업 에 따라 (위의 구조는 많은 유연성을 제공합니다) 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));

우리는 AsParallel()이미 2014 년이기 때문에 위를 사용하며 속도를 높이기 위해 여러 코어를 잘 사용하려고합니다. 또한 '순차적'LINQ의 경우 ForEach()확장 방법 만 사용 List<T>하고Array ... 더 간단한 foreach구문을 수행하는 것보다 그 방법을 사용하는 것이 더 나쁘다는 것은 확실하지 않습니다 .

원래 열거자를 인덱스 정보가 포함 된 다른 열거 자로 랩핑 할 수 있습니다.

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

다음은 ForEachHelper클래스 코드입니다 .

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;
        }            
    }
}

이 문제에 대해 방금 생각 해낸 해결책이 있습니다.

원본 코드 :

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

업데이트 된 코드

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

확장 방법 :

    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;
    }

자신의 색인을 추가하십시오. 간단하게 유지하십시오.

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

IEnumerable이 아닌 List에서만 작동하지만 LINQ에는 다음이 있습니다.

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 나는 그것이 훌륭한 대답이라고 말하지 않았고, 방금 그가 요청한 것을 할 수 있음을 보여주고 있다고 말했다. :)

@Graphain 나는 그것이 빠를 것이라고 기대하지 않을 것입니다-그것이 어떻게 작동하는지 완전히 확신하지 못합니다. 매일 전체 목록을 반복하여 일치하는 객체를 찾을 때마다 비교할 수 있습니다.

즉, List는 개수와 함께 각 객체의 색인을 유지할 수 있습니다.

조나단이 더 정교하게 생각한다면 더 좋은 생각을 가지고있는 것 같습니까?

그러나 foreach의 위치, 단순성 및 적응성을 높이는 것이 좋습니다.

C # 7은 마침내이 작업을 수행하는 우아한 방법을 제공합니다.

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}");
        }
    }
}

왜 foreach ?!

List를 사용하는 경우 가장 간단한 방법은 foreach 대신 사용 하는 것입니다 .

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

또는 foreach를 사용하려는 경우 :

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

이것을 사용하여 각 루프의 인덱스를 알 수 있습니다.

myList.indexOf(m)

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

이것은 컬렉션을 지원하는 데 효과적입니다 IList.

이것이 내가하는 방법입니다. 단순성 / 간결함에 좋지만 루프 본문에서 많은 obj.Value일을하면 꽤 빨리 늙을 것입니다.

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

이 답변 : C # 언어 팀 로비에서 직접 언어 지원.

주요 답변은 다음과 같습니다.

분명히, 인덱스 개념은 열거 개념과는 다른 개념이므로 수행 할 수 없습니다.

이것이 현재 C # 언어 버전 (2020)에서는 사실이지만, 이것은 개념적 CLR / 언어 제한이 아니며 수행 할 수 있습니다.

Microsoft C # 언어 개발 팀은 새로운 인터페이스 IIndexedEnumerable에 대한 지원을 추가하여 새로운 C # 언어 기능을 만들 수 있습니다.

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);
}

foreach ()가 사용되고 있으면 with var index컴파일러는 항목 컬렉션이 IIndexedEnumerable인터페이스 를 선언 할 것으로 예상합니다 . 인터페이스가 없으면 컴파일러는 IndexedEnumerable 객체로 소스를 래핑하여 인덱스를 추적하기위한 코드를 추가 할 수 있습니다.

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

나중에 CLR을 업데이트하여 내부 인덱스 추적을 수행 할 수 있습니다. 이는 with키워드가 지정되고 소스가 직접 구현하지 않은 경우에만 사용됩니다.IIndexedEnumerable

왜:

• Foreach가 더 좋아 보이고 비즈니스 응용 프로그램에서 foreach 루프는 성능 병목 현상이 거의 없습니다.
• Foreach는 메모리에서 더 효율적일 수 있습니다. 각 단계에서 새 컬렉션으로 변환하는 대신 함수 파이프 라인이 있어야합니다. CPU 캐시 오류가 적고 가비지 수집이 적을 때 CPU주기를 몇 개 더 사용하면 누가 신경 쓰나요?
• 색인 추적 코드를 추가하기 위해 코더를 요구하면 아름다움을 망치고
• 구현하기가 쉽고 (Microsoft에 문의하십시오) 이전 버전과 호환됩니다

대부분의 사람들이 여기에 마이크로 소프트의 직원 수는 없지만, 이것이 정답은, 당신은 이러한 기능을 추가하려면 Microsoft 로비 할 수 있습니다. 이미 확장 기능을 사용 하여 자체 반복기를 빌드 하고 튜플을 사용할 수 있지만 Microsoft는 확장 기능을 피하기 위해 구문 설탕을 뿌릴 수 있습니다.

컬렉션이 목록이면 다음과 같이 List.IndexOf를 사용할 수 있습니다.

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

continue이와 같은 키워드 안전 구성 을 사용하는 것이 좋습니다.

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

다음과 같이 루프를 작성할 수 있습니다.

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

다음 구조체 및 확장 방법을 추가 한 후

구조체 및 확장 메서드는 Enumerable을 캡슐화합니다. 기능을 선택합니다.

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);
    }
}

이 문제에 대한 나의 해결책은 확장 방법입니다 WithIndex().

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

처럼 사용

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));

필자는 Phil Haack이 Razor Templated Delegate ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx ) 와 관련하여 이에 대한 예를 썼습니다.

효과적으로 반복을 "IteratedItem"클래스 (아래 참조)로 래핑하는 확장 메소드를 작성하여 반복 중에 요소뿐만 아니라 색인에 대한 액세스를 허용합니다.

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; }
}

그러나 Razor가 아닌 환경에서는 단일 작업 (예 : 람다로 제공 될 수있는 작업)을 수행하는 경우 Razor가 아닌 컨텍스트에서 for / foreach 구문을 완전히 대체하지는 않습니다. .

나는 이것이 매우 효율적이라고 생각하지 않지만 작동합니다.

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

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.

당신은 또한 사용할 수 있습니다 string.join:

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

foreach 루프의 현재 반복 값을 얻는 방법이 없다고 생각합니다. 자신을 세는 것이 가장 좋은 방법 인 것 같습니다.

왜 물어보고 싶습니까?

대부분의 likley가 다음 세 가지 중 하나를 수행하는 것 같습니다.

1) 컬렉션에서 객체 가져 오기, 그러나이 경우 이미 가지고 있습니다.

2) 나중에 사후 처리를 위해 객체를 계산합니다 ... 컬렉션에는 사용할 수있는 Count 속성이 있습니다.

3) 루프의 순서에 따라 객체의 속성을 설정합니다 ...하지만 컬렉션에 객체를 추가했을 때 쉽게 설정할 수 있습니다.

컬렉션이 어떤 메소드를 통해 객체의 인덱스를 반환하지 않는 한 유일한 방법은 예제와 같이 카운터를 사용하는 것입니다.

그러나 인덱스 작업시 문제에 대한 합리적인 대답은 for 루프를 사용하는 것입니다. 다른 어떤 것도 시간과 공간의 복잡성을 언급하지 않고 코드 복잡성을 도입합니다.

이런 건 어때? myEnumerable이 비어 있으면 myDelimitedString이 널일 수 있습니다.

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;
}

방금이 문제가 있었지만 내 경우의 문제를 생각하면 예상 솔루션과 관련이없는 최상의 솔루션을 얻었습니다.

꽤 일반적인 경우 일 수 있습니다. 기본적으로 하나의 소스 목록에서 읽고 대상 목록에서 객체를 기반으로 객체를 생성하지만 소스 항목이 먼저 유효한지 확인하고 모든 행을 반환해야합니다 오류. 언뜻 보면, Current 속성에서 개체의 열거 자에 인덱스를 가져오고 싶지만, 이러한 요소를 복사 할 때 어쨌든 현재 대상에서 현재 인덱스를 암시 적으로 알고 있습니다. 분명히 대상 객체에 따라 다르지만 나에게 그것은 목록이었고 대부분 ICollection을 구현할 것입니다.

즉

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]});
  }
}

항상 적용 가능한 것은 아니지만 언급 할 가치가있는 경우가 많습니다.

어쨌든 요점은 때로는 이미 가지고있는 논리에 이미 명백한 해결책이 있다는 것입니다 ...

질문에 기반한 색인 정보로 무엇을하려고했는지 잘 모르겠습니다. 그러나 C #에서는 일반적으로 IEnumerable.Select 메서드를 적용하여 원하는 인덱스를 가져올 수 있습니다. 예를 들어, 값이 홀수인지 짝수인지에 대해 이와 같은 것을 사용할 수 있습니다.

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);

이렇게하면 목록에서 항목이 홀수 (1)인지 짝수 (0)인지에 따라 이름별로 사전이 표시됩니다.