Comment obtenir un index en utilisant LINQ ?

Question

Étant donné une source de données comme ça :

var c = new Car[]
{
  new Car{ Color="Blue", Price=28000},
  new Car{ Color="Red", Price=54000},
  new Car{ Color="Pink", Price=9999},
  // ..
};

Comment puis-je trouver le indice de la première voiture satisfaisant une certaine condition avec LINQ ?

EDIT :

Je pourrais penser à quelque chose comme ça mais ça a l'air horrible :

int firstItem = someItems.Select((item, index) => new    
{    
    ItemName = item.Color,    
    Position = index    
}).Where(i => i.ItemName == "purple")    
  .First()    
  .Position;

Le mieux serait-il de résoudre ce problème avec une simple boucle ?

Answer 1

myCars.Select((v, i) => new {car = v, index = i}).First(myCondition).index;

ou la version légèrement plus courte

myCars.Select((car, index) => new {car, index}).First(myCondition).index;

ou la version légèrement plus courte

myCars.Select((car, index) => (car, index)).First(myCondition).index;

Answer 2

Il suffit de faire :

int index = List.FindIndex(your condition);

Par exemple

int index = cars.FindIndex(c => c.ID == 150);

Answer 3

Un site IEnumerable n'est pas un ensemble ordonné.
Bien que la plupart des IEnumerables soient ordonnés, certains (comme les Dictionary o HashSet ) ne le sont pas.

Par conséquent, LINQ ne dispose pas d'un IndexOf méthode.

Cependant, vous pouvez en écrire un vous-même :

///<summary>Finds the index of the first item matching an expression in an enumerable.</summary>
///<param name="items">The enumerable to search.</param>
///<param name="predicate">The expression to test the items against.</param>
///<returns>The index of the first matching item, or -1 if no items match.</returns>
public static int FindIndex<T>(this IEnumerable<T> items, Func<T, bool> predicate) {
    if (items == null) throw new ArgumentNullException("items");
    if (predicate == null) throw new ArgumentNullException("predicate");

    int retVal = 0;
    foreach (var item in items) {
        if (predicate(item)) return retVal;
        retVal++;
    }
    return -1;
}
///<summary>Finds the index of the first occurrence of an item in an enumerable.</summary>
///<param name="items">The enumerable to search.</param>
///<param name="item">The item to find.</param>
///<returns>The index of the first matching item, or -1 if the item was not found.</returns>
public static int IndexOf<T>(this IEnumerable<T> items, T item) { return items.FindIndex(i => EqualityComparer<T>.Default.Equals(item, i)); }

Answer 4

myCars.TakeWhile(car => !myCondition(car)).Count();

Ça marche ! Pensez-y. L'indice du premier élément correspondant est égal au nombre d'éléments (non correspondants) qui le précèdent.

L'heure du conte

Moi aussi, je n'aime pas le horrible solution standard que vous avez déjà suggéré dans votre question. Comme la réponse acceptée, j'ai opté pour une bonne vieille boucle, mais avec une légère modification :

public static int FindIndex<T>(this IEnumerable<T> items, Predicate<T> predicate) {
    int index = 0;
    foreach (var item in items) {
        if (predicate(item)) break;
        index++;
    }
    return index;
}

Notez qu'il retournera le nombre d'éléments au lieu de -1 lorsqu'il n'y a pas de correspondance. Mais ignorons cette petite gêne pour l'instant. En fait, le horrible solution standard s'effondre dans ce cas et J'envisage de retourner un index qui est hors limites supérieur .

Ce qui se passe maintenant, c'est que ReSharper me dit La boucle peut être convertie en expression LINQ . Si, la plupart du temps, cette fonctionnalité nuit à la lisibilité, cette fois-ci, le résultat a été époustouflant. Félicitations à JetBrains.

Analyse

Pour

• Concise
• Combinable avec d'autres LINQ
• Évite le site new ingérer des objets anonymes
• N'évalue l'énumérable que lorsque le prédicat correspond pour la première fois.

Je considère donc qu'il est optimal dans le temps et l'espace tout en restant lisible.

Cons

• Pas tout à fait évident au début
• Ne revient pas -1 lorsqu'il n'y a pas de correspondance

Bien sûr, vous pouvez toujours la cacher derrière une méthode d'extension. Et ce qu'il convient de faire lorsqu'il n'y a pas de correspondance dépend fortement du contexte.

Answer 5

Je vais apporter ma contribution ici... pourquoi ? juste parce que :p C'est une implémentation différente, basée sur l'extension Any LINQ, et un délégué. La voici :

public static class Extensions
{
    public static int IndexOf<T>(
            this IEnumerable<T> list, 
            Predicate<T> condition) {               
        int i = -1;
        return list.Any(x => { i++; return condition(x); }) ? i : -1;
    }
}

void Main()
{
    TestGetsFirstItem();
    TestGetsLastItem();
    TestGetsMinusOneOnNotFound();
    TestGetsMiddleItem();   
    TestGetsMinusOneOnEmptyList();
}

void TestGetsFirstItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("a"));

    // Assert
    if(index != 0)
    {
        throw new Exception("Index should be 0 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsLastItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("d"));

    // Assert
    if(index != 3)
    {
        throw new Exception("Index should be 3 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMinusOneOnNotFound()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d" };

    // Act
    int index = list.IndexOf(item => item.Equals("e"));

    // Assert
    if(index != -1)
    {
        throw new Exception("Index should be -1 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMinusOneOnEmptyList()
{
    // Arrange
    var list = new string[] {  };

    // Act
    int index = list.IndexOf(item => item.Equals("e"));

    // Assert
    if(index != -1)
    {
        throw new Exception("Index should be -1 but is: " + index);
    }

    "Test Successful".Dump();
}

void TestGetsMiddleItem()
{
    // Arrange
    var list = new string[] { "a", "b", "c", "d", "e" };

    // Act
    int index = list.IndexOf(item => item.Equals("c"));

    // Assert
    if(index != 2)
    {
        throw new Exception("Index should be 2 but is: " + index);
    }

    "Test Successful".Dump();
}