string.join na liście <int> lub innego rodzaju

Question

chcę włączyć tablicę lub listę int na ciąg rozdzielany przecinkami, na przykład:

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

Ale string.join zajmuje tylko List<string> jako drugi parametr . Jaki jest najlepszy sposób na zrobienie tego?

Answer 1

Najlepszym sposobem jest uaktualnienie do .NET 4.0, gdzie występuje przeciążenie, że robi to, co chcesz:

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

Jeśli nie można uaktualnić, można osiągnąć to samo efekt przy użyciu Select i ToArray.

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

Answer 2

Ta odpowiedź jest dla Ciebie, jeśli jeszcze nie chcesz zapuszczać się w głąb .NET 4.0.

String.Join() łączy wszystkie elementy tablicy łańcuchów, używając określonego separatora między każdym elementem.

Składnia jest

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

Zamiast przechodzącą listy wskazówki do metody join, proponuję budowania tablicę ciągów pierwszy.

Oto co proponuję:

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

Gdyby podobną metodę rozszerzenia że zmodyfikowany do tego

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

i go używać tak

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

skalowalne i bezpieczny wdrożenie generycznego przeliczalnego ciąg przyłączenia dla .NET 3.5. Użycie iteratorów polega na tym, że wartość ciągu sprzężenia nie utknęła na końcu łańcucha. To działa prawidłowo z 0, 1 i więcej elementów:

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(); 
    } 
} 

Zastosowanie:

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

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

Enjoy!

Answer 6

Korzystanie 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

W .NET klasa lista ma metodę .ToArray().Coś takiego może działać:

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

Ref: List<T> Methods (MSDN)