Làm thế nào để có được chỉ mục của một phần tử trong IEnumerable?

Tôi đã viết điều này:

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

Nhưng tôi không biết nếu nó đã tồn tại, phải không?

Toàn bộ vấn đề nhận được mọi thứ như IEnumerable là để bạn có thể lặp đi lặp lại một cách lười biếng các nội dung. Như vậy, thực sự không có khái niệm về một chỉ mục. Những gì bạn đang làm thực sự không có nhiều ý nghĩa đối với một IEnumerable. Nếu bạn cần thứ gì đó hỗ trợ truy cập theo chỉ mục, hãy đặt nó vào danh sách hoặc bộ sưu tập thực tế.

Tôi muốn hỏi sự khôn ngoan, nhưng có lẽ:

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

(sử dụng EqualityComparer<T>.Defaultđể mô phỏng !=nếu cần) - nhưng bạn cần xem để trả về -1 nếu không tìm thấy ... vì vậy có lẽ chỉ cần thực hiện theo cách lâu dài

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

Tôi sẽ thực hiện nó như thế này:

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

Cách tôi hiện đang làm điều này ngắn hơn một chút so với những gì đã được đề xuất và theo như tôi có thể nói cho kết quả mong muốn:

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

Đó là một chút lộn xộn, nhưng nó làm công việc và khá súc tích.

Cách tốt nhất để bắt vị trí là FindIndex Chức năng này chỉ khả dụng choList<>

Thí dụ

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

Nếu bạn có liệt kê hoặc mảng sử dụng theo cách này

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

hoặc là

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

Tôi nghĩ rằng lựa chọn tốt nhất là thực hiện như thế này:

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

Nó cũng sẽ không tạo đối tượng ẩn danh

Một chút muộn trong trò chơi, tôi biết ... nhưng đây là những gì tôi đã làm gần đây. Nó hơi khác so với của bạn, nhưng cho phép lập trình viên ra lệnh cho hoạt động bình đẳng cần là gì (vị ngữ). Mà tôi thấy rất hữu ích khi xử lý các loại khác nhau, vì sau đó tôi có cách làm chung chung bất kể loại đối tượng và<T> được xây dựng trong toán tử đẳng thức.

Nó cũng có dung lượng bộ nhớ rất nhỏ và rất, rất nhanh / hiệu quả ... nếu bạn quan tâm đến điều đó.

Tệ hơn nữa, bạn sẽ chỉ thêm phần này vào danh sách các tiện ích mở rộng của mình.

Dù sao ... đây rồi.

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

Hy vọng điều này sẽ giúp được ai đó.

Một vài năm sau, nhưng điều này sử dụng Linq, trả về -1 nếu không tìm thấy, không tạo thêm các đối tượng và sẽ bị đoản mạch khi tìm thấy [trái ngược với việc lặp lại trên toàn bộ 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);
}

Trong đó 'FirstOr' là:

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

Tình cờ tìm thấy điều này ngày hôm nay trong một cuộc tìm kiếm câu trả lời và tôi nghĩ rằng tôi đã thêm phiên bản của mình vào danh sách (Không có ý định chơi chữ). Nó sử dụng toán tử điều kiện null của 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;

Tôi đã thực hiện một số 'cuộc đua của những con ngựa già' (thử nghiệm) và đối với các bộ sưu tập lớn (~ 100.000), trường hợp xấu nhất mà mục bạn muốn là ở cuối, điều này nhanh hơn gấp 2 lần so với thực hiện ToList().FindIndex(). Nếu Mục bạn muốn nằm ở giữa ~ 4x nhanh hơn .

Đối với các bộ sưu tập nhỏ hơn (~ 10.000), dường như chỉ nhanh hơn một chút

Đây là cách tôi đã thử nghiệm https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Sử dụng câu trả lời của @Marc Gravell, tôi đã tìm ra cách sử dụng phương pháp sau:

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

để có được -1 khi không thể tìm thấy vật phẩm:

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

Tôi đoán cách này có thể là nhanh nhất và đơn giản hơn. Tuy nhiên, tôi chưa thử nghiệm màn trình diễn.

Một cách khác để tìm chỉ mục sau khi thực tế là bao bọc Enumerable, hơi giống với sử dụng phương thức 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();
    }
}

Cung cấp cho một trường hợp sử dụng:

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

Điều này có thể trở nên thực sự thú vị với một tiện ích mở rộng (hoạt động như một proxy), ví dụ:

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

Cái nào sẽ tự động gán các chỉ mục cho bộ sưu tập có thể truy cập thông qua điều này Index tính này.

Giao diện:

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

Tiện ích mở rộng tùy chỉnh (có thể hữu ích nhất để làm việc với EF và 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();