IEnumerable'da bir öğenin dizinini nasıl alabilirim?

Bunu ben yazdım:

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

Ama zaten var olup olmadığını bilmiyorum, değil mi?

IEnumerable olarak şeyleri çıkarmanın tüm amacı, böylece içerik üzerinde tembel bir şekilde tekrarlayabilirsiniz. Bu nedenle, gerçekten bir indeks kavramı yoktur. Yaptığınız şey gerçekten bir IEnumerable için pek mantıklı değil. Dizine göre erişimi destekleyen bir şeye ihtiyacınız varsa, bunu gerçek bir listeye veya koleksiyona koyun.

Bilgeliği sorgulardım ama belki de:

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

( EqualityComparer<T>.Defaultgerekiyorsa taklit etmek için kullanılır !=) - ancak bulunamazsa -1'e dönmek için izlemeniz gerekir ... bu yüzden belki de uzun yoldan yapın

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

Ben böyle uygulamak istiyorum:

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

Şu anda bunu yapmanın yolu zaten önerilenlerden biraz daha kısa ve söyleyebildiğim kadarıyla istenen sonucu veriyor:

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

Biraz hantal, ama işi yapıyor ve oldukça özlü.

Konumu yakalamanın en iyi yolu şudur: FindIndexBu işlev yalnızca şunlar için kullanılabilir:List<>

Misal

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

Numaralandırıcı veya diziniz varsa bu yolu kullanın

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

veya

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

Bence en iyi seçenek böyle uygulamaktır:

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

Ayrıca anonim nesne oluşturmaz

Oyuna biraz geç biliyorum, ama son zamanlarda yaptığım da bu. Sizinkinden biraz farklıdır, ancak programcının eşitlik işleminin ne olması gerektiğini dikte etmesine izin verir (yüklem). Hangi i farklı türlerle uğraşırken çok yararlı buluyorum, çünkü o zaman nesne türü ne olursa olsun bunu yapmak ve genel <T>eşitlik operatörü inşa genel bir yolu var .

Ayrıca çok küçük bir bellek alanına sahiptir ve çok, çok hızlı / verimlidir ... eğer bunu önemsiyorsanız.

Daha da kötüsü, bunu uzantı listenize eklemeniz yeterlidir.

Her neyse ... işte burada.

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

Umarım bu birine yardımcı olur.

Birkaç yıl sonra, ancak bu Linq kullanır, bulunmazsa -1 döndürür, fazladan nesne oluşturmaz ve [IEnumerable'ın tamamında yinelemenin aksine] bulunduğunda kısa devre yapmalıdır :

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

'FirstOr' nerede:

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

Bugün cevaplar bulmak için tökezledi ve ben versiyonumu listeye eklemek istiyorum düşündüm (Hiçbir ceza amaçlanan). C # 6.0 null koşullu işleci kullanır

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;

Bazı 'eski atların yarışı' (test) ve büyük koleksiyonlar (~ 100.000) için yaptım, istediğiniz öğenin sonunda en kötü durum senaryosu, bu yapmaktan 2 kat daha hızlı ToList().FindIndex(). İstediğiniz Öğe ortada ise ~ 4x daha hızlı.

Daha küçük koleksiyonlar için (~ 10.000) sadece çok daha hızlı görünüyor

Heres nasıl test ettim https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

@Marc Gravell yanıtını kullanarak, aşağıdaki yöntemi kullanmanın bir yolunu buldum:

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

Öğe bulunamadığında -1 almak için:

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

Sanırım bu yol hem en hızlı hem de daha basit olabilir. Ancak, henüz performansları test etmedim.

Gerçekten sonra dizini bulmanın bir alternatifi, Linq GroupBy () yöntemini kullanmaya benzer şekilde, Numaralandırılabilir'i sarmaktır.

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

Hangi kullanım örneği verir:

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

Bu, bir uzantıyla (proxy olarak işlev görür) gerçekten harika olabilir, örneğin:

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

Bu, otomatik olarak bu Indexözellik üzerinden erişilebilen koleksiyona dizinler atar .

Arayüz:

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

Özel uzantı (muhtemelen en çok EF ve DbContext ile çalışmak için yararlıdır):

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