Come ottenere l'indice di un elemento in un IEnumerable?

Ho scritto questo:

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

Ma non so se esiste già, vero?

Il punto centrale di far emergere le cose come IEnumerable è così che tu possa pigramente iterare sui contenuti. In quanto tale, non è in realtà un concetto di un indice. Quello che stai facendo davvero non ha molto senso per un IEnumerable. Se hai bisogno di qualcosa che supporti l'accesso in base all'indice, inseriscilo in un elenco o una raccolta effettivi.

Metterei in dubbio la saggezza, ma forse:

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

(usando EqualityComparer<T>.Defaultper emulare !=se necessario) - ma devi guardare per restituire -1 se non trovato ... quindi forse fallo solo a lungo

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

Lo implementerei così:

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

Il modo in cui lo sto facendo attualmente è un po 'più breve di quelli già suggeriti e, per quanto ne so, dà il risultato desiderato:

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

È un po 'goffo, ma fa il lavoro ed è abbastanza conciso.

Il modo migliore per catturare la posizione è tramite FindIndexQuesta funzione è disponibile solo perList<>

Esempio

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

Se si dispone dell'enumeratore o dell'array, utilizzare in questo modo

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

o

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

Penso che l'opzione migliore sia implementare in questo modo:

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

Inoltre non creerà l'oggetto anonimo

Un po 'in ritardo nel gioco, lo so ... ma questo è quello che ho fatto di recente. È leggermente diverso dal tuo, ma consente al programmatore di dettare ciò che l'operazione di uguaglianza deve essere (predicato). Che trovo molto utile quando ho a che fare con diversi tipi, dal momento che ho un modo generico di farlo indipendentemente dal tipo di oggetto e<T> dall'operatore di uguaglianza incorporato.

Ha anche un ingombro di memoria molto piccolo ed è molto, molto veloce / efficiente ... se ti interessa.

Nel peggiore dei casi, lo aggiungerai semplicemente al tuo elenco di estensioni.

Comunque ... eccolo qui.

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

Spero che questo aiuti qualcuno.

Qualche anno dopo, ma utilizza Linq, restituisce -1 se non viene trovato, non crea oggetti extra e dovrebbe cortocircuitare quando viene trovato [invece di iterare sull'intero 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);
}

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

Mi sono imbattuto in questo oggi in una ricerca di risposte e ho pensato di aggiungere la mia versione all'elenco (nessun gioco di parole previsto). Utilizza l'operatore condizionale null di 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;

Ho fatto un po 'di corse dei vecchi cavalli (test) e per grandi collezioni (~ 100.000), il peggior scenario in cui l'articolo che vuoi è alla fine, questo è 2 volte più veloce di quello che fai ToList().FindIndex(). Se l'oggetto che vuoi è nel mezzo è ~ 4x più veloce.

Per le raccolte più piccole (~ 10.000) sembra essere solo leggermente più veloce

Ecco come l'ho provato https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Usando la risposta di @Marc Gravell, ho trovato il modo di usare il seguente metodo:

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

per ottenere -1 quando non è possibile trovare l'elemento:

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

Immagino che in questo modo potrebbe essere sia il più veloce che il più semplice. Tuttavia, non ho ancora testato le prestazioni.

Un'alternativa alla ricerca dell'indice dopo il fatto è quella di racchiudere l'Enumerable, in qualche modo simile all'utilizzo del metodo 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();
    }
}

Che dà un caso d'uso di:

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

Questo può diventare davvero interessante con un'estensione (che funziona come proxy), ad esempio:

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

Che assegnerà automaticamente gli indici alla raccolta accessibile tramite questo Index proprietà.

Interfaccia:

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

Estensione personalizzata (probabilmente più utile per lavorare con EF e 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();