Console.WriteLine et Liste générique
https://stackoverflow.com/questions/52927
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Il m'arrive fréquemment de l'écriture de code comme ceci:
List<int> list = new List<int> { 1, 3, 5 };
foreach (int i in list) {
Console.Write("{0}\t", i.ToString()); }
Console.WriteLine();
Mieux serait quelque chose comme ceci:
List<int> list = new List<int> { 1, 3, 5 };
Console.WriteLine("{0}\t", list);
Je pense qu'il y est une certaine façon intelligente de le faire, mais je ne la vois pas.Quelqu'un at-il une meilleure solution que le premier bloc?
La solution
Faire cela:
list.ForEach(i => Console.Write("{0}\t", i));
EDIT:Pour les autres qui ont répondu - il les veut tous sur la même ligne, avec des onglets entre eux.:)
Autres conseils
Une approche différente, juste pour le plaisir:
Console.WriteLine(string.Join("\t", list));
Si il y a un morceau de code que vous répétez tout le temps en fonction de Ne pas se Répéter, vous devriez mettre dans votre propre bibliothèque et l'appeler.Avec cela à l'esprit, il y a 2 aspects à obtenir la bonne réponse ici.La première est la clarté et la concision dans le code qui appelle la fonction de la bibliothèque.La deuxième est l'incidence sur les performances de foreach.
D'abord, nous allons réfléchir sur la clarté et la concision dans le code appelant.
Vous pouvez faire foreach dans un certain nombre de façons:
- pour la boucle
- boucle foreach
- Collection.ForEach
De toutes les façons de faire un foreach Liste.ForEach avec un lamba est la plus claire et la plus courte.
list.ForEach(i => Console.Write("{0}\t", i));
Donc, à ce stade, il peut ressembler à la Liste.ForEach est le chemin à parcourir.Cependant ce qui est de la performance de ce?C'est vrai que dans ce cas le temps d'écrire dans la console régissent la performance du code.Quand on sait quelque chose à propos de la performance d'une langue particulière, la fonction devrait certainement au moins en tenir compte.
Selon Duston Campbell mesures de performance de foreach le moyen le plus rapide de l'itération de la liste sous code est optimisé à l'aide d'une boucle for sans appel de Liste.Le comte.
La boucle for est une détaillé de construire.Il est également considéré comme un très itératif façon de faire les choses qui ne correspond pas à la tendance actuelle vers la fonctionnelle d'expressions idiomatiques.
Ainsi pouvons-nous obtenir de la concision, la clarté et la performance?Nous pouvons en utilisant une méthode d'extension.Dans un monde idéal, nous aurions pu créer une méthode d'extension de la Console qui prend une liste et l'écrit avec un délimiteur.Nous ne pouvons pas faire cela parce que la Console est une classe statique et les méthodes d'extension ne fonctionne que sur des instances de classes.Au lieu de cela, nous avons besoin de mettre la méthode d'extension sur la liste elle-même (comme par David B est une suggestion):
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ées dans de nombreux endroits, de sorte que nous devrions mener à bien les améliorations suivantes:
- Au lieu d'utiliser foreach nous devrions utiliser le moyen le plus rapide de l'itération de la collection qui est une boucle avec un cache comte.
- Actuellement, seule la Liste peut être passé comme argument.Comme une fonction de la bibliothèque on peut généraliser à travers une petite quantité d'efforts.
- L'aide de la Liste qui nous limite à des Listes, à l'Aide de IList ce code permet de travailler avec des Tableaux trop.
- Depuis l'extension de la méthode sur un IList nous avons besoin de changer le nom pour le rendre plus clair ce que nous écrivant à:
Voici comment le code de la fonction ressemblerait à:
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();
}
On peut améliorer encore plus loin en permettant au client de passer dans le séparateur.On pourrait alors fournir une deuxième fonction qui écrit dans la console avec la norme délimiteur 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 et performante pour l'écriture de listes à la console nous en avons un.Ici est l'ensemble du 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 ce devait être la fin de la réponse.Cependant, il est un autre morceau de généralisation qui peut être fait.Il n'est pas clair à partir de fatcat la question de savoir s'il est toujours écrit à la console.Peut-être que quelque chose d'autre à faire dans la boucle foreach.Dans ce cas, Jason Bunting la réponse à donner à cette généralité.Voici sa réponse encore une fois:
list.ForEach(i => Console.Write("{0}\t", i));
C'est à moins de nous faire un plus de raffinement à nos méthodes de vulgarisation 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 du code arbitraire à l'encontre de chaque élément de la collection à l'aide de la manière la plus rapide possible de l'itération de la méthode.
On peut même changer la WriteToConsole fonction à 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, le code source complet, 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();
}
}
}
nouvelle Liste { 1, 3, 5 }.ForEach(Console.WriteLine);
List<int> a = new List<int>() { 1, 2, 3, 4, 5 };
a.ForEach(p => Console.WriteLine(p));
edit:ahhh il me battre pour elle.
list.ForEach(x=>Console.WriteLine(x));
List<int> list = new List<int> { 1, 3, 5 };
list.ForEach(x => Console.WriteLine(x));
Edit:Nom d'une pipe!a pris trop de temps pour ouvrir visual studio pour le tester.
Vous pouvez aussi le faire rejoindre:
var qwe = new List<int> {5, 2, 3, 8};
Console.WriteLine(string.Join("\t", qwe));
public static void WriteLine(this List<int> theList)
{
foreach (int i in list)
{
Console.Write("{0}\t", t.ToString());
}
Console.WriteLine();
}
Puis, plus tard...
list.WriteLine();
