Einfache Verwendung des IEnumerators (mit Beispiel)

Ich habe Probleme, mich daran zu erinnern, wie (aber nicht warum) IEnumerators in C # verwendet werden soll. Ich bin an Java mit seiner wunderbaren Dokumentation gewöhnt, die Anfängern alles sehr gut erklärt. Also bitte, ertrage es mit mir.

Ich habe erfolglos versucht, aus anderen Antworten auf diesen Boards zu lernen. Anstatt eine allgemeine Frage zu stellen, die bereits zuvor gestellt wurde, habe ich ein spezielles Beispiel, das die Dinge für mich klarstellen würde.

Angenommen, ich habe eine Methode, der ein IEnumerable<String>Objekt übergeben werden muss. Alles, was die Methode tun muss, ist, die Buchstaben roxxorsan das Ende jedes einzelnen Stringim Iterator zu verketten . Dieser neue Iterator wird dann zurückgegeben (natürlich IEnumerablebleibt das ursprüngliche Objekt unverändert ).

Wie würde ich das machen? Die Antwort hier sollte natürlich neben mir vielen bei grundlegenden Fragen zu diesen Objekten helfen.

Hier ist die Dokumentation zu IEnumerator. Sie werden verwendet, um die Werte von Listen abzurufen, bei denen die Länge nicht unbedingt im Voraus bekannt ist (obwohl dies möglich ist). Das Wort kommt von enumerate, was bedeutet "eins zählen oder eins nach dem anderen benennen".

IEnumeratorund IEnumerator<T>wird von allen IEnumerableund IEnumerable<T>Schnittstellen (letztere bieten beide) in .NET über bereitgestellt GetEnumerator(). Dies ist wichtig, da die foreachAnweisung so konzipiert ist, dass sie über diese Schnittstellenmethoden direkt mit Enumeratoren zusammenarbeitet.

Also zum Beispiel:

IEnumerator enumerator = enumerable.GetEnumerator();

while (enumerator.MoveNext())
{
    object item = enumerator.Current;
    // Perform logic on the item
}

Wird:

foreach(object item in enumerable)
{
    // Perform logic on the item
}

In Bezug auf Ihr spezifisches Szenario werden fast alle Sammlungen in .NET implementiert IEnumerable. Aus diesem Grund können Sie Folgendes tun:

public IEnumerator Enumerate(IEnumerable enumerable)
{
    // List implements IEnumerable, but could be any collection.
    List<string> list = new List<string>(); 

    foreach(string value in enumerable)
    {
        list.Add(value + "roxxors");
    }
    return list.GetEnumerator();
}

public IEnumerable<string> Appender(IEnumerable<string> strings)
{
  List<string> myList = new List<string>();
  foreach(string str in strings)
  {
      myList.Add(str + "roxxors");
  }
  return myList;
}

oder

public IEnumerable<string> Appender(IEnumerable<string> strings)
{
  foreach(string str in strings)
  {
      yield return str + "roxxors";
  }
}

unter Verwendung des Ertragskonstrukts oder einfach

var newCollection = strings.Select(str => str + "roxxors"); //(*)

oder

var newCollection = from str in strings select str + "roxxors"; //(**)

wo die beiden letzteren LINQ verwenden und (**)nur syntaktischer Zucker für sind (*).

Wenn ich dich richtig verstehe, dann ist in c # die yield returnCompiler-Magie alles, was du brauchst, denke ich.

z.B

IEnumerable<string> myMethod(IEnumerable<string> sequence)
{
    foreach(string item in sequence)
    {
         yield return item + "roxxors";
    }
}

Ich würde so etwas tun wie:

private IEnumerable<string> DoWork(IEnumerable<string> data)
{
    List<string> newData = new List<string>();
    foreach(string item in data)
    {
        newData.Add(item + "roxxors");
    }
    return newData;
}

Einfaches Zeug :)

Sie können auch die Auswahlmethode von LINQ verwenden:

var source = new[] { "Line 1", "Line 2" };

var result = source.Select(s => s + " roxxors");

Lesen Sie hier mehr Enumerable.Select-Methode