Comment obtenir l'index d'un élément dans un IEnumerable?

J'ai écrit ceci:

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

Mais je ne sais pas si ça existe déjà, n'est-ce pas?

L'intérêt de faire sortir les choses en tant que IEnumerable est que vous puissiez parcourir paresseusement le contenu. En tant que tel, il n'y a pas vraiment de concept d'index. Ce que vous faites n'a vraiment pas beaucoup de sens pour un IEnumerable. Si vous avez besoin de quelque chose qui prend en charge l'accès par index, placez-le dans une liste ou une collection réelle.

Je remettrais en question la sagesse, mais peut-être:

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

(utiliser EqualityComparer<T>.Defaultpour émuler !=si nécessaire) - mais vous devez regarder pour renvoyer -1 si non trouvé ... alors peut-être le faire le long du chemin

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

Je le mettrais en œuvre comme ceci:

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 façon dont je fais actuellement est un peu plus courte que celles déjà suggérées et, pour autant que je sache, donne le résultat souhaité:

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

C'est un peu maladroit, mais cela fait le travail et est assez concis.

La meilleure façon de saisir la position est par FindIndexCette fonction n'est disponible que pourList<>

Exemple

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

Si vous avez un énumérateur ou un tableau, utilisez cette méthode

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

ou

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

Je pense que la meilleure option est de mettre en œuvre comme ceci:

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

Il ne créera pas non plus l'objet anonyme

Un peu tard dans le jeu, je sais ... mais c'est ce que j'ai fait récemment. Il est légèrement différent du vôtre, mais permet au programmeur de dicter ce que l'opération d'égalité doit être (prédicat). Ce que je trouve très utile pour traiter différents types, car j'ai alors une manière générique de le faire quel que soit le type d'objet et <T>l'opérateur d'égalité intégré.

Il a également une très très petite empreinte mémoire, et est très, très rapide / efficace ... si vous vous en souciez.

Au pire, vous l'ajouterez simplement à votre liste d'extensions.

Quoi qu'il en soit ... le voici.

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

Espérons que cela aide quelqu'un.

Quelques années plus tard, mais cela utilise Linq, retourne -1 si non trouvé, ne crée pas d'objets supplémentaires et devrait court-circuiter une fois trouvé [par opposition à une itération sur tout le 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);
}

Où 'FirstOr' est:

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

Je suis tombé sur cela aujourd'hui dans une recherche de réponses et j'ai pensé ajouter ma version à la liste (sans jeu de mots). Il utilise l'opérateur conditionnel nul 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;

J'ai fait des «courses des vieux chevaux» (tests) et pour les grandes collections (~ 100 000), dans le pire des cas, l'élément que vous voulez est à la fin, c'est 2x plus rapide que de le faire ToList().FindIndex(). Si l'élément que vous voulez est au milieu, il est ~ 4x plus rapide.

Pour les collections plus petites (~ 10 000), il semble être légèrement plus rapide

Voici comment je l'ai testé https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

En utilisant la réponse de @Marc Gravell, j'ai trouvé un moyen d'utiliser la méthode suivante:

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

afin d'obtenir -1 lorsque l'élément est introuvable:

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

Je suppose que cette méthode pourrait être à la fois la plus rapide et la plus simple. Cependant, je n'ai pas encore testé les performances.

Une alternative à la recherche de l'index après coup consiste à encapsuler le Enumerable, un peu similaire à l'utilisation de la méthode 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();
    }
}

Ce qui donne un cas d'utilisation 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);
}

Cela peut devenir vraiment cool avec une extension (fonctionnant comme un proxy), par exemple:

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

Qui attribuera automatiquement des index à la collection accessible via ce Index propriété.

Interface:

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

Extension personnalisée (probablement la plus utile pour travailler avec EF et 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();