Jak uzyskać indeks elementu w IEnumerable?

Ja to napisałem:

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

Ale nie wiem, czy już istnieje, prawda?

Cały sens wyrzucania rzeczy jako IEnumerable polega na tym, abyś mógł leniwie iterować zawartość. W związku z tym tak naprawdę nie ma pojęcia indeksu. To, co robisz, naprawdę nie ma większego sensu dla IEnumerable. Jeśli potrzebujesz czegoś, co obsługuje dostęp przez indeks, umieść to na rzeczywistej liście lub kolekcji.

Zakwestionowałbym mądrość, ale może:

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

(używając EqualityComparer<T>.Defaultdo emulacji w !=razie potrzeby) - ale musisz oglądać, aby zwrócić -1, jeśli nie zostanie znaleziony ... więc może po prostu zrób to długo

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

Wdrożyłbym to w ten sposób:

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

Sposób, w jaki obecnie to robię, jest nieco krótszy niż te już sugerowane i, o ile wiem, daje pożądany efekt:

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

Jest trochę niezgrabny, ale spełnia swoje zadanie i jest dość zwięzły.

Najlepszym sposobem na złapanie pozycji jest FindIndexta funkcja jest dostępna tylko dlaList<>

Przykład

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

Jeśli masz moduł wyliczający lub tablicę, użyj tego sposobu

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

lub

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

Myślę, że najlepszą opcją jest wdrożenie w ten sposób:

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

Nie utworzy również anonimowego obiektu

Wiem, że trochę późno w grze ... ale to właśnie ostatnio zrobiłem. Jest nieco inny niż twój, ale pozwala programiście dyktować, jaka ma być operacja równości (predykat). Co uważam za bardzo przydatne w przypadku różnych typów, ponieważ mam wtedy ogólny sposób robienia tego niezależnie od typu obiektu i <T>wbudowanego operatora równości.

Ma również bardzo, bardzo małe zużycie pamięci i jest bardzo, bardzo szybki / wydajny ... jeśli o to ci chodzi.

Co gorsza, po prostu dodasz to do listy rozszerzeń.

W każdym razie ... oto jest.

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

Mam nadzieję, że to komuś pomoże.

Kilka lat później, ale to używa Linq, zwraca -1, jeśli nie zostanie znaleziony, nie tworzy dodatkowych obiektów i powinno spowodować zwarcie, gdy zostanie znalezione [w przeciwieństwie do iteracji po całym 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);
}

Gdzie „FirstOr” to:

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

Natknąłem się na to dzisiaj w poszukiwaniu odpowiedzi i pomyślałem, że dodam swoją wersję do listy (gra słów nie zamierzona). Wykorzystuje zerowy operator warunkowy języka 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;

Zrobiłem kilka „wyścigów starych koni” (testy) i dla dużych kolekcji (~ 100 000), najgorszy scenariusz, że przedmiot, który chcesz, jest na końcu, jest to 2x szybsze niż robienie ToList().FindIndex(). Jeśli żądany przedmiot znajduje się pośrodku, jest ~ 4x szybszy.

W przypadku mniejszych kolekcji (~ 10 000) wydaje się, że jest tylko nieznacznie szybszy

Oto, jak to przetestowałem https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Korzystając z odpowiedzi @Marc Gravell, znalazłem sposób na użycie następującej metody:

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

aby otrzymać -1, gdy przedmiotu nie można znaleźć:

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

Myślę, że ten sposób może być zarówno najszybszy, jak i prostszy. Jednak nie testowałem jeszcze wydajności.

Alternatywą dla znalezienia indeksu po fakcie jest zawinięcie Enumerable, nieco podobne do użycia metody 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();
    }
}

Co daje przykład użycia:

var items = new[] {1, 2, 3};
var indexedItems = items.ToIndexed();
foreach (var item in indexedItems)
{
    Console.WriteLine("items[{0}] = {1}", item.Index, item.Value);
}

Może to być naprawdę fajne z rozszerzeniem (działającym jako proxy), na przykład:

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

Który automagicznie przypisze indeksy do kolekcji dostępnej przez to Index właściwości.

Berło:

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

Rozszerzenie niestandardowe (prawdopodobnie najbardziej przydatne do pracy z EF i 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();