string.join en una lista de <int> u otro tipo de

Question

Quiero convertir una matriz o lista de enteros en una cadena separada por comas, como esto:

string myFunction(List<int> a) { 
    return string.Join(",", a); 
} 

Pero string.join sólo toma List<string> como el segundo parámetro . ¿Cuál es la mejor manera de hacer esto?

Answer 1

La mejor manera es actualizar a .NET 4.0, donde hay una sobrecarga que hace lo que quiere:

• String.Join<T>(String, IEnumerable<T>)

Si no se puede actualizar, se puede lograr el mismo efecto usando Select y ToArray.

return string.Join(",", a.Select(x => x.ToString()).ToArray()); 

Answer 2

Esta respuesta es para ti si aún no quieres aventurarte en las profundidades de .NET 4.0.

String.Join() concatena todos los elementos de una matriz de cadenas, utilizando el separador especificado entre cada elemento.

La sintaxis es

public static string Join(
    string separator, 
    params string[] value 
) 

En lugar de pasar su lista de enteros al método join, sugiero la creación de una matriz de cadenas en primer lugar.

Aquí es lo que propongo:

static string myFunction(List<int> a) { 
    int[] intArray = a.ToArray(); 
    string[] stringArray = new string[intArray.Length]; 

    for (int i = 0; i < intArray.Length; i++) 
    { 
     stringArray[i] = intArray[i].ToString(); 
    } 

    return string.Join(",", stringArray); 
} 

Answer 3

tenía un método de extensión similar que he modificado a este

public static class MyExtensions 
{ 
    public static string Join(this List<int> a, string splitChar) 
    { 
     return string.Join(splitChar, a.Select(n => n.ToString()).ToArray()); 
    } 
} 

y utilizar de esta manera

var test = new List<int>() { 1, 2, 3, 4, 5 }; 
string s = test.Join(","); 

.NET 3.5

Answer 4

. NET 2.0:

static string IntListToDelimitedString(List<int> intList, char Delimiter) 
{ 
    StringBuilder builder = new StringBuilder(); 

    for (int i = 0; i < intList.Count; i++) 
    { 
     builder.Append(intList[i].ToString()); 

     if (i != intList.Count - 1) 
      builder.Append(Delimiter); 
    } 

    return builder.ToString(); 
} 

Answer 5

Un escalable y segura implementación de una cadena numerable genérica se unen para .NET 3.5. El uso de iteradores es para que el valor de la cadena de unión no quede bloqueado al final de la cadena. Funciona correctamente con 0, 1 y más elementos:

public static class StringExtensions 
{ 
    public static string Join<T>(this string joinWith, IEnumerable<T> list) 
    { 
     if (list == null) 
      throw new ArgumentNullException("list"); 
     if (joinWith == null) 
      throw new ArgumentNullException("joinWith"); 

     var stringBuilder = new StringBuilder(); 
     var enumerator = list.GetEnumerator(); 

     if (!enumerator.MoveNext()) 
      return string.Empty; 

     while (true) 
     { 
      stringBuilder.Append(enumerator.Current); 
      if (!enumerator.MoveNext()) 
       break; 

      stringBuilder.Append(joinWith); 
     } 

     return stringBuilder.ToString(); 
    } 
} 

Uso:

var arrayOfInts = new[] { 1, 2, 3, 4 }; 
Console.WriteLine(",".Join(arrayOfInts)); 

var listOfInts = new List<int> { 1, 2, 3, 4 }; 
Console.WriteLine(",".Join(listOfInts)); 

disfrutar!

Answer 6

El uso de .NET 4,0

public partial class _Default : System.Web.UI.Page 
{ 
    protected void Page_Load(object sender, EventArgs e) 
    { 
     string s = myFunction(PopulateTestList()); 
     this.TextBox1.Text = s; 
    } 

    protected List<int> PopulateTestList() 
    { 
     List<int> thisList = new List<int>(); 
     thisList.Add(22); 
     thisList.Add(33); 
     thisList.Add(44); 

     return thisList; 
    } 

    protected string myFunction(List<int> a) 
    { 
     return string.Join(",", a); 
    } 
} 

Answer 7

En .NET lista de la clase tiene un método .ToArray().Algo como esto podría funcionar:

string myFunction(List<int> a) 
{ 
    return string.Join(",", a.ToArray()); 
} 

Ref: List<T> Methods (MSDN)