¿Cómo obtener el índice de un elemento en un IEnumerable?

Yo escribí esto:

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

Pero no sé si ya existe, ¿verdad?

El objetivo de sacar las cosas como IEnumerable es para que puedas iterar perezosamente sobre los contenidos. Como tal, no existe realmente un concepto de índice. Lo que estás haciendo realmente no tiene mucho sentido para un IEnumerable. Si necesita algo que admita el acceso por índice, colóquelo en una lista o colección real.

Cuestionaría la sabiduría, pero tal vez:

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

(usando EqualityComparer<T>.Defaultpara emular !=si es necesario), pero necesita mirar para devolver -1 si no se encuentra ... así que tal vez solo hágalo a la larga

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 implementaría así:

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

La forma en que lo estoy haciendo actualmente es un poco más corta que las ya sugeridas y, por lo que puedo decir, da el resultado deseado:

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

Es un poco torpe, pero hace el trabajo y es bastante conciso.

La mejor manera de tomar la posición es FindIndex Esta función está disponible solo paraList<>

Ejemplo

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

Si tiene enumerador o matriz, use de esta manera

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

o

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

Creo que la mejor opción es implementar así:

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

Tampoco creará el objeto anónimo

Un poco tarde en el juego, lo sé ... pero esto es lo que hice recientemente. Es ligeramente diferente al suyo, pero permite que el programador dicte lo que la operación de igualdad debe ser (predicado). Lo cual encuentro muy útil cuando trato con diferentes tipos, ya que tengo una forma genérica de hacerlo independientemente del tipo de objeto y del <T>operador de igualdad incorporado.

También tiene una huella de memoria muy pequeña, y es muy, muy rápido / eficiente ... si te importa eso.

En el peor de los casos, solo agregará esto a su lista de extensiones.

De todos modos ... aquí está.

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

Esperemos que esto ayude a alguien.

Unos años más tarde, pero esto usa Linq, devuelve -1 si no se encuentra, no crea objetos adicionales y debería cortocircuitarse cuando se encuentra [en lugar de iterar sobre todo 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);
}

Donde 'FirstOr' es:

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

Encontré esto hoy en busca de respuestas y pensé en agregar mi versión a la lista (sin juego de palabras). Utiliza el operador condicional nulo de 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;

He hecho algunas 'carreras de los viejos caballos' (pruebas) y para grandes colecciones (~ 100,000), el peor de los casos en que el artículo que deseas es al final, esto es 2 veces más rápido que hacerlo ToList().FindIndex(). Si el artículo que desea está en el medio, es ~ 4 veces más rápido.

Para colecciones más pequeñas (~ 10,000) parece ser solo marginalmente más rápido

Aquí está cómo lo probé https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Usando la respuesta de @Marc Gravell, encontré una manera de usar el siguiente método:

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

para obtener -1 cuando no se puede encontrar el artículo:

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

Supongo que de esta manera podría ser tanto el más rápido como el más simple. Sin embargo, aún no he probado las actuaciones.

Una alternativa para encontrar el índice después del hecho es envolver el Enumerable, algo similar a usar el método 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();
    }
}

Lo que da un caso de uso de:

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

Esto puede ser realmente genial con una extensión (que funciona como un proxy), por ejemplo:

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

Que asignará automáticamente índices a la colección accesible a través de este Index propiedad.

Interfaz:

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

Extensión personalizada (probablemente más útil para trabajar con EF y 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();