.NET IEnumerable 是否有相当于 Python 的 enumerate()

Question

我找不到相关问题。

在python 中，您可以轻松地遍历一个序列（list、generator 等）并同时收集迭代的索引，这要感谢enumerate(seq)，就像这样：

>>> for (i,item) in enumerate(["toto","titi","tutu"]):
...     print i, item
...
0 toto
1 titi
2 tutu

IEnumerable 是否有类似的东西，例如，将 IEnumerable<T> 转换为 IEnumerable<Tuple<Int32,T>> ？

（由于Select() 中的正确功能，我知道这很容易完成......但如果它存在，我宁愿使用它:)）

更新 仅供参考，我很好奇这种可能性能够做类似的事情：“给我满足这个条件的最后一个项目的索引”，然后通过：

myEnumeration.First(t => some condition on t.Item2 ... ).Item1;

Answer 1

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, o) in s.Enumerate())
            Console.WriteLine($"{i}: {o}");
    }
}

Answer 2

您可以使用 KeyValuePair<,> 结构，而不是使用 Tuple<,>（这是一个类）。这将避免枚举时的内存分配（不是说它们非常昂贵，但仍然如此）。

public static IEnumerable<KeyValuePair<int, T>> Enumerate<T>(this IEnumerable<T> items) {
    return items.Select((item, key) => new KeyValuePair(key, item));
}

Answer 3

至于可以满足您要求的特定功能，我不知道 .NET 是否包含它。然而，最快的方法就是这样做：

int id = 0;
foreach(var elem in someList)
{
    ... doStuff ...
    id++;
}

编辑：这是一个可以按照您的要求使用 yield return 的函数，但它的缺点是每次迭代都需要分配一次 GC：

public static IEnumerable<Tuple<int, T>> Enumerate<T>(IEnumerable<T> list)
{
    int id = 0;
    foreach(var elem in list)
    {
        yield return new Tuple<int, T>(id, elem);
        id++;
    }
}

Answer 4

这是我对自己问题的回答......

如果它不存在，我还不如这样做，而无需实际编写for/foreach：

var items = new List<String> { "toto", "titi", "tutu" };

var enumerated = items.Select((x, i) => new Tuple<int, String>(i, x));

foreach (var t in enumerated)
{
    Console.WriteLine(String.Format("{0} : {1}", t.Item1, t.Item2));

}

哪个打印：

0 : toto
1 : titi
2 : tutu

这是一个单线......一个丑陋的，但无论如何都是一个单线:)

Answer 5

这是一个扩展方法，它将返回元组序列，其中第一项是序列中的数字，第二项是源序列中的值。

public static IEnumerable<Tuple<int, T>> Enumerate<T>(this IEnumerable<T> source, int start = 0)
{
    return source.Select((value, index) => new Tuple<int, T>(index + start, value));
}

示例：

var source = new[] { "apple", "pear", "banana", "orange", "lemon" };
var enumerated1 = source.Enumerate();   // { (0, "apple"), (1, "pear"), (2, "banana"), (3, "orange"), (4, "lemon") }
var enumerated2 = source.Enumerate(3);  // { (3, "apple"), (4, "pear"), (5, "banana"), (6, "orange"), (7, "lemon") }