C'è un modo per prendere una lista e convertirla in una stringa separata da virgole?Conversione di una lista <int> in una stringa separata da virgola
So che posso semplicemente eseguire il ciclo e costruirlo, ma in qualche modo penso che alcuni di voi ragazzi siano un modo più interessante di farlo?
Voglio davvero imparare questi tipi di "trucchi", quindi per favore spiega o collega i documenti al metodo che usi.
List<int> list = ...;
string.Join(",", list.Select(n => n.ToString()).ToArray())
List<int> list = new List<int> { 1, 2, 3 };
Console.WriteLine(String.Join(",", list.Select(i => i.ToString()).ToArray()));
Ottimo se non è possibile utilizzare .NET 4 –
mio "intelligente" entry:
List<int> list = new List<int> { 1, 2, 3 };
StringBuilder sb = new StringBuilder();
var y = list.Skip(1).Aggregate(sb.Append(x.ToString()),
(sb1, x) => sb1.AppendFormat(",{0}",x));
// A lot of mess to remove initial comma
Console.WriteLine(y.ToString().Substring(1,y.Length - 1));
Solo che non hanno capito come aggiungere condizionalmente la virgola.
Si prega di non scrivere 'Seleziona' con effetti collaterali nel lambda. In questo caso non stai nemmeno usando 'y', quindi il tuo' Select' è essenzialmente solo un 'foreach' - quindi scrivilo come tale. –
Non stavo suggerendo questo come una buona soluzione. OP voleva qualcosa di più interessante di foreach. – Larsenal
Sì, ma abusare di 'Select' come' foreach' va oltre "interessante" e in, beh, "abuso". Un approccio più interessante sarebbe usare 'Enumerable.Aggregate' con' StringBuilder' come valore di seed - provalo. –
Per freddezza in più vorrei fare questo un metodo di estensione sul IEnumerable < T> in modo che funziona su qualsiasi IEnumerable:
public static class IEnumerableExtensions {
public static string BuildString<T>(this IEnumerable<T> self, string delim) {
return string.Join(",", self)
}
}
usarlo come segue:
List<int> list = new List<int> { 1, 2, 3 };
Console.WriteLine(list.BuildString(", "));
Due possibili ottimizzazioni: 1) Aggiungere il delimitatore dopo ogni elemento, quindi rimuovere quello aggiuntivo dopo la fine del ciclo. 2) Specificare una capacità per lo StringBuilder. –
Se si estrae Reflector, risulta che Join somma le lunghezze per calcolare preventivamente la dimensione del buffer e inoltre "avvia la pompa" aggiungendo la prima stringa all'esterno del ciclo e quindi, all'interno del ciclo, aggiungendo incondizionatamente il delimitatore prima la stringa successiva. Combinato con alcuni trucchi non sicuri/interni, dovrebbe essere molto veloce. –
@Steven: seguito il tuo consiglio. – cdiggins
Per circa un gazillion soluzioni a una versione leggermente più complicata di questo problema - molte delle quali sono lente, buggy, o nemmeno compilate - vedere i commenti al mio articolo su questo argomento:
http://blogs.msdn.com/ericlippert/archive/2009/04/15/comma-quibbling.aspx
e il commento StackOverflow:
Grazie per il link. Questo problema di concatenazione delle stringhe si è rivelato più complesso e più educativo di quanto mi aspettassi! –
Sembra reasonablly veloce.
IList<int> listItem = Enumerable.Range(0, 100000).ToList();
var result = listItem.Aggregate<int, StringBuilder, string>(new StringBuilder(), (strBuild, intVal) => { strBuild.Append(intVal); strBuild.Append(","); return strBuild; }, (strBuild) => strBuild.ToString(0, strBuild.Length - 1));
soluzione più semplice è
List<int> list = new List<int>() {1,2,3};
string.Join<int>(",", list)
ho usato solo ora nel mio codice, Funtastic lavorando.
Grazie! questo è un bellissimo approccio –
Intelligente ma lento e gonfio, poiché assegna una stringa per elemento. Usare un StringBuilder sarebbe molto più efficiente. –
Da quello che ho visto online (ricerca rapida) String.Join è più veloce dell'utilizzo di StringBuilder. –
http://stackoverflow.com/questions/585860/string-join-vs-stringbuilder-which-is-faster, non sei corretto Steven –