foreach mit Index

Question

Gibt es ein C#-Äquivalent zu Pythons enumerate() und Ruby's each_with_index ?

Answer 1

Meine Lösung besteht aus einer einfachen Pair-Klasse, die ich für allgemeine Zwecke erstellt habe und die operativ im Wesentlichen mit der Framework-Klasse KeyValuePair identisch ist. Dann habe ich ein paar Erweiterungsfunktionen für IEnumerable mit dem Namen Ordinate (aus dem Begriff der Mengenlehre " Ordinal ").

Diese Funktionen geben für jedes Element ein Pair-Objekt zurück, das den Index und das Element selbst enthält.

public static IEnumerable<Pair<Int32, X>> Ordinate<X>(this IEnumerable<X> lhs)
{
    return lhs.Ordinate(0);
}

public static IEnumerable<Pair<Int32, X>> Ordinate<X>(this IEnumerable<X> lhs, Int32 initial)
{
    Int32 index = initial - 1;

    return lhs.Select(x => new Pair<Int32, X>(++index, x));
}

Answer 2

Nein, die gibt es nicht.

Wie andere Leute gezeigt haben, gibt es Möglichkeiten, das Verhalten von Ruby zu simulieren. Aber es ist möglich, einen Typ zu haben, der Folgendes implementiert IEnumerable die keinen Index ausweist.

Answer 3

Ich habe gerade eine interessante Lösung gefunden:

public class DepthAware<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> source;

    public DepthAware(IEnumerable<T> source)
    {
        this.source = source;
        this.Depth = 0;
    }

    public int Depth { get; private set; }

    private IEnumerable<T> GetItems()
    {
        foreach (var item in source)
        {
            yield return item;
            ++this.Depth;
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return GetItems().GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

// Generic type leverage and extension invoking
public static class DepthAware
{
    public static DepthAware<T> AsDepthAware<T>(this IEnumerable<T> source)
    {
        return new DepthAware<T>(source);
    }

    public static DepthAware<T> New<T>(IEnumerable<T> source)
    {
        return new DepthAware<T>(source);
    }
}

Verwendung:

var chars = new[] {'a', 'b', 'c', 'd', 'e', 'f', 'g'}.AsDepthAware();

foreach (var item in chars)
{
    Console.WriteLine("Char: {0}, depth: {1}", item, chars.Depth);
}

Answer 4

Dies ist Ihre Sammlung

var values = new[] {6, 2, 8, 45, 9, 3, 0};

Erstellen Sie eine Reihe von Indizes für diese Sammlung

var indexes = Enumerable.Range(0, values.Length).ToList();

Verwenden Sie den Bereich, um mit Index zu iterieren

indexes.ForEach(i => values[i] += i);
indexes.ForEach(i => Console.Write("[{0}] = {1}", i, values[i]));

Answer 5

Das hängt von der Klasse ab, die Sie verwenden.

Dictionary<(Of <(TKey, TValue>)>) Class For Example Support This

Die generische Klasse Dictionary<(Of <(TKey, TValue>)>) bietet eine Zuordnung von einer Menge von Schlüsseln zu einer Menge von Werten.

Für die Zwecke der Aufzählung wird jedes Element im Wörterbuch als KeyValuePair<(Of <(TKey, TValue>)>) Struktur behandelt, die einen Wert und seinen Schlüssel darstellt. Die Reihenfolge, in der die Elemente zurückgegeben werden, ist undefiniert.

foreach (KeyValuePair kvp in myDictionary) {...}