6

IEnumerable<T>公开一个枚举器，因此可以枚举对象。此接口公开的索引没有任何内容。IList<T>是关于索引的，因为它公开了IndexOf方法。

那么 Enumerable.ElementAt 的意义何在？我刚刚阅读了这个 LINQ 扩展方法的文档：

返回序列中指定索引处的元素。

嗯，是的，它是关于一个序列，而不仅仅是一个IEnumerable. 阅读注释：

如果源的类型实现了 IList，则该实现用于获取指定索引处的元素。否则，此方法获取指定元素。

好的，所以如果具体类型实现了继承自的东西IList<T>（这是一个实际的序列），那么它与IndexOf(). 如果不是，它会迭代直到达到索引。

这是一个示例场景：

// Some extension method exposed by a lib
// I know it's not a good piece of code, but let's say it's coded this way:
public static class EnumerableExtensions
{
    // Returns true if all elements are ordered
    public static bool IsEnumerableOrdered(this IEnumerable<int> value)
    {
        // Iterates over elements using an index
        for (int i = 0; i < value.Count() - 1; i++)
        {
            if (value.ElementAt(i) > value.ElementAt(i + 1))
            {
                return false;
            }
        }

        return true;
    }
}

// Here's a collection that is enumerable, but doesn't always returns
// its objects in the same order
public class RandomAccessEnumerable<T> : IEnumerable<T>
{
    private List<T> innerList;
    private static Random rnd = new Random();

    public RandomAccessEnumerable(IEnumerable<T> list)
    {
        innerList = list.ToList();
    }

    public IEnumerator<T> GetEnumerator()
    {
        var listCount = this.innerList.Count;
        List<int> enumeratedIndexes = new List<int>();

        for (int i = 0; i < listCount; i++)
        {
            int randomIndex = -1;
            while (randomIndex < 0 || enumeratedIndexes.Contains(randomIndex))
            {
                randomIndex = rnd.Next(listCount);
            }

            enumeratedIndexes.Add(randomIndex);
            yield return this.innerList[randomIndex];
        }
    }

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

// Here's some test program
internal class Program
{
    private static void Main()
    {
        var test0 = new List<int> { 0, 1, 2, 3 };
        var test1 = new RandomAccessEnumerable<int>(test0);

        Console.WriteLine("With List");
        Console.WriteLine(test0.IsEnumerableOrdered()); // true
        Console.WriteLine(test0.IsEnumerableOrdered()); // true
        Console.WriteLine(test0.IsEnumerableOrdered()); // true
        Console.WriteLine(test0.IsEnumerableOrdered()); // true
        Console.WriteLine(test0.IsEnumerableOrdered()); // true

        Console.WriteLine("With RandomAccessEnumerable");
        Console.WriteLine(test1.IsEnumerableOrdered()); // might be true or false
        Console.WriteLine(test1.IsEnumerableOrdered()); // might be true or false
        Console.WriteLine(test1.IsEnumerableOrdered()); // might be true or false
        Console.WriteLine(test1.IsEnumerableOrdered()); // might be true or false
        Console.WriteLine(test1.IsEnumerableOrdered()); // might be true or false

        Console.Read();
    }
}

因此，RandomAccessEnumerable可能会以随机顺序返回枚举对象，您不能依赖简单的IEnumerable<T>界面来假设您的元素已编入索引。所以你不想ElementAt使用IEnumerable.

在上面的例子中，我认为IsEnumerableOrdered应该需要一个IList<T>参数，因为它意味着元素是一个序列。我实际上找不到该ElementAt方法有用且不易出错的场景。

4

1 回答 1

6

有很多IEnumerable类型，例如数组或列表。所有IList类型（Array也实现）都有一个索引器，您可以使用它来访问特定索引处的元素。

Enumerable.ElementAt如果可以成功转换序列，则将使用此选项IList。否则将被枚举。

所以这只是一种方便的方式来访问所有类型的给定索引处的元素IEnumerable。

这样做的好处是您可以稍后更改类型，而无需更改所有出现的arr[index].

对于它的价值，这里是反射（ILSpy）方法来演示我所说的：

public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    IList<TSource> list = source as IList<TSource>;
    if (list != null)
    {
        return list[index];
    }
    if (index < 0)
    {
        throw Error.ArgumentOutOfRange("index");
    }
    TSource current;
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            if (index == 0)
            {
                current = enumerator.Current;
                return current;
            }
            index--;
        }
        throw Error.ArgumentOutOfRange("index");
    }
    return current;
}
于 2013-01-15T13:29:44.027 回答