Como obter o índice de um elemento em um IEnumerable?
-
18-09-2019 - |
Pergunta
Eu escrevi o seguinte:
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();
}
}
Mas eu não sei se ele já existe, não é?
Solução
O ponto inteiro de fazer as coisas como IEnumerable é para que você possa preguiçosamente iterar sobre o conteúdo. Como tal, não existe realmente um conceito de um índice. O que você está fazendo realmente não faz muito sentido para um IEnumerable. Se você precisa de algo que suporta o acesso por índice, colocá-lo em uma lista ou coleção real.
Outras dicas
Eu questionar a sabedoria, mas talvez:
source.TakeWhile(x => x != value).Count();
(usando EqualityComparer<T>.Default
para !=
emular se necessário) - mas você precisa prestar atenção para retornar -1 se não encontrado ... então talvez apenas fazê-lo o caminho mais longo
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;
}
Gostaria de implementá-lo como este:
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;
}
}
A maneira que eu estou fazendo atualmente este é um pouco mais curto do que aqueles que já sugeriu e, tanto quanto eu posso dizer dá o resultado desejado:
var index = haystack.ToList().IndexOf(needle);
É um pouco desajeitado, mas ele faz o trabalho e é bastante concisa.
Eu acho que a melhor opção é implementar como este:
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;
}
Ele também não vai criar o objeto anônimo
A melhor maneira de pegar a posição é de FindIndex
Esta função está disponível apenas para List<>
Exemplo
int id = listMyObject.FindIndex(x => x.Id == 15);
Se você tem recenseador ou matriz uso dessa maneira
int id = myEnumerator.ToList().FindIndex(x => x.Id == 15);
ou
int id = myArray.ToList().FindIndex(x => x.Id == 15);
Um pouco tarde no jogo, eu sei ... mas é isso que eu fiz recentemente. É um pouco diferente do que o seu, mas permite que o programador ditar o que a operação de igualdade precisa ser (predicado). Que eu acho muito útil quando se lida com diferentes tipos, desde que eu, então, uma forma genérica de fazê-lo, independentemente do tipo de objeto e <T>
construído em operador de igualdade.
Ele também tem uma pegada muito pequena da memória, e é muito, muito rápido / eficiente ... se você se preocupa com isso.
Na pior das hipóteses, você só vai adicionar este à sua lista de extensões.
De qualquer forma ... aqui 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;
}
Esperamos que isso ajude alguém.
Alguns anos mais tarde, mas isso usa Linq, retorna -1 se não for encontrado, não cria objetos extras, e deve curto-circuito quando encontrado [em oposição a iteração sobre todo o 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);
}
Onde FirstOr 'é:
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);
}
Uma alternativa para encontrar o índice após o fato é para embrulhar o Enumerable, algo semelhante ao usando o 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();
}
}
O que dá um 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);
}
Metida este hoje em busca de respostas e eu pensei que eu gostaria de acrescentar a minha versão para a lista (sem trocadilhos). Ele utlises o operador condicional nula 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á fiz alguns 'correndo dos antigos cavalos' (teste) e para grandes coleções (~ 100.000), cenário de pior caso esse item que você quer é, no final, este é 2x mais rápido do que fazer ToList().FindIndex()
. Se o item que você quer é no meio a sua ~ 4x mais rápido.
Para mais pequenas coleções (~ 10.000) parece ser apenas marginalmente mais rápido
Veja como eu testei https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e
Usando resposta @ Marc Gravell 's, eu encontrei uma maneira de usar o método a seguir:
source.TakeWhile(x => x != value).Count();
a fim de obter -1 quando o item não pode ser encontrada:
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;
}
}
Eu acho que desta forma poderia ser tanto o mais rápido e mais simples. No entanto, eu não testei performances ainda.
Este pode ficar muito legal com uma extensão (que funciona como um proxy), por exemplo:
collection.SelectWithIndex();
// vs.
collection.Select((item, index) => item);
que irá índices automagicamente atribuir à recolha acessível via esta propriedade Index
.
Interface:
public interface IIndexable
{
int Index { get; set; }
}
extensão personalizada (provavelmente mais útil para trabalhar com EF e 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();