วิธีรับดัชนีขององค์ประกอบใน IEnumerable?

ฉันเขียนสิ่งนี้:

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

แต่ฉันไม่รู้ว่ามันมีอยู่แล้วใช่ไหม?

จุดรวมของการกำจัดสิ่งต่าง ๆ ออกมาในรูปแบบของ IEnumerable นั้นทำให้คุณสามารถทำซ้ำเนื้อหาได้อย่างเกียจคร้าน เป็นเช่นนี้มีไม่ได้จริงๆแนวคิดของดัชนี สิ่งที่คุณกำลังทำจริงๆไม่สมเหตุสมผลสำหรับ IEnumerable หากคุณต้องการสิ่งที่รองรับการเข้าถึงโดยดัชนีให้ใส่ไว้ในรายการหรือคอลเล็กชันจริง

ฉันถามภูมิปัญญา แต่บางที:

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

(ใช้EqualityComparer<T>.Defaultเพื่อเลียนแบบ!=ถ้าจำเป็น) - แต่คุณต้องดูกลับ -1 ถ้าไม่พบ ... ดังนั้นบางทีมันอาจจะเป็นทางยาว

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

ฉันจะใช้มันเช่นนี้

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

วิธีที่ฉันทำอยู่ในขณะนี้สั้นกว่าที่แนะนำเล็กน้อยและเท่าที่ฉันจะบอกได้ก็ให้ผลลัพธ์ที่ต้องการ:

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

มันค่อนข้างเงียบ แต่ก็ทำหน้าที่ได้ค่อนข้างกระชับ

วิธีที่ดีที่สุดในการรับตำแหน่งคือโดยFindIndexฟังก์ชั่นนี้ใช้ได้เฉพาะสำหรับList<>

ตัวอย่าง

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

หากคุณมีตัวแจงนับหรืออาร์เรย์ใช้วิธีนี้

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

หรือ

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

ฉันคิดว่าตัวเลือกที่ดีที่สุดคือการใช้เช่นนี้

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

มันจะไม่สร้างวัตถุที่ไม่ระบุชื่อ

สายในเกมฉันรู้ ... แต่นี่คือสิ่งที่ฉันเพิ่งทำ มันแตกต่างจากของคุณเล็กน้อย แต่อนุญาตให้โปรแกรมเมอร์กำหนดสิ่งที่การดำเนินการความเท่าเทียมกันจะต้อง (ภาคแสดง) ซึ่งฉันพบว่ามีประโยชน์มากเมื่อจัดการกับประเภทที่แตกต่างกันเนื่องจากฉันมีวิธีทั่วไปในการทำโดยไม่คำนึงถึงประเภทของวัตถุและ<T>สร้างขึ้นในตัวดำเนินการความเท่าเทียมกัน

นอกจากนี้ยังมีหน่วยความจำขนาดเล็กมากและรวดเร็วมาก / มีประสิทธิภาพ ... ถ้าคุณเป็นห่วง

ที่แย่กว่านั้นคือคุณจะเพิ่มส่วนนี้ลงในรายการส่วนขยายของคุณ

อย่างไรก็ตาม ... นี่ไง

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

หวังว่านี่จะช่วยใครซักคน

ไม่กี่ปีต่อมา แต่สิ่งนี้ใช้ Linq ส่งคืน -1 หากไม่พบไม่สร้างวัตถุพิเศษและควรลัดวงจรเมื่อพบ [เมื่อเทียบกับการวนซ้ำทั่ว 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);
}

ที่ '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);
}

เจอสิ่งนี้ในวันนี้เพื่อค้นหาคำตอบและฉันคิดว่าฉันจะเพิ่มเวอร์ชันของฉันลงในรายการ มันใช้ตัวดำเนินการ null แบบไม่มีเงื่อนไขของ 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;

ฉันได้ทำบาง 'แข่งม้าเก่า' (การทดสอบ) และสำหรับคอลเลกชันขนาดใหญ่ (~ 100,000) กรณีสถานการณ์ที่เลวร้ายที่สุดที่รายการที่คุณต้องการเป็นที่สิ้นสุดนี้เป็น2 เท่าToList().FindIndex()ได้เร็วขึ้นกว่าการทำ หากรายการที่คุณต้องการอยู่ตรงกลางมันจะเร็วกว่า~ 4x

สำหรับคอลเลกชันขนาดเล็ก (~ 10,000) ดูเหมือนว่าจะเร็วขึ้นเพียงเล็กน้อยเท่านั้น

นี่คือวิธีที่ฉันทดสอบมันhttps://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

ใช้คำตอบของ @Marc Gravell ฉันพบวิธีใช้วิธีต่อไปนี้:

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

เพื่อรับ -1 เมื่อไม่พบรายการ:

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

ฉันคิดว่าวิธีนี้อาจเป็นได้ทั้งเร็วและง่ายกว่า อย่างไรก็ตามฉันยังไม่ได้ทดสอบการแสดง

อีกทางเลือกหนึ่งในการค้นหาดัชนีหลังจากข้อเท็จจริงคือการห่อ Enumerable ค่อนข้างคล้ายกับการใช้วิธี 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();
    }
}

ซึ่งให้กรณีการใช้งานของ:

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

สิ่งนี้จะเจ๋งจริง ๆ ด้วยส่วนขยาย (ทำงานเป็นพร็อกซี) ตัวอย่างเช่น:

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

ซึ่งโดยอัตโนมัติจะกำหนดดัชนีให้กับคอลเลกชันที่สามารถเข้าถึงได้ผ่านทางนี้ Indexคุณสมบัตินี้

อินเตอร์เฟซ:

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

ส่วนขยายที่กำหนดเอง (อาจมีประโยชน์มากที่สุดสำหรับการทำงานกับ EF และ 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();