Uso simple de IEnumerator (con ejemplo)

Question

Tengo problemas para recordar cómo (pero no por qué) usar IEnumeratorS en C#. Estoy acostumbrado a Java con su maravillosa documentación que explica todo a los principiantes bastante bien. Así que por favor, tengan paciencia conmigo.

He intentado aprender de otras respuestas en estos tableros en vano. En lugar de hacer una pregunta genérica que ya se ha hecho antes, tengo un ejemplo específico que aclararía las cosas para mí.

Supongamos que tengo un método que debe pasar un IEnumerable<String> objeto. Todo lo que el método debe hacer es concatenar las letras roxxors al final de cada String en el iterador. Luego devolverá este nuevo iterador (por supuesto el original IEnumerable El objeto se deja como estaba).

¿Cómo haría esto? La respuesta aquí debería ayudar a muchos con preguntas básicas sobre estos objetos, además de mí, por supuesto.

Answer 1

Aquí está la documentación en IEnumerator. Se utilizan para obtener los valores de las listas, donde la longitud no necesariamente se conoce con anticipación (aunque podría ser). La palabra viene de enumerate, que significa "contar o nombrar uno por uno".

IEnumerator y IEnumerator<T> es proporcionado por todos IEnumerable y IEnumerable<T> interfaces (esta última proporcionando ambas) en .net a través de GetEnumerator(). Esto es importante porque el foreach La declaración está diseñada para trabajar directamente con los enumeradores a través de esos métodos de interfaz.

Así por ejemplo:

IEnumerator enumerator = enumerable.GetEnumerator();

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

Se convierte en:

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

En cuanto a su escenario específico, casi todas las colecciones en .NET implementan IEnumerable. Por eso, puedes hacer lo siguiente:

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

Answer 2

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

o

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

utilizando el construcción de rendimiento, o simplemente

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

o

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

donde usan los dos últimos Linq y (**) es solo azúcar sintáctica para (*).

Answer 3

Si te entiendo correctamente, entonces en C# el yield return La magia del compilador es todo lo que necesitas, creo.

p.ej

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

Answer 4

Haría algo como:

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

Cosas simples :)

Answer 5

También puede usar el método de selección de Linq:

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

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

Leer más aquí Enumerable. Método de selección