C # Unterschied zwischen First () und Find ()

Also ich weiß, dass Find() ist nur ein List<T> Methode, in der Erwägung, dass First() ist eine Erweiterung für alle IEnumerable<T>. Ich weiß auch, dass First() wird das erste element zurückzugeben, wenn kein parameter übergeben wird, in der Erwägung, dass Find() wird eine exception werfen. Schließlich weiß ich, dass First() wird eine Ausnahme ausgelöst, wenn das element nicht gefunden, wohingegen Find() zurück, geben Sie den Standardwert.

Ich hoffe, das klärt die Verwirrung über das, was ich wirklich bin, zu Fragen. Dies ist eine informatik Frage, und die beschäftigt sich mit diesen Methoden auf die rechnerische Ebene. Ich bin gekommen, zu verstehen, dass IEnumerable<T> Erweiterungen nicht immer funktionieren, wie man erwarten würde, unter der Haube. So, hier ist der Q, und ich meine, von einem "nahe am Metall" Standpunkt: Was ist der Unterschied zwischen Find() und First()?

Hier finden Sie den code, um grundlegende Annahmen für den Betrieb unter diese Frage.

var l = new List<int> { 1, 2, 3, 4, 5 };
var x = l.First(i => i == 3);
var y = l.Find(i => i == 3);

Ist es, die tatsächliche rechnerische Differenz zwischen dem, wie First() und Find() entdecken Sie Ihre Werte in dem code oben?

Beachten Sie: Lassen Sie uns ignorieren Dinge wie AsParallel() und AsQueryable() für jetzt.

InformationsquelleAutor der Frage Squirrelsama | 2010-12-06

  1. 50

    Hier ist der code für List<T>.Find (aus Reflektor):

    public T Find(Predicate<T> match)
{
    if (match == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
    }
    for (int i = 0; i < this._size; i++)
    {
        if (match(this._items[i]))
        {
            return this._items[i];
        }
    }
    return default(T);
}

    Und hier ist Enumerable.First:

    public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    if (predicate == null)
    {
        throw Error.ArgumentNull("predicate");
    }
    foreach (TSource local in source)
    {
        if (predicate(local))
        {
            return local;
        }
    }
    throw Error.NoMatch();
}

    Also beide Methoden in etwa die gleiche Art und Weise: Sie Durchlaufen alle Elemente, bis Sie finden, das entspricht dem Prädikat. Der einzige auffällige Unterschied ist, dass Find verwendet eine for Schleife, weil es bereits weiß, die Anzahl der Elemente, und First verwendet eine foreach-Schleife, da Sie es nicht kennt.

    InformationsquelleAutor der Antwort Thomas Levesque

  2. 16

    First wird eine exception werfen, wenn es nichts findet, FirstOrDefault jedoch macht genau das gleiche wie Find (abgesehen von der Frage, wie es iteriert durch die Elemente).

    InformationsquelleAutor der Antwort Doggett

  3. 2

    BTW Finden, ist eher gleich FirstOrDefault() als First(). Denn wenn Prädikat First() ist nicht zufrieden mit der Liste alle Elemente, erhalten Sie eine Ausnahme.
    Hier was wieder ein dotpeek, eine andere große kostenlos Reflektor-Ersatz mit einigen von ReSharper-Funktionen

    Hier für Enumerable.First(...) und Enumerable.FirstOrDefault(...) extension Methoden:

        public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
        if (source == null) throw Error.ArgumentNull("source");
        if (predicate == null) throw Error.ArgumentNull("predicate");
        foreach (TSource element in source) { 
            if (predicate(element)) return element;
        } 
        return default(TSource); 
    }


    public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
        if (source == null) throw Error.ArgumentNull("source"); 
        if (predicate == null) throw Error.ArgumentNull("predicate"); 
        foreach (TSource element in source) {
            if (predicate(element)) return element; 
        }
        throw Error.NoMatch();
    }

    und hier ist für List<>.Finden:

    ///<summary>
///Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire <see cref="T:System.Collections.Generic.List`1"/>.
///</summary>
///
///<returns>
///The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T"/>.
///</returns>
///<param name="match">The <see cref="T:System.Predicate`1"/> delegate that defines the conditions of the element to search for.</param><exception cref="T:System.ArgumentNullException"><paramref name="match"/> is null.</exception>
[__DynamicallyInvokable]
public T Find(Predicate<T> match)
{
  if (match == null)
    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
  for (int index = 0; index < this._size; ++index)
  {
    if (match(this._items[index]))
      return this._items[index];
  }
  return default (T);
}

    InformationsquelleAutor der Antwort python_kaa

  4. 1

    Seit List<> ist nicht indiziert in irgendeiner Weise, es hat zu gehen durch alle Werte zu finden, die einen bestimmten Wert. Von daher hat er nicht viel von einem Unterschied im Vergleich zum Durchlaufen der Liste über ein enumerable (abgesehen von der Schaffung einer aufzählbaren helper object-Instanz).

    Sagte, im Hinterkopf behalten, dass die Find Funktion wurde Weise früher als die First Erweiterung Methode (Framework V2.0 vs. V3.5), und ich bezweifle, dass Sie würden umgesetzt haben Find wenn die List<> Klasse wurde implementiert in der gleichen Zeit wie die Erweiterung Methoden.

    InformationsquelleAutor der Antwort Lucero

  5. 0

    Wäre es auch wahr, dass die Verwendung Finden, auf etwas, das ist ein enumerator, anstatt einer Liste wird ein potential haben, die Leistung Kosten, da ein enumerator kann nicht Holen die ganze Liste, die das Prädikat erfüllen? Umgekehrt, wenn Sie bereits über eine Liste, dann Finden Sie besser wäre.

    InformationsquelleAutor der Antwort pkr2000

Schreibe einen Kommentar