Sintaxis de C# - Ejemplo de una expresión de Lambda - ForEach() sobre la lista genérica

Question

En primer lugar, sé que hay métodos fuera de la clase genérica List<> que ya están en el marco iterar sobre List<>.

Pero como ejemplo, ¿cuál es la sintaxis correcta para escribir un método ForEach para iterar sobre cada objeto de un List<>, y hacer un Console.WriteLine(object.ToString()) en cada objeto. Algo que toma el List<> como primer argumento y la expresión lambda como el segundo argumento.

La mayoría de los ejemplos que he visto se hacen como métodos de extensión o involucran LINQ. Estoy buscando un ejemplo de método simple.

Answer 1

public void Each<T>(IEnumerable<T> items, Action<T> action) 
{ 
    foreach (var item in items) 
     action(item); 
} 

... y lo llaman así:

Each(myList, i => Console.WriteLine(i)); 

Answer 2

Lo anterior también se podría escribir con menos código como:

new List<SomeType>(items).ForEach(
    i => Console.WriteLine(i) 
); 

Esto crea una lista genérica y lo llena con el IEnumerable y luego llama a la lista de objetos ForEach.

Answer 3

Puede recorrer cada cadena en la lista e incluso puede buscar en el genérico completo utilizando una sola instrucción que facilita la búsqueda.

public static void main(string[] args) 
{ 
List names = new List(); 

names.Add(“Saurabh”); 
names.Add("Garima"); 
names.Add(“Vivek”); 
names.Add(“Sandeep”); 

string stringResult = names.Find(name => name.Equals(“Garima”)); 
} 

Answer 4

¿Es esto lo que estás pidiendo?

int[] numbers = { 1, 2, 3 }; 
numbers.ToList().ForEach(n => Console.WriteLine(n)); 

Answer 5

public static void Each<T>(this IEnumerable<T> items, Action<T> action) { 
foreach (var item in items) { 
    action(item); 
} } 

... y lo llaman así:

myList.Each(x => { x.Enabled = false; }); 

Answer 6

quiere poner por ahí que no hay mucho que preocuparse de si alguien da una respuesta como un método de extensión debido a una extensión método es solo una forma genial de llamar a un método de instancia. Entiendo que quieres la respuesta sin usar un método de extensión. Independientemente de si el método se define como estático, instancia o extensión, el resultado es el mismo.

El siguiente código utiliza el código de la respuesta aceptada para definir un método de extensión y un método de instancia y crea una prueba de unidad para mostrar que la salida es la misma.

public static class Extensions 
{ 
    public static void Each<T>(this IEnumerable<T> items, Action<T> action) 
    { 
     foreach (var item in items) 
     { 
      action(item); 
     } 
    } 
} 

[TestFixture] 
public class ForEachTests 
{ 
    public void Each<T>(IEnumerable<T> items, Action<T> action) 
    { 
     foreach (var item in items) 
     { 
      action(item); 
     } 
    } 

    private string _extensionOutput; 

    private void SaveExtensionOutput(string value) 
    { 
     _extensionOutput += value; 
    } 

    private string _instanceOutput; 

    private void SaveInstanceOutput(string value) 
    { 
     _instanceOutput += value; 
    } 

    [Test] 
    public void Test1() 
    { 
     string[] teams = new string[] {"cowboys", "falcons", "browns", "chargers", "rams", "seahawks", "lions", "heat", "blackhawks", "penguins", "pirates"}; 

     Each(teams, SaveInstanceOutput); 

     teams.Each(SaveExtensionOutput); 

     Assert.AreEqual(_extensionOutput, _instanceOutput); 
    } 
} 

Literalmente, lo único que tiene que hacer para convertir un método de extensión a un método de instancia es quitar el modificador static y el primer parámetro del método.

Este método

public static void Each<T>(this IEnumerable<T> items, Action<T> action) 
{ 
    foreach (var item in items) 
    { 
     action(item); 
    } 
} 

convierte

public void Each<T>(Action<T> action) 
{ 
    foreach (var item in items) 
    { 
     action(item); 
    } 
}