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

lambda c#

Question

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

Pero como ejemplo, ¿cuál es la sintaxis correcta para escribir un método ForEach para iterar sobre cada objeto de una List<> , y hacer una Console.WriteLine(object.ToString()) en cada objeto. Algo que toma la 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

¿Es esto lo que estás pidiendo?

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

Answer 2

Desea exponer que no hay mucho de qué preocuparse si alguien proporciona una respuesta como método de extensión porque un método de extensión es simplemente una buena forma 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 usa 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 el resultado es el mismo.

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 debe hacer para convertir un método de extensión en un método de instancia es eliminar 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);
    }
 }

se convierte

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

Answer 3

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

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

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

Answer 4

Puede atravesar cada cadena en la lista e incluso puede buscar en el genérico completo utilizando una única declaración, lo 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 5

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

... y llámalo así:

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

Answer 6

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

... y llámalo así:

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