saber - recorrer una lista c#

¿Cómo obtener el índice de un artículo en una lista en un solo paso?

Question

¿Cómo puedo encontrar el índice de un elemento en una lista sin recorrerlo?

Actualmente, esto no se ve muy bien: buscar dos veces en el mismo artículo para obtener el índice:

var oProp = something;
int theThingIActuallyAmInterestedIn = myList.IndexOf(myList.Single(i => i.Prop == oProp));

Answer 1

1. Solución simple para encontrar el índice para cualquier valor de cadena en la Lista.

Aquí está el código para List of String:

int indexOfValue = myList.FindIndex(a => a.Contains("//insert value from list"));

2. Solución simple para encontrar el índice para cualquier valor entero en la lista.

Aquí está el código para la lista de enteros:

 int indexOfNumber = myList.IndexOf(//insert number from list);

Answer 2

¿Qué tal el método List.FindIndex :

int index = myList.FindIndex(a => a.Prop == oProp);

Este método realiza una búsqueda lineal; por lo tanto, este método es una operación O (n), donde n es Count.

Answer 3

Aquí hay un método de extensión de copiar / pegar para IEnumerable

public static class EnumerableExtensions
{
/// <summary>
/// Searches for an element that matches the conditions defined by the specified predicate,
/// and returns the zero-based index of the first occurrence within the entire <see cref="IEnumerable{T}"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list">The list.</param>
/// <param name="predicate">The predicate.</param>
/// <returns>
/// The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="predicate"/>, if found; otherwise it''ll throw.
/// </returns>
public static int FindIndex<T>(this IEnumerable<T> list, Func<T, bool> predicate)
{
var idx = list.Select((value, index) => new {value, index}).Where(x => predicate(x.value)).Select(x => x.index).First();
return idx;
}
}

Disfrutar.

Answer 4

EDITAR: Si solo está utilizando una List<> y solo necesita el índice, entonces List.FindIndex es de hecho el mejor enfoque. IEnumerable<> esta respuesta aquí para aquellos que necesitan algo diferente (por ejemplo, sobre cualquier IEnumerable<> ).

Utilice la sobrecarga de Select que toma un índice en el predicado, por lo que transformará su lista en un par (índice, valor):

var pair = myList.Select((Value, Index) => new { Value, Index })
.Single(p => p.Value.Prop == oProp);

Entonces:

Console.WriteLine("Index:{0}; Value: {1}", pair.Index, pair.Value);

O bien, si solo quiere el índice y lo está utilizando en varios lugares, podría escribir fácilmente su propio método de extensión, que era como Where , pero en lugar de devolver los elementos originales, devolvía los índices de los elementos que coincidían con el predicado.

Answer 5

Para tipos simples puede usar "IndexOf":

List<string> arr = new List<string>();
arr.Add("aaa");
arr.Add("bbb");
arr.Add("ccc");
int i = arr.IndexOf("bbb"); // RETURNS 1.

Answer 6

Si no quieres usar LINQ, entonces:

int index;
for (int i = 0; i < myList.Count; i++)
{
if (myList[i].Prop == oProp)
{
index = i;
break;
}
}

de esta manera estás iterando la lista solo una vez.