Wie erhalte ich den Index eines Elements in einer IEnumerable?

Ich habe das geschrieben:

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

Aber ich weiß nicht, ob es das schon gibt, oder?

Der springende Punkt beim Herausgeben von Dingen als IEnumerable ist, dass Sie den Inhalt träge durchlaufen können. Als solches ist es nicht wirklich ein Konzept eines Index. Was Sie tun, macht für eine IEnumerable wirklich keinen Sinn. Wenn Sie etwas benötigen, das den Zugriff per Index unterstützt, fügen Sie es in eine aktuelle Liste oder Sammlung ein.

Ich würde die Weisheit in Frage stellen, aber vielleicht:

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

(Verwenden EqualityComparer<T>.Default, um !=bei Bedarf zu emulieren ) - aber Sie müssen darauf achten, -1 zurückzugeben, wenn es nicht gefunden wird ... also machen Sie es vielleicht einfach den langen Weg

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

Ich würde es so implementieren:

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

Die Art und Weise, wie ich das derzeit mache, ist etwas kürzer als die bereits vorgeschlagenen und ergibt, soweit ich das beurteilen kann, das gewünschte Ergebnis:

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

Es ist ein bisschen klobig, aber es macht den Job und ist ziemlich prägnant.

Der beste Weg, um die Position zu erfassen, ist: FindIndexDiese Funktion ist nur für verfügbarList<>

Beispiel

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

Wenn Sie einen Enumerator oder ein Array haben, verwenden Sie diese Methode

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

oder

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

Ich denke, die beste Option ist, Folgendes zu implementieren:

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

Das anonyme Objekt wird ebenfalls nicht erstellt

Ein bisschen spät im Spiel, ich weiß ... aber das habe ich kürzlich getan. Es unterscheidet sich geringfügig von Ihrem, ermöglicht es dem Programmierer jedoch, zu bestimmen, wie die Gleichstellungsoperation aussehen soll (Prädikat). Was ich sehr nützlich finde, wenn ich mich mit verschiedenen Typen befasse, da ich dann eine generische Methode habe, dies unabhängig vom Objekttyp und dem <T>eingebauten Gleichheitsoperator zu tun .

Es hat auch einen sehr sehr kleinen Speicherbedarf und ist sehr, sehr schnell / effizient ... wenn Sie sich dafür interessieren.

Schlimmer noch, Sie fügen dies einfach Ihrer Liste der Erweiterungen hinzu.

Wie auch immer ... hier ist es.

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

Hoffentlich hilft das jemandem.

Ein paar Jahre später, aber dies verwendet Linq, gibt -1 zurück, wenn es nicht gefunden wird, erstellt keine zusätzlichen Objekte und sollte kurzschließen, wenn es gefunden wird [im Gegensatz zum Iterieren über die gesamte 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);
}

Wo 'FirstOr' ist:

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

Ich bin heute auf der Suche nach Antworten darüber gestolpert und dachte, ich würde meine Version zur Liste hinzufügen (kein Wortspiel beabsichtigt). Es verwendet den bedingten Nulloperator von 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;

Ich habe einige "Rennen der alten Pferde" (Tests) durchgeführt und für große Sammlungen (~ 100.000) ist das schlimmste Szenario, das der gewünschte Gegenstand am Ende hat, 2x schneller als dies der Fall ist ToList().FindIndex(). Wenn sich der gewünschte Gegenstand in der Mitte befindet, ist er ~ 4x schneller.

Für kleinere Sammlungen (~ 10.000) scheint es nur unwesentlich schneller zu sein

Hier ist, wie ich es getestet habe https://gist.github.com/insulind/16310945247fcf13ba186a45734f254e

Mit der Antwort von @Marc Gravell habe ich einen Weg gefunden, die folgende Methode zu verwenden:

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

um -1 zu erhalten, wenn der Gegenstand nicht gefunden werden kann:

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

Ich denke, dieser Weg könnte sowohl der schnellste als auch der einfachere sein. Allerdings habe ich die Leistungen noch nicht getestet.

Eine Alternative zum nachträglichen Suchen des Index besteht darin, die Aufzählung zu umbrechen, ähnlich wie bei der Verwendung der Linq GroupBy () -Methode.

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

Welches gibt einen Anwendungsfall von:

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

Dies kann mit einer Erweiterung (die als Proxy fungiert) sehr cool werden, zum Beispiel:

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

Dadurch werden der Sammlung, auf die über diese IndexEigenschaft zugegriffen werden kann, automatisch Indizes zugewiesen .

Schnittstelle:

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

Benutzerdefinierte Erweiterung (wahrscheinlich am nützlichsten für die Arbeit mit EF und 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();