169

是否有与 Pythonenumerate()和 Ruby等效的 C# each_with_index？

4

10 回答 10

270

为此，我保留了此扩展方法：

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

或者允许break类似的行为：

public static bool Each<T>(this IEnumerable<T> ie, Func<T, int, bool> action)
{
    int i = 0;
    foreach (T e in ie) if (!action(e, i++)) return false;
    return true;
}

var strings = new List<string>() { "a", "b", "c" };

bool iteratedAll = strings.Each ((str, n)) =>
{
    if (str == "b") return false;
    return true;
});
于 2009-02-06T19:49:39.877 回答
233

您可以执行以下操作

foreach (var it in someCollection.Select((x, i) => new { Value = x, Index = i }) )
{
   if (it.Index > SomeNumber) //      
}

这将为集合中的每个条目创建一个匿名类型值。它将有两个属性

  • Value：与集合中的原始值
  • Index: 带有集合内的索引
于 2009-02-06T19:04:28.130 回答
68

C# foreach 没有内置索引。您需要在 foreach 循环之外添加一个整数并每次递增。

int i = -1;
foreach (Widget w in widgets)
{
   i++;
   // do something
}

或者，您可以使用标准 for 循环，如下所示：

for (int i = 0; i < widgets.Length; i++)
{
   w = widgets[i];
   // do something
}
于 2009-02-06T19:04:05.883 回答
16

我喜欢能够使用foreach，所以我做了一个扩展方法和一个结构：

public struct EnumeratedInstance<T>
{
    public long cnt;
    public T item;
}

public static IEnumerable<EnumeratedInstance<T>> Enumerate<T>(this IEnumerable<T> collection)
{
    long counter = 0;
    foreach (var item in collection)
    {
        yield return new EnumeratedInstance<T>
        {
            cnt = counter,
            item = item
        };
        counter++;
    }
}

和一个例子使用：

foreach (var ii in new string[] { "a", "b", "c" }.Enumerate())
{
    Console.WriteLine(ii.item + ii.cnt);
}

一件好事是，如果您习惯了 Python 语法，您仍然可以使用它：

foreach (var ii in Enumerate(new string[] { "a", "b", "c" }))
于 2012-08-10T08:30:06.260 回答
15

除了已经给出的 LINQ 答案之外，我还有一个“SmartEnumerable”类，它允许您获取索引和“第一个/最后一个”-ness。它在语法方面有点难看，但您可能会发现它很有用。

我们可能可以在非泛型类型中使用静态方法来改进类型推断，隐式类型也会有所帮助。

于 2009-02-06T19:07:08.077 回答
6

我的解决方案涉及我为通用实用程序创建的一个简单的 Pair 类，它在操作上与框架类 KeyValuePair 基本相同。然后我为 IEnumerable 创建了几个扩展函数，称为 Ordinate（来自集合论术语“ ordinal ”）。

这些函数将为每个项目返回一个包含索引的 Pair 对象和项目本身。

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));
}
于 2009-02-06T19:12:05.087 回答
3

不，那里没有。

正如其他人所展示的，有一些方法可以模拟 Ruby 的行为。但是可能有一个类型实现了不公开索引的IEnumerable 。

于 2009-02-06T19:13:47.453 回答
1

我刚刚想出了有趣的解决方案：

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

用法：

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);
}
于 2011-01-21T11:10:23.880 回答
1

这是你的收藏

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

为此集合创建一系列索引

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

使用范围迭代索引

indexes.ForEach(i => values[i] += i);
indexes.ForEach(i => Console.Write("[{0}] = {1}", i, values[i]));
于 2012-05-04T06:27:40.950 回答
0

这取决于您使用的课​​程。

Dictionary<(Of <(TKey, TValue>)>) 类例子支持这个

Dictionary<(Of <(TKey, TValue>)>) 泛型类提供从一组键到一组值的映射。

出于枚举的目的，字典中的每个项目都被视为表示值及其键的 KeyValuePair<(Of <(TKey, TValue>)>) 结构。返回项目的顺序未定义。

foreach（myDictionary 中的 KeyValuePair kvp）{...}

于 2009-02-06T19:04:22.403 回答