Як отримати індекс елемента в IEnumerable?

Я написав це:

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

Але я не знаю, чи вона вже існує, чи не так?

Вся справа в тому, щоб викласти речі як IEnumerable, щоб ви могли ліниво переглядати вміст. Таким чином , не існує на насправді поняття індексу. Те, що ви робите, насправді не має великого сенсу для IEnumerable. Якщо вам потрібно щось, що підтримує доступ за індексом, помістіть його у фактичний список чи колекцію.

Я б сумнівався в мудрості, але можливо:

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

Я би реалізував це так:

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

Те, що я зараз роблю це, трохи коротше, ніж ті, що вже пропонуються, і, наскільки я можу сказати, дає бажаний результат:

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

Це трохи незграбно, але це робить роботу і досить стисло.

Найкращий спосіб зайняти позицію - мимо 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); 

Я думаю, що найкращий варіант - реалізувати так:

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

Він також не створить анонімний об’єкт

Трохи пізно в грі, я знаю ... але це те, що я нещодавно зробив. Він дещо інший, ніж ваш, але дозволяє програмісту диктувати, якою повинна бути операція рівності (предикат). Що мені здається дуже корисним при роботі з різними типами, оскільки тоді я маю загальний спосіб робити це незалежно від типу об'єкта та<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;
 }

Сподіваємось, це комусь допомагає.

Через кілька років, але для цього використовується 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);
}

Сьогодні натрапив на це в пошуках відповідей, і я подумав, що додаю свою версію до списку (каламбур не призначений). Це utlises нульовий умовний оператор c # 6.0

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), найгірший сценарій, коли ви хочете, щоб цей предмет був наприкінці, це в 2 рази швидше, ніж робити ToList().FindIndex(). Якщо предмет, який ви хочете, знаходиться в середині його ~ 4 рази швидше.

Для менших колекцій (~ 10000) це здається лише незначно швидшим

Ось як я тестував це https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Використовуючи відповідь @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;
    }
}

Я думаю, що цей спосіб може бути і найшвидшим, і простішим. Однак я ще не перевіряв виступи.

Альтернативою пошуку індексу після факту є обертання 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);
}

Це може бути дуже здоровим з розширенням (функціонуючи як проксі), наприклад:

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