162

我写了这个:

public static class EnumerableExtensions
{
    public static int IndexOf<T>(this IEnumerable<T> obj, T value)
    {
        return obj
            .Select((a, i) => (a.Equals(value)) ? i : -1)
            .Max();
    }

    public static int IndexOf<T>(this IEnumerable<T> obj, T value
           , IEqualityComparer<T> comparer)
    {
        return obj
            .Select((a, i) => (comparer.Equals(a, value)) ? i : -1)
            .Max();
    }
}

但我不知道它是否已经存在,是吗?

4

12 回答 12

137

我会质疑智慧,但也许:

source.TakeWhile(x => x != value).Count();

(如果需要,可以EqualityComparer<T>.Default用来模拟!=) - 但如果没有找到,你需要注意返回 -1 ......所以也许只是做很长的路

public static int IndexOf<T>(this IEnumerable<T> source, T value)
{
    int index = 0;
    var comparer = EqualityComparer<T>.Default; // or pass in as a parameter
    foreach (T item in source)
    {
        if (comparer.Equals(item, value)) return index;
        index++;
    }
    return -1;
}
于 2009-08-17T21:43:07.617 回答
52

将事物作为 IEnumerable 输出的全部意义在于,您可以懒惰地迭代内容。因此,实际上并没有索引的概念。对于 IEnumerable,您正在做的事情真的没有多大意义。如果您需要支持按索引访问的东西,请将其放入实际的列表或集合中。

于 2009-08-17T21:48:25.907 回答
28

我会这样实现它:

public static class EnumerableExtensions
{
    public static int IndexOf<T>(this IEnumerable<T> obj, T value)
    {
        return obj.IndexOf(value, null);
    }

    public static int IndexOf<T>(this IEnumerable<T> obj, T value, IEqualityComparer<T> comparer)
    {
        comparer = comparer ?? EqualityComparer<T>.Default;
        var found = obj
            .Select((a, i) => new { a, i })
            .FirstOrDefault(x => comparer.Equals(x.a, value));
        return found == null ? -1 : found.i;
    }
}
于 2009-08-17T21:47:42.397 回答
21

我目前这样做的方式比已经建议的方式要短一些,据我所知,它给出了预期的结果:

 var index = haystack.ToList().IndexOf(needle);

它有点笨拙,但它可以完成工作并且相当简洁。

于 2014-11-06T11:29:10.543 回答
10

我认为最好的选择是这样实现:

public static int IndexOf<T>(this IEnumerable<T> enumerable, T element, IEqualityComparer<T> comparer = null)
{
    int i = 0;
    comparer = comparer ?? EqualityComparer<T>.Default;
    foreach (var currentElement in enumerable)
    {
        if (comparer.Equals(currentElement, element))
        {
            return i;
        }

        i++;
    }

    return -1;
}

它也不会创建匿名对象

于 2011-06-19T20:16:34.047 回答
9

捕捉位置的最佳方法是通过FindIndex此功能仅适用于List<>

例子

int id = listMyObject.FindIndex(x => x.Id == 15); 

如果您有枚举器或数组,请使用这种方式

int id = myEnumerator.ToList().FindIndex(x => x.Id == 15); 

或者

 int id = myArray.ToList().FindIndex(x => x.Id == 15); 
于 2016-09-05T08:28:07.720 回答
6

游戏有点晚了,我知道……但这是我最近做的。它与您的略有不同,但允许程序员决定相等操作需要是什么(谓词)。我发现在处理不同类型时非常有用,因为我有一种通用的方法来处理它,而不管对象类型和<T>内置的相等运算符。

它还具有非常非常小的内存占用,并且非常非常快速/高效......如果你关心的话。

更糟糕的是,您只需将其添加到您的扩展列表中。

无论如何……就是这样。

 public static int IndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate)
 {
     int retval = -1;
     var enumerator = source.GetEnumerator();

     while (enumerator.MoveNext())
     {
         retval += 1;
         if (predicate(enumerator.Current))
         {
             IDisposable disposable = enumerator as System.IDisposable;
             if (disposable != null) disposable.Dispose();
             return retval;
         }
     }
     IDisposable disposable = enumerator as System.IDisposable;
     if (disposable != null) disposable.Dispose();
     return -1;
 }

希望这可以帮助某人。

于 2014-12-19T23:39:41.443 回答
5

几年后,但这使用了 Linq,如果没有找到则返回 -1,不会创建额外的对象,并且在找到时应该短路 [而不是遍历整个 IEnumerable]:

public static int IndexOf<T>(this IEnumerable<T> list, T item)
{
    return list.Select((x, index) => EqualityComparer<T>.Default.Equals(item, x)
                                     ? index
                                     : -1)
               .FirstOr(x => x != -1, -1);
}

'FirstOr' 是:

public static T FirstOr<T>(this IEnumerable<T> source, T alternate)
{
    return source.DefaultIfEmpty(alternate)
                 .First();
}

public static T FirstOr<T>(this IEnumerable<T> source, Func<T, bool> predicate, T alternate)
{
    return source.Where(predicate)
                 .FirstOr(alternate);
}
于 2016-01-07T14:42:31.620 回答
3

今天在寻找答案时偶然发现了这个,我想我会把我的版本添加到列表中(没有双关语的意思)。它利用了 c#6.0 的 null 条件运算符

IEnumerable<Item> collection = GetTheCollection();

var index = collection
.Select((item,idx) => new { Item = item, Index = idx })
//or .FirstOrDefault(_ =>  _.Item.Prop == something)
.FirstOrDefault(_ => _.Item == itemToFind)?.Index ?? -1;

我已经完成了一些“老马赛跑”(测试)和大型收藏(约 100,000 个),最坏的情况是您想要的项目在最后,这比做2ToList().FindIndex()倍快。如果你想要的项目在中间,它的速度要快4 倍

对于较小的集合(〜10,000),它似乎只是稍微快一点

这是我测试它的方法https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

于 2018-02-08T16:40:31.427 回答
1

事后查找索引的另一种方法是包装 Enumerable,有点类似于使用 Linq GroupBy() 方法。

public static class IndexedEnumerable
{
    public static IndexedEnumerable<T> ToIndexed<T>(this IEnumerable<T> items)
    {
        return IndexedEnumerable<T>.Create(items);
    }
}

public class IndexedEnumerable<T> : IEnumerable<IndexedEnumerable<T>.IndexedItem>
{
    private readonly IEnumerable<IndexedItem> _items;

    public IndexedEnumerable(IEnumerable<IndexedItem> items)
    {
        _items = items;
    }

    public class IndexedItem
    {
        public IndexedItem(int index, T value)
        {
            Index = index;
            Value = value;
        }

        public T Value { get; private set; }
        public int Index { get; private set; }
    }

    public static IndexedEnumerable<T> Create(IEnumerable<T> items)
    {
        return new IndexedEnumerable<T>(items.Select((item, index) => new IndexedItem(index, item)));
    }

    public IEnumerator<IndexedItem> GetEnumerator()
    {
        return _items.GetEnumerator();
    }

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

这给出了一个用例:

var items = new[] {1, 2, 3};
var indexedItems = items.ToIndexed();
foreach (var item in indexedItems)
{
    Console.WriteLine("items[{0}] = {1}", item.Index, item.Value);
}
于 2012-03-26T07:05:40.510 回答
1

使用@Marc Gravell 的答案,我找到了一种使用以下方法的方法:

source.TakeWhile(x => x != value).Count();

为了在找不到项目时获得-1:

internal static class Utils
{

    public static int IndexOf<T>(this IEnumerable<T> enumerable, T item) => enumerable.IndexOf(item, EqualityComparer<T>.Default);

    public static int IndexOf<T>(this IEnumerable<T> enumerable, T item, EqualityComparer<T> comparer)
    {
        int index = enumerable.TakeWhile(x => comparer.Equals(x, item)).Count();
        return index == enumerable.Count() ? -1 : index;
    }
}

我想这种方式可能是最快和最简单的。但是,我还没有测试过性能。

于 2019-04-28T16:10:45.913 回答
0

这可以通过扩展(充当代理)变得非常酷,例如:

collection.SelectWithIndex(); 
// vs. 
collection.Select((item, index) => item);

这将自动将索引分配给可通过此Index属性访问的集合。

界面:

public interface IIndexable
{
    int Index { get; set; }
}

自定义扩展(可能对使用 EF 和 DbContext 最有用):

public static class EnumerableXtensions
{
    public static IEnumerable<TModel> SelectWithIndex<TModel>(
        this IEnumerable<TModel> collection) where TModel : class, IIndexable
    {
        return collection.Select((item, index) =>
        {
            item.Index = index;
            return item;
        });
    }
}

public class SomeModelDTO : IIndexable
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }

    public int Index { get; set; }
}

// In a method
var items = from a in db.SomeTable
            where a.Id == someValue
            select new SomeModelDTO
            {
                Id = a.Id,
                Name = a.Name,
                Price = a.Price
            };

return items.SelectWithIndex()
            .OrderBy(m => m.Name)
            .Skip(pageStart)
            .Take(pageSize)
            .ToList();
于 2018-01-14T10:13:10.560 回答