c# - with - Crear una lista separada por comas desde IList<string> o IEnumerable<string>




string join example c# (14)

¿Cuál es la forma más sencilla de crear una lista de valores de cadena separados por comas a partir de una IList<string> o IEnumerable<string> IList<string> ?

String.Join(...) opera en una string[] por lo que puede ser complicado trabajar cuando tipos como IList<string> o IEnumerable<string> no se pueden convertir fácilmente en una matriz de cadenas.


Acabo de resolver este problema antes de pasar a través de este artículo. Mi solución es algo como a continuación:

   private static string GetSeparator<T>(IList<T> list, T item)
   {
       return (list.IndexOf(item) == list.Count - 1) ? "" : ", ";
   }

Llamado como

List<thing> myThings;
string tidyString;

foreach (var thing in myThings)
{
     tidyString += string.format("Thing {0} is a {1}", thing.id, thing.name) + GetSeparator(myThings, thing);
}

También podría haber expresado con tanta facilidad como tal y habría sido más eficiente:

string.Join(“,”, myThings.Select(t => string.format(“Thing {0} is a {1}”, t.id, t.name)); 

Algo un poco feo, pero funciona:

string divisionsCSV = String.Join(",", ((List<IDivisionView>)divisions).ConvertAll<string>(d => d.DivisionID.ToString("b")).ToArray());

Le da un CSV de una Lista después de que le haya dado el convertidor (en este caso d => d.DivisionID.ToString ("b")).

Hacky pero funciona, ¿podría convertirse en un método de extensión tal vez?


Así es como lo hice, usando la forma en que lo he hecho en otros idiomas:

private string ToStringList<T>(IEnumerable<T> list, string delimiter)
{
  var sb = new StringBuilder();
  string separator = String.Empty;
  foreach (T value in list)
  {
    sb.Append(separator).Append(value);
    separator = delimiter;
  }
  return sb.ToString();
}

Comencé esta discusión mientras buscaba un buen método de C # para unir cadenas, como se hace con el método MySQL CONCAT_WS() . Este método difiere del método string.Join() en que no agrega el signo separador si las cadenas son NULL o están vacías.

CONCAT_WS (',', tbl.Lastname, tbl.Firstname)

solo devolverá el apellido si el primer nombre está vacío, mientras que

string.Join (",", strLastname, strFirstname)

devolverá strLastname + ", " en el mismo caso.

Queriendo el primer comportamiento, escribí los siguientes métodos:

    public static string JoinStringsIfNotNullOrEmpty(string strSeparator, string strA, string strB, string strC = "")
    {
        return JoinStringsIfNotNullOrEmpty(strSeparator, new[] {strA, strB, strC});
    }

    public static string JoinStringsIfNotNullOrEmpty(string strSeparator, string[] arrayStrings)
    {
        if (strSeparator == null)
            strSeparator = "";
        if (arrayStrings == null)
            return "";
        string strRetVal = arrayStrings.Where(str => !string.IsNullOrEmpty(str)).Aggregate("", (current, str) => current + (str + strSeparator));
        int trimEndStartIndex = strRetVal.Length - strSeparator.Length;
        if (trimEndStartIndex>0)
            strRetVal = strRetVal.Remove(trimEndStartIndex);
        return strRetVal;
    }

Creo que la forma más sencilla de crear una lista de valores de cadena separados por comas es simplemente:

string.Join<string>(",", stringEnumerable);

Aquí hay un ejemplo completo:

IEnumerable<string> stringEnumerable= new List<string>();
stringList.Add("Comma");
stringList.Add("Separated");

string.Join<string>(",", stringEnumerable);

No es necesario realizar una función auxiliar, esto está integrado en .NET 4.0 y superior.


Desde que llegué aquí mientras buscaba unirme a una propiedad específica de una lista de objetos (y no a ToString () de ella), aquí hay una adición a la respuesta aceptada:

var commaDelimited = string.Join(",", students.Where(i => i.Category == studentCategory)
                                 .Select(i => i.FirstName));

Esperemos que esta sea la forma más sencilla.

 string Commaseplist;
 string[] itemList = { "Test1", "Test2", "Test3" };
 Commaseplist = string.join(",",itemList);
 Console.WriteLine(Commaseplist); //Outputs Test1,Test2,Test3

La forma más fácil que puedo ver para hacer esto es usar el método de Aggregate LINQ:

string commaSeparatedList = input.Aggregate((a, x) => a + ", " + x)

Mi respuesta es como la de la solución Agregada anterior, pero debería tener menos volumen de pila de llamadas ya que no hay llamadas delegadas explícitas:

public static string ToCommaDelimitedString<T>(this IEnumerable<T> items)
{
    StringBuilder sb = new StringBuilder();
    foreach (var item in items)
    {
        sb.Append(item.ToString());
        sb.Append(',');
    }
    if (sb.Length >= 1) sb.Length--;
    return sb.ToString();
}

Por supuesto, uno puede extender la firma para que sea independiente del delimitador. Realmente no soy un fanático de la llamada sb.Remove () y me gustaría refactorizarlo para que sea un bucle directo en un IEnumerable y usar MoveNext () para determinar si escribir o no una coma. Voy a juguetear y publicar esa solución si la encuentro.

Esto es lo que quería inicialmente:

public static string ToDelimitedString<T>(this IEnumerable<T> source, string delimiter, Func<T, string> converter)
{
    StringBuilder sb = new StringBuilder();
    var en = source.GetEnumerator();
    bool notdone = en.MoveNext();
    while (notdone)
    {
        sb.Append(converter(en.Current));
        notdone = en.MoveNext();
        if (notdone) sb.Append(delimiter);
    }
    return sb.ToString();
}

No se requiere almacenamiento temporal de matriz o lista, ni StringBuilder Remove() o Length-- requiere hackeo.

En mi biblioteca de marcos realicé algunas variaciones en esta firma de método, cada combinación de incluir el delimiter y los parámetros del converter con el uso de "," y x.ToString() como valores predeterminados, respectivamente.


Necesidad específica cuando deberíamos rodear por ', por ej:

        string[] arr = { "jj", "laa", "123" };
        List<string> myList = arr.ToList();

        // 'jj', 'laa', '123'
        Console.WriteLine(string.Join(", ",
            myList.ConvertAll(m =>
                string.Format("'{0}'", m)).ToArray()));

Puede usar .ToArray() en Lists y IEnumerables , y luego usar String.Join() como desee.


Se pueden convertir fácilmente en una matriz utilizando las extensiones Linq en .NET 3.5.

   var stringArray = stringList.ToArray();

Tenemos una función de utilidad, algo como esto:

public static string Join<T>( string delimiter, 
    IEnumerable<T> collection, Func<T, string> convert )
{
    return string.Join( delimiter, 
        collection.Select( convert ).ToArray() );
}

Que se puede usar para unir muchas colecciones fácilmente:

int[] ids = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233};

string csv = StringUtility.Join(",", ids, i => i.ToString() );

Tenga en cuenta que tenemos el parámetro de colección antes de la lambda porque intellisense luego recoge el tipo de colección.

Si ya tiene una enumeración de cadenas, todo lo que debe hacer es ToArray:

string csv = string.Join( ",", myStrings.ToArray() );

puede convertir el IList a una matriz utilizando ToArray y luego ejecutar un comando string.join en la matriz.

Dim strs As New List(Of String)
Dim arr As Array
arr = strs.ToArray




string