Syntaxe C# - Exemple d'une expression lambda - ForEach() sur la liste générique

Question

Tout d'abord, je sais qu'il existe des méthodes hors de la classe List<> générique déjà dans le cadre itérer sur le List<>.

Mais à titre d'exemple, quelle est la syntaxe correcte pour écrire une méthode ForEach pour itérer sur chaque objet d'un List<> et faire un Console.WriteLine(object.ToString()) sur chaque objet. Quelque chose qui prend le List<> comme premier argument et l'expression lambda comme deuxième argument.

La plupart des exemples que j'ai vus sont effectués comme des méthodes d'extension ou impliquent LINQ. Je cherche un exemple de méthode simple.

Answer 1

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

... et l'appeler ainsi:

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

Answer 2

ci-dessus pourrait également être écrit avec moins de code comme:

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

Ce qu'il crée une liste générique et remplit avec la IEnumerable, puis appelle les objets de liste ForEach.

Answer 3

Vous pouvez parcourir chaque chaîne dans la liste et même vous pouvez effectuer une recherche dans l'ensemble générique en utilisant une seule instruction, ce qui facilite la recherche.

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

Est-ce ce que vous demandez?

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

... et l'appeler ainsi:

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

Answer 6

Vous voulez mettre là-bas qu'il n'y a pas grand-chose à se soucier si quelqu'un apporte une réponse en tant que méthode d'extension, car une extension méthode est juste une façon cool d'appeler une méthode d'instance. Je comprends que vous voulez la réponse sans utiliser une méthode d'extension. Peu importe si la méthode est définie comme statique, instance ou extension - le résultat est le même.

Le code ci-dessous utilise le code de la réponse acceptée pour définir une méthode d'extension et une méthode d'instance et crée un test unitaire pour montrer que la sortie est la même. Littéralement

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

, la seule chose que vous devez faire pour convertir une méthode d'extension à une méthode d'instance est de supprimer le modificateur static et le premier paramètre de la méthode.

Cette méthode

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

devient

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