Comment faire pour 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 elle existe déjà, n'est ce pas?

Le problème avec un Max approche est que: il ne cesse de regarder, et b: elle retourne la dernière index quand il y a des doublons (les gens s'attendent généralement à ce que le premier indice)
geekswithblogs.net compare 4 solutions et de leur performance. Le ToList()/FindIndex() astuce fonctionne mieux

InformationsquelleAutor Jader Dias | 2009-08-17

.net c#ienumerable indexof linq

49

Le point de faire les choses comme IEnumerable est de sorte que vous pouvez paresseusement parcourir le contenu. En tant que tel, il n'y a pas vraiment un concept d'un index. Ce que vous faites vraiment ne fait pas beaucoup de sens pour un IEnumerable. Si vous besoin de quelque chose qui prend en charge l'accès par index, le mettre dans une liste réelle ou de la collection.
- Actuellement, je suis tombé sur ce fil parce que je suis mise en œuvre d'un générique IList<> wrapper pour l'interface IEnumerable<> type afin de pouvoir utiliser mon IEnumerable<> les objets avec des composants tiers seulement compatibles avec les sources de données de type IList. Je suis d'accord que d'essayer d'obtenir un indice d'un élément dans un IEnumerable objet est probablement dans la plupart des cas un signe de quelque chose de beign fait de mal, il y a des moments où la recherche de l'indice une fois les battements de reproduire une grande collection dans la mémoire juste pour le plaisir de trouver l'indice d'un élément unique lorsque vous avez déjà un IEnumerable.
- -1 cause: Il y a des raisons légitimes pour lesquelles vous souhaitez obtenir un indice d'un IEnumerable<>. Je n'achète pas tout "vous shoul ferais ce" dogme.
- D'accord avec @ja72; si vous ne devriez pas avoir à composer avec des index avec IEnumerable puis Enumerable.ElementAt n'existerait pas. IndexOf est tout simplement l'inverse -- aucun argument contre elle doit également s'appliquer aux ElementAt.
- Cleary, C# rate le concept de IIndexableEnumerable. que serait l'équivalent d'une "aléatoire accessible", un concept en C++ STL terminologie.
- Supposons que vous souhaitiez trouver l'indice d'un membre de la SortedSet<T>, qui veille au respect de l'unicité de chacun de ses membres?
- les extensions de surcharges comme Select((x, i) => ...) semblent indiquer que ces indices devraient exister
- Liste<XXX> maliste = new List<XXX>(myIEnumerable);
- Le point de l'ensemble de IEnumerable<T> est de ne pas forcer les consommateurs d'objets dans un camp de votre choix (Liste, ObservableCollection, Collection, etc) ce qui permet de définir les paramètres de la méthode et des types de retour la façon dont ils l'entendent, tant qu'il implémente l'interface IEnumerable<T>
- Pour IndexOf pour être significative, l'interface IEnumerable doivent être commandés (à ne pas confondre avec triés), et doit pouvoir être dénombrées plus d'une fois. Je soupçonne que cette méthode n'est pas une partie de LINQ parce que pas tous les IEnumerables répondent à ces critères. Mais, dans presque tous les cas où vous souhaitez utiliser ce que vous savez que la collection sous-jacente NE répondent pas à ces critères, alors je souhaite qu'il ont été inclus.
- Tombé sur ce, tout en travaillant avec OpenXML.. vous pouvez seulement consulter les styles par leurs Indices et vous ne pouvez y accéder via les agents recenseurs... Maintenant, on pourrait penser qu'une bonne idée serait d'être en mesure d'arrêter l'énumération si le style désiré a été trouvé, plutôt que d'impatience construire de longues listes avant la traversée. Je suis assez nouveau à cela, peut-être qu'il est un moyen élégant pour atteindre cet objectif...
- Que pensez-vous des commentaires ci-dessus, précisant que "Pour IndexOf pour être significative, l'interface IEnumerable doivent être commandés (à ne pas confondre avec triés), et doit pouvoir être dénombrées plus d'une fois." Ne pensez-vous pas que c'est un argument valable contre l'indice de IEnumerable?
- Excellent argument. Cependant, quelqu'un l'a souligné le fait que Énumérable implémente ElementAt qui suppose une certaine commande, bien que Énumérable d'être une classe peut avoir une commande. Qu'en pensez-vous?
- Je suis d'accord que pour IEnumerable être assez souple, ils ne doivent pas se limiter à reproductible collections, mais doit permettre un passage seulement paradigmes. Donc IndexOf peut-être trop restrictive. Peut-être une meilleure place serait dans ICollection<T> qui est plus comme un tableau ou une liste type de collecte.
InformationsquelleAutor Scott Dorman
115

J'avais en question la sagesse, mais peut-être:
```
source.TakeWhile(x => x != value).Count();
```
(à l'aide de EqualityComparer<T>.Default pour émuler != si nécessaire) - mais vous avez besoin de regarder pour retourner -1 si pas trouvé... donc peut-être juste faire le long 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;
}
```
- +1 pour "la remise en question de la sagesse". 9 fois sur 10 c'est probablement une mauvaise idée en premier lieu.
- De manière explicite de la solution de boucle s'exécute aussi 2x plus rapide (dans le pire des cas) que le Select().Max() solution.
- Vous pouvez simplement Compter les éléments par lambda sans TakeWhile - il enregistre une boucle: source.Count(x => x != valeur);
- non, ce n'est quelque chose de différent. TakeWhile s'arrête quand il obtient un échec; Count(prédicat) renvoie ceux qui correspondent. c'est à dire si le premier a été une miss et tout le reste était vrai, TakeWhile(pred).Comte (le) de déclarer 0; Count(pred) fera rapport à n-1.
- Vous avez raison, je devrais réfléchir avant de poster quelque temps:)
- TakeWhile est intelligent! Gardez à l'esprit ceci renvoie Count si l'élément n'existe pas, qui est une déviation de la norme de comportement.
InformationsquelleAutor Marc Gravell
23

Je voudrais mettre 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;
    }
}
```
- C'est vraiment très mignon, +1! Il implique les objets supplémentaires, mais ils devraient être relativement pas cher (GEN0), donc pas un énorme problème. Le == pourriez avoir besoin de travailler?
- Ajouté IEqualityComparer surcharge, en vrai LINQ style. 😉
- Je pense que tu veux dire ... comparer.Est égal à(x.une, valeur) =)
- Qu'est-ce que dire... de lire ce que je veux dire, pas ce que je tape? 🙁
- Depuis l'expression de sélection est de retourner le résultat combiné, qui est ensuite traité, j'imagine explicitement à l'aide de la KeyValuePair type de valeur vous permettra d'éviter toute sorte de tas allocations, tant que le .NET impl alloue des types de valeur sur la pile et tout l'état de la machine qui LINQ peut générer utilise un champ pour le Sélectionner avais résultat qui n'est pas déclaré comme une propriété de l'Objet (ce qui provoque le KVP résultat à obtenir en boîte). Bien sûr, vous auriez à retravailler le trouve==null condition (puisque l'on retrouve maintenant serait un KVP valeur). Peut-être l'aide d'DefaultIfEmpty() ou KVP<T, int?> (nullable index)
- Vous avez raison qu'il y a des allocations pour les résultats intermédiaires. Mais si vous êtes qui a entravé pour les performances, vous aurez probablement éviter l'utilisation de LINQ tout à fait. 🙂
- Sympa la mise en œuvre, mais un truc que j'aimerais suggérer l'ajout d'une vérification pour voir si obj implémente IList<T> et, dans l'affirmative, de reporter à sa méthode IndexOf juste au cas où il a un type spécifique d'optimisation.
InformationsquelleAutor dahlbyk
14

La façon dont je suis en train de faire, c'est un peu plus courts que ceux déjà suggéré, et aussi loin que je peux dire donne le résultat souhaité:
```
 var index = haystack.ToList().IndexOf(needle);
```
C'est un peu maladroit, mais il fait le travail et est assez concis.
- Bien que cela pourrait fonctionner pour les petites collections, supposons que vous avez un million d'articles dans la "botte de foin". Faire un ToList() sur qui va parcourir tous d'un million d'éléments et de les ajouter à une liste. Ensuite, il effectuera une recherche dans la liste pour trouver l'élément correspondant de l'index. Ce serait extrêmement inefficace ainsi que la possibilité de lancer une exception si la liste devient trop grande.
- Certainement vous avez besoin de choisir une approche qui convient le mieux à votre cas d'utilisation. Je doute qu'il ya une solution unique pour tous, qui est peut-être pourquoi il n'y a pas une mise en œuvre dans les bibliothèques de base.
InformationsquelleAutor Mark Watts

Je pense que la meilleure option est de mettre en place 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 sera également pas créer l'objet anonyme

InformationsquelleAutor Axente Adrian

6

Le meilleur moyen de détecter la position est par FindIndex Cette fonction est disponible uniquement pour les List<>

Exemple
```
int id = listMyObject.FindIndex(x => x.Id == 15); 
```
Si vous avez énumérateur de tableau ou de l'utiliser de cette façon
```
int id = myEnumerator.ToList().FindIndex(x => x.Id == 15); 
```
ou
```
 int id = myArray.ToList().FindIndex(x => x.Id == 15); 
```
InformationsquelleAutor daniele3004
5

Un peu en retard dans le jeu, je sais... mais c'est ce que j'ai fait récemment. Elle est légèrement différente de la 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 utiles lorsqu'il s'agit de différents types, depuis que je puis avoir un générique façon de le faire quel que soit le type d'objet et <T> construit en opérateur d'égalité.

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

Au pire, il vous suffit de l'ajouter à votre liste d'extensions.

De toute façon... c'est ici.
```
 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;
 }
```
J'espère que cela aide quelqu'un.
- Peut-être que je manque quelque chose, mais pourquoi le GetEnumerator et MoveNext plutôt que juste un foreach?
- Réponse courte? De l'efficacité. Réponse longue: msdn.microsoft.com/en-us/library/9yb8xew9.aspx
- En regardant le IL il apparaît que la différence de performances est qu'un foreach appellera Dispose sur l'énumérateur si elle met en œuvre IDisposable. (Voir stackoverflow.com/questions/4982396/...) Comme le code de cette réponse ne sais pas si le résultat de l'appel GetEnumerator est ou n'est pas jetable, il doit faire de même. À ce point, je ne suis toujours pas clair qu'il y a une perf d'avantages, mais il y avait une certaine supplémentaire de IL dont le but n'est pas de jaillir hors de moi!
- J'ai fait un peu de recherche, un moment de retour concernant les perf des avantages entre les foreach et pour(i), et le principal avantage de l'utilisation de(i) est qu'il ByRefs l'objet sur place plutôt que de re-création/passant de retour ByVal. Je suppose que la même chose s'applique à MoveNext contre foreach, mais je ne suis pas sûr que l'on. Peut-être qu'ils utilisent tous deux ByVal...
- La lecture de ce blog (blogs.msdn.com/b/ericlippert/archive/2010/09/30/...), il se peut que le "itérateur boucle" à laquelle il se réfère est un foreach boucle, dans ce cas, pour le cas particulier de T être un type de la valeur qu'il pourrait être l'enregistrement d'un box/unbox opération à l'aide de la boucle while. Cependant, ce n'est pas corroborée par le IL que j'ai obtenu à partir d'une version de votre réponse avec foreach. Je ne pense toujours que la condition de l'élimination de l'itérateur est important, cependant. Pourriez-vous modifier la réponse de l'inclure?
InformationsquelleAutor MaxOvrdrv

Quelques années plus tard, mais il utilise Linq, retourne -1 si pas trouvé, n'est pas de créer des objets en plus, et devrait de court-circuit, une fois trouvé, [par opposition à une itération sur l'ensemble de la 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);
}

Une autre façon de faire peut être: public static int IndexOf<T>(ce IEnumerable<T> liste, T item) { int e = liste.Sélectionnez((x, index) => EqualityComparer<T>.Par défaut.Equals(élément, x) ? x + 1 : -1) .FirstOrDefault(x => x > 0); return (e == 0) ? -1 : e - 1); }
"ne pas créer d'autres objets". Linq va en fait créer des objets dans le fond si ce n'est pas entièrement correct. Les deux source.Where et source.DefaultIfEmpty, par exemple, créer un IEnumerable chaque.

InformationsquelleAutor Greg

Une alternative pour trouver l'indice, après les faits, est d'envelopper le Énumérable, un peu similaire à l'aide de Linq GroupBy() la méthode.

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

Qui donne un cas d'utilisation d':

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

grande ligne de base. Il est utile pour ajouter des membres IsEven, IsOdd, IsFirst et IsLast ainsi.

InformationsquelleAutor Joshka

1

Suis tombé sur ça aujourd'hui, en quête de réponses et je pensais que je voudrais ajouter ma version de la liste (Aucun calembour prévu). Il utlises le null opérateur conditionnel 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 de la course des vieux chevaux (test) et pour les grandes collections (~100 000 habitants), le scénario du pire cas que le point que vous voulez est à la fin, c'est 2x plus rapide que de faire ToList().FindIndex(). Si l'Élément que vous voulez, c'est au milieu de ses ~4x plus rapide.

Pour les petites collections (~10 000 habitants), il semble à peine plus rapide

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

InformationsquelleAutor Dave

À l'aide de @Marc Gravel 's réponse, j'ai trouvé un moyen d'utiliser la méthode suivante:

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

afin d'obtenir -1 si l'élément ne peut pas être trouvé:

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 cela pourrait être à la fois le plus rapide et le plus simple. Cependant, je n'ai pas testé les performances encore.

InformationsquelleAutor Davide Cannizzo

Cela peut être vraiment cool avec une extension (comme le fonctionnement d'un proxy), par exemple:

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

Qui sera automatiquement attribuer des indices de la collection accessible via ce Index propriété.

Interface:

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

Extension personnalisée (sans doute plus utile pour le travail avec les objectifs 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();

InformationsquelleAutor Yom S.

Vous devez vous connecter pour publier un commentaire.