S'il y a un morceau de code que vous répétez tout le temps selon Do not Repeat Yourself, vous devriez le mettre dans votre propre bibliothèque et l'appeler. Dans cet esprit, il y a 2 aspects pour obtenir la bonne réponse ici. Le premier est la clarté et la brièveté du code qui appelle la fonction de bibliothèque. La seconde est les implications de performance de foreach.
D'abord, réfléchissons à la clarté et à la brièveté du code d'appel.
Vous pouvez faire foreach dans plusieurs façons:
- boucle
- boucle foreach
- Collection.ForEach
De toutes les façons de faire une liste de foreach. ForEach avec un lamba est le plus clair et le plus bref. Donc, à ce stade, il peut sembler que le List.ForEach est le chemin à parcourir. Cependant quelle est la performance de ceci? Il est vrai que dans ce cas le temps d'écriture sur la console va régir la performance du code. Lorsque nous savons quelque chose sur la performance d'une caractéristique particulière d'un langage, nous devrions au moins le considérer. La méthode la plus rapide pour parcourir la liste sous code optimisé est d'utiliser une boucle for sans appel à List.Count.
La boucle for est cependant une construction verbeuse. Il est également considéré comme une manière très itérative de faire les choses qui ne correspond pas à la tendance actuelle vers les idiomes fonctionnels.
Alors, pouvons-nous obtenir la brièveté, la clarté et la performance? Nous pouvons en utilisant une méthode d'extension. Dans un monde idéal, nous allons créer une méthode d'extension sur Console qui prend une liste et l'écrit avec un délimiteur. Nous ne pouvons pas le faire car la console est une classe statique et les méthodes d'extension ne fonctionnent que sur les instances de classes. Au lieu de cela nous avons besoin de mettre la méthode d'extension sur la liste elle-même (selon la suggestion de David B):
public static void WriteLine(this List<int> theList)
{
foreach (int i in list)
{
Console.Write("{0}\t", t.ToString());
}
Console.WriteLine();
}
Ce code va utilisé dans de nombreux endroits que nous devons mener à bien les améliorations suivantes:
- Au lieu d'utiliser foreach, nous devrions utiliser le moyen le plus rapide d'itérer la collection qui est une boucle for avec un nombre mis en cache.
- Actuellement, seule la liste peut être passée en argument. En tant que fonction de bibliothèque, nous pouvons la généraliser en faisant un petit effort.
- L'utilisation de la liste nous limite aux listes. L'utilisation de IList permet à ce code de fonctionner également avec les tableaux.
- Puisque la méthode d'extension sera sur un IList nous devons changer le nom pour le rendre plus clair ce que nous écrivons:
Voici comment le code de la fonction regarderais:
public static void WriteToConsole<T>(this IList<T> collection)
{
int count = collection.Count();
for(int i = 0; i < count; ++i)
{
Console.Write("{0}\t", collection[i].ToString(), delimiter);
}
Console.WriteLine();
}
Nous pouvons encore améliorer cela en permettant au client de passer dans le délimiteur. Nous pourrions alors fournir une seconde fonction qui écrit à la console avec le séparateur standard comme ceci:
public static void WriteToConsole<T>(this IList<T> collection)
{
WriteToConsole<T>(collection, "\t");
}
public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
int count = collection.Count();
for(int i = 0; i < count; ++i)
{
Console.Write("{0}{1}", collection[i].ToString(), delimiter);
}
Console.WriteLine();
}
Alors maintenant, étant donné que nous voulons une brève, claire façon des listes performante écriture à la console que nous avons un. Voici tout le code source, y compris une démonstration de l'utilisation de la fonction de la bibliothèque:
using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleWritelineTest
{
public static class Extensions
{
public static void WriteToConsole<T>(this IList<T> collection)
{
WriteToConsole<T>(collection, "\t");
}
public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
int count = collection.Count();
for(int i = 0; i < count; ++i)
{
Console.Write("{0}{1}", collection[i].ToString(), delimiter);
}
Console.WriteLine();
}
}
internal class Foo
{
override public string ToString()
{
return "FooClass";
}
}
internal class Program
{
static void Main(string[] args)
{
var myIntList = new List<int> {1, 2, 3, 4, 5};
var myDoubleList = new List<double> {1.1, 2.2, 3.3, 4.4};
var myDoubleArray = new Double[] {12.3, 12.4, 12.5, 12.6};
var myFooList = new List<Foo> {new Foo(), new Foo(), new Foo()};
// Using the standard delimiter /t
myIntList.WriteToConsole();
myDoubleList.WriteToConsole();
myDoubleArray.WriteToConsole();
myFooList.WriteToConsole();
// Using our own delimiter ~
myIntList.WriteToConsole("~");
Console.Read();
}
}
}
============================ ==============================
Vous pourriez penser que cela devrait être la fin de la réponse. Cependant, il y a un autre élément de généralisation qui peut être fait. La question de fatcat n'est pas claire s'il écrit toujours sur la console. Peut-être que quelque chose d'autre doit être fait dans le foreach. Dans ce cas, la réponse de Jason Bunting va donner cette généralité. Voici sa réponse encore:
list.ForEach(i => Console.Write("{0}\t", i));
C'est à moins de faire un plus de raffinement à nos méthodes d'extension et d'ajouter FastForEach comme ci-dessous:
public static void FastForEach<T>(this IList<T> collection, Action<T> actionToPerform)
{
int count = collection.Count();
for (int i = 0; i < count; ++i)
{
actionToPerform(collection[i]);
}
Console.WriteLine();
}
Cela nous permet d'exécuter un code arbitraire contre tous les éléments dans la collection en utilisant la méthode d'itération la plus rapide possible.
On peut même changer la fonction WriteToConsole utiliser FastForEach
public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
collection.FastForEach(item => Console.Write("{0}{1}", item.ToString(), delimiter));
}
Alors maintenant l'intégralité du code source, y compris un exemple d'utilisation de FastForEach est:
using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleWritelineTest
{
public static class Extensions
{
public static void WriteToConsole<T>(this IList<T> collection)
{
WriteToConsole<T>(collection, "\t");
}
public static void WriteToConsole<T>(this IList<T> collection, string delimiter)
{
collection.FastForEach(item => Console.Write("{0}{1}", item.ToString(), delimiter));
}
public static void FastForEach<T>(this IList<T> collection, Action<T> actionToPerform)
{
int count = collection.Count();
for (int i = 0; i < count; ++i)
{
actionToPerform(collection[i]);
}
Console.WriteLine();
}
}
internal class Foo
{
override public string ToString()
{
return "FooClass";
}
}
internal class Program
{
static void Main(string[] args)
{
var myIntList = new List<int> {1, 2, 3, 4, 5};
var myDoubleList = new List<double> {1.1, 2.2, 3.3, 4.4};
var myDoubleArray = new Double[] {12.3, 12.4, 12.5, 12.6};
var myFooList = new List<Foo> {new Foo(), new Foo(), new Foo()};
// Using the standard delimiter /t
myIntList.WriteToConsole();
myDoubleList.WriteToConsole();
myDoubleArray.WriteToConsole();
myFooList.WriteToConsole();
// Using our own delimiter ~
myIntList.WriteToConsole("~");
// What if we want to write them to separate lines?
myIntList.FastForEach(item => Console.WriteLine(item.ToString()));
Console.Read();
}
}
}
Vous battre d'environ 30 secondes. :) –