¿Hay alguna manera de tomar una lista y convertirla en una cadena separada por comas?Conversión de una lista <int> en una cadena separada por comas
Sé que puedo hacer un bucle y construirlo, pero de alguna manera creo que algunos de ustedes una forma más genial de hacerlo?
Realmente quiero aprender este tipo de 'trucos', así que por favor explique o vincule a los documentos sobre el método que utiliza.
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()));
Genial si no puede usar .NET 4 –
Mi entrada "inteligente":
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));
simplemente no han descubierto cómo añadir condicionalmente la coma.
No escriba 'Seleccionar' con efectos secundarios en la lambda. En este caso, ni siquiera está usando 'y', por lo que su' Seleccionar' es esencialmente solo 'foreach', así que escríbalo como tal. –
No estaba sugiriendo esto como una buena solución. OP quería algo más interesante que foreach. – Larsenal
Sí, pero abusar de "Seleccionar" como "foreach" pasa por "interesante" y, bueno, por "abuso". Un enfoque más interesante aquí sería usar 'Enumerable.Aggregate' con' StringBuilder' como valor inicial, inténtalo. –
Para serenidad adicional Me gustaría hacer de este un método de extensión en IEnumerable < T> para que funcione en cualquier IEnumerable:
public static class IEnumerableExtensions {
public static string BuildString<T>(this IEnumerable<T> self, string delim) {
return string.Join(",", self)
}
}
utilizarlo como sigue:
List<int> list = new List<int> { 1, 2, 3 };
Console.WriteLine(list.BuildString(", "));
Dos posibles optimizaciones: 1) Agregue el delímetro después de cada elemento independientemente, luego quite el extra después de que termine el ciclo. 2) Especifique una capacidad para StringBuilder. –
Si extrae Reflector, resulta que Join resume las longitudes para precalcular el tamaño del búfer, y también "prepara la bomba" al agregar la primera cadena fuera del bucle, y luego, dentro del bucle, agrega incondicionalmente el delimitador antes la siguiente cuerda. Combinado con algunos trucos inseguros/internos, debería ser muy rápido. –
@Steven: siguió su consejo. – cdiggins
durante aproximadamente un tropecientos soluciones a una versión un poco más complicada de este problema, muchas de las cuales son lentas, con errores o incluso no se compilan, vea los comentarios a mi artículo sobre este tema:
http://blogs.msdn.com/ericlippert/archive/2009/04/15/comma-quibbling.aspx
y el comentario Stackoverflow:
Gracias por el enlace. ¡Este problema de concatenación de cadenas ha resultado ser más complejo y más educativo de lo que esperaba! –
Parece reasonablly rápido.
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));
solución simple es
List<int> list = new List<int>() {1,2,3};
string.Join<int>(",", list)
que lo utilizaron en este momento en mi código, funtastic de trabajo.
¡Gracias! este es un enfoque hermoso –
Inteligente pero lento e hinchado, ya que asigna una cadena por elemento. Usar un StringBuilder sería mucho más eficiente. –
De lo que vi en línea (búsqueda rápida) String.Join es más rápido que usar un StringBuilder. –
http://stackoverflow.com/questions/585860/string-join-vs-stringbuilder-which-is-faster, usted es incorrecto Steven –