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

오늘 답변을 찾기 위해이 문제를 우연히 발견했으며 내 버전을 목록에 추가 할 것이라고 생각했습니다. c # 6.0의 null 조건부 연산자를 사용하지 않습니다.

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(). 원하는 아이템이 중간에 ~ 4 배 빠릅니다.

소규모 컬렉션 (~ 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;
    }
}

나는이 방법이 가장 빠르고 간단 할 수 있다고 생각합니다. 그러나 아직 성능을 테스트하지 않았습니다.

사실 이후 인덱스를 찾는 대안은 Linq GroupBy () 메서드를 사용하는 것과 다소 비슷한 Enumerable을 래핑하는 것입니다.

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