Bagaimana cara mendapatkan indeks suatu elemen dalam suatu IEnumerable?

Saya menulis ini:

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

Tapi saya tidak tahu apakah itu sudah ada, bukan?

Inti dari mengeluarkan segala sesuatu sebagai IEnumerable adalah agar Anda dapat dengan malas beralih pada isinya. Dengan demikian, tidak ada benar-benar sebuah konsep indeks. Apa yang Anda lakukan sebenarnya tidak masuk akal untuk IEnumerable. Jika Anda memerlukan sesuatu yang mendukung akses berdasarkan indeks, taruh dalam daftar atau koleksi aktual.

Saya akan mempertanyakan kebijaksanaan, tetapi mungkin:

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

(gunakan EqualityComparer<T>.Defaultuntuk meniru !=jika diperlukan) - tetapi Anda harus menonton untuk mengembalikan -1 jika tidak ditemukan ... jadi mungkin lakukan saja

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

Saya akan menerapkannya seperti ini:

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

Cara saya saat ini melakukan ini sedikit lebih pendek dari yang sudah disarankan dan sejauh yang saya tahu memberikan hasil yang diinginkan:

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

Agak kikuk, tetapi berhasil dan cukup ringkas.

Cara terbaik untuk menangkap posisi adalah dengan FindIndexFungsi ini hanya tersedia untukList<>

Contoh

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

Jika Anda memiliki enumerator atau array gunakan cara ini

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

atau

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

Saya pikir opsi terbaik adalah menerapkan seperti ini:

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

Itu juga tidak akan membuat objek anonim

Agak terlambat dalam permainan, saya tahu ... tapi inilah yang baru-baru ini saya lakukan. Ini sedikit berbeda dari milik Anda, tetapi memungkinkan pemrogram untuk menentukan apa yang harus operasi kesetaraan (predikat). Yang saya temukan sangat berguna ketika berhadapan dengan berbagai jenis, karena saya kemudian memiliki cara umum untuk melakukannya terlepas dari jenis objek dan<T> dibangun di operator kesetaraan.

Ini juga memiliki jejak memori yang sangat sangat kecil, dan sangat, sangat cepat / efisien ... jika Anda peduli tentang itu.

Lebih buruk lagi, Anda hanya akan menambahkan ini ke daftar ekstensi Anda.

Ngomong-ngomong ... ini dia.

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

Semoga ini bisa membantu seseorang.

Beberapa tahun kemudian, tetapi ini menggunakan Linq, mengembalikan -1 jika tidak ditemukan, tidak membuat objek tambahan, dan harus korsleting ketika ditemukan [sebagai lawan iterasi seluruh 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);
}

Di mana 'FirstOr' adalah:

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

Tersandung di sini hari ini dalam mencari jawaban dan saya pikir saya akan menambahkan versi saya ke daftar (No pun intended). Ini menggunakan operator bersyarat nol dari 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;

Saya telah melakukan beberapa 'balap kuda tua' (pengujian) dan untuk koleksi besar (~ 100.000), skenario terburuk item yang Anda inginkan adalah pada akhirnya, ini 2x lebih cepat daripada melakukannya ToList().FindIndex(). Jika Item yang Anda inginkan ada di tengah ~ 4x lebih cepat.

Untuk koleksi yang lebih kecil (~ 10.000) sepertinya hanya sedikit lebih cepat

Inilah cara saya mengujinya https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Menggunakan jawaban @Marc Gravell, saya menemukan cara untuk menggunakan metode berikut:

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

untuk mendapatkan -1 saat item tidak dapat ditemukan:

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

Saya kira cara ini bisa menjadi yang tercepat dan lebih sederhana. Namun, saya belum menguji kinerja.

Alternatif untuk menemukan indeks setelah faktanya adalah dengan membungkus Enumerable, agak mirip dengan menggunakan metode 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();
    }
}

Yang memberikan kasus penggunaan:

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

Ini bisa menjadi sangat keren dengan ekstensi (berfungsi sebagai proxy), misalnya:

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

Yang secara otomatis akan menetapkan indeks untuk koleksi yang dapat diakses melalui Indexproperti ini .

Antarmuka:

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

Ekstensi khusus (mungkin paling berguna untuk bekerja dengan EF dan 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();