Usando LINQ para concatenar cadenas

¿Cuál es la forma más eficiente de escribir la vieja escuela?

StringBuilder sb = new StringBuilder();
if (strings.Count > 0)
{
    foreach (string s in strings)
    {
        sb.Append(s + ", ");
    }
    sb.Remove(sb.Length - 2, 2);
}
return sb.ToString();

... en LINQ?

Esta respuesta muestra el uso de LINQ ( Aggregate) según lo solicitado en la pregunta y no está destinado para el uso diario. Debido a que esto no usa un StringBuilder, tendrá un rendimiento horrible para secuencias muy largas. Para el uso regular del código String.Joincomo se muestra en la otra respuesta

Use consultas agregadas como esta:

string[] words = { "one", "two", "three" };
var res = words.Aggregate(
   "", // start with empty string to handle empty list case.
   (current, next) => current + ", " + next);
Console.WriteLine(res);

Esto produce:

, uno dos tres

Un agregado es una función que toma una colección de valores y devuelve un valor escalar. Los ejemplos de T-SQL incluyen min, max y sum. Tanto VB como C # tienen soporte para agregados. Tanto VB como C # admiten agregados como métodos de extensión. Usando la notación de puntos, uno simplemente llama a un método en un objeto IEnumerable .

Recuerde que las consultas agregadas se ejecutan de inmediato.

Más información - MSDN: consultas agregadas

Si realmente desea Aggregateutilizar la variante de uso StringBuilderpropuesta en el comentario de CodeMonkeyKing, que sería aproximadamente el mismo código que el habitual, String.Joinincluido un buen rendimiento para una gran cantidad de objetos:

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();

return string.Join(", ", strings.ToArray());

En .Net 4, hay una nueva sobrecarga para string.Joinque acepte IEnumerable<string>. El código se vería así:

return string.Join(", ", strings);

¿Por qué usar Linq?

string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));

Eso funciona perfectamente y acepta cualquiera IEnumerable<string>hasta donde recuerdo. No necesita Aggregatenada aquí, que es mucho más lento.

¿Has mirado el método de extensión Agregado?

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);

Ejemplo real de mi código:

return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);

Una consulta es un objeto que tiene una propiedad Name que es una cadena, y quiero los nombres de todas las consultas en la lista seleccionada, separadas por comas.

Aquí está el enfoque combinado Join / Linq que decidí después de mirar las otras respuestas y los problemas abordados en una pregunta similar (a saber, que Aggregate and Concatenate fallan con 0 elementos).

string Result = String.Join(",", split.Select(s => s.Name));

o (si sno es una cadena)

string Result = String.Join(",", split.Select(s => s.ToString()));

• Simple
• Fácil de leer y entender
• funciona para elementos genéricos
• permite usar objetos o propiedades de objetos
• maneja el caso de elementos de longitud 0
• podría usarse con filtrado Linq adicional
• funciona bien (al menos en mi experiencia)
• no requiere la creación (manual) de un objeto adicional (por ejemplo StringBuilder) para implementar

Y, por supuesto, Join se encarga de la molesta coma final que a veces se cuela en otros enfoques ( for, foreach), por lo que estaba buscando una solución de Linq en primer lugar.

Puedes usar StringBuilderen Aggregate:

  List<string> strings = new List<string>() { "one", "two", "three" };

  StringBuilder sb = strings
    .Select(s => s)
    .Aggregate(new StringBuilder(), (ag, n) => ag.Append(n).Append(", "));

  if (sb.Length > 0) { sb.Remove(sb.Length - 2, 2); }

  Console.WriteLine(sb.ToString());

(El Selectestá ahí solo para mostrar que puedes hacer más cosas de LINQ).

Datos de rendimiento rápido para el caso StringBuilder vs Select & Aggregate sobre más de 3000 elementos:

Prueba unitaria - Duración (segundos)
LINQ_StringBuilder - 0.0036644
LINQ_Select.Aggregate - 1.8012535

    [TestMethod()]
    public void LINQ_StringBuilder()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000;i++ )
        {
            ints.Add(i);
        }
        StringBuilder idString = new StringBuilder();
        foreach (int id in ints)
        {
            idString.Append(id + ", ");
        }
    }
    [TestMethod()]
    public void LINQ_SELECT()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000; i++)
        {
            ints.Add(i);
        }
        string ids = ints.Select(query => query.ToString())
                         .Aggregate((a, b) => a + ", " + b);
    }

Siempre uso el método de extensión:

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString()).ToArray();
    return string.Join(seperator, ar);
}

Con la 'manera súper genial de LINQ ', podría estar hablando de la forma en que LINQ hace que la programación funcional sea mucho más aceptable con el uso de métodos de extensión. Quiero decir, el azúcar sintáctico que permite encadenar funciones de una manera visualmente lineal (una después de la otra) en lugar de anidar (una dentro de la otra). Por ejemplo:

int totalEven = Enumerable.Sum(Enumerable.Where(myInts, i => i % 2 == 0));

se puede escribir así:

int totalEven = myInts.Where(i => i % 2 == 0).Sum();

Puede ver cómo el segundo ejemplo es más fácil de leer. También puede ver cómo se pueden agregar más funciones con menos problemas de sangría o los pares de cierre de Lispy que aparecen al final de la expresión.

Muchas de las otras respuestas indican que este String.Joines el camino a seguir porque es el más rápido o el más simple de leer. Pero si toma mi interpretación de la ' forma LINQ súper genial ', entonces la respuesta es usar, String.Joinpero envuélvala en un método de extensión de estilo LINQ que le permitirá encadenar sus funciones de una manera visualmente agradable. Entonces, si quieres escribir sa.Concatenate(", "), solo necesitas crear algo como esto:

public static class EnumerableStringExtensions
{
   public static string Concatenate(this IEnumerable<string> strings, string separator)
   {
      return String.Join(separator, strings);
   }
}

Esto proporcionará un código que es tan eficaz como la llamada directa (al menos en términos de complejidad del algoritmo) y en algunos casos puede hacer que el código sea más legible (según el contexto), especialmente si otro código en el bloque está usando el estilo de función encadenada .

Hay varias respuestas alternativas en esta pregunta anterior , que ciertamente apuntaba a una matriz entera como fuente, pero recibió respuestas generalizadas.

Aquí está usando LINQ puro como una sola expresión:

static string StringJoin(string sep, IEnumerable<string> strings) {
  return strings
    .Skip(1)
    .Aggregate(
       new StringBuilder().Append(strings.FirstOrDefault() ?? ""), 
       (sb, x) => sb.Append(sep).Append(x));
}

¡Y es bastante rápido!

Voy a hacer un poco de trampa y arrojar una nueva respuesta a esto que parece resumir lo mejor de todo aquí en lugar de incluirlo en un comentario.

Entonces puedes una línea de esto:

List<string> strings = new List<string>() { "one", "two", "three" };

string concat = strings        
    .Aggregate(new StringBuilder("\a"), 
                    (current, next) => current.Append(", ").Append(next))
    .ToString()
    .Replace("\a, ",string.Empty); 

Editar: primero querrá verificar si hay un enumerable vacío o agregar un .Replace("\a",string.Empty);al final de la expresión. Supongo que podría haber estado tratando de ser demasiado inteligente.

La respuesta de @ a.friend podría ser un poco más eficaz, no estoy seguro de lo que Reemplazar hace bajo el capó en comparación con Eliminar. La única otra advertencia es que si por alguna razón quisieras concatenar cadenas que terminaran en \ a, perderías tus separadores ... Me parece poco probable. Si ese es el caso, tiene otros personajes elegantes para elegir.

Puede combinar LINQ y con string.join()bastante eficacia. Aquí estoy eliminando un elemento de una cadena. También hay mejores formas de hacerlo, pero aquí está:

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );

Muchas opciones aquí. Puede usar LINQ y un StringBuilder para obtener el rendimiento de la siguiente manera:

StringBuilder builder = new StringBuilder();
List<string> MyList = new List<string>() {"one","two","three"};

MyList.ForEach(w => builder.Append(builder.Length > 0 ? ", " + w : w));
return builder.ToString();

Hice lo siguiente rápido y sucio cuando analicé un archivo de registro IIS usando linq, funcionó a 1 millón de líneas bastante bien (15 segundos), aunque obtuvo un error de falta de memoria al intentar 2 millones de líneas.

    static void Main(string[] args)
    {

        Debug.WriteLine(DateTime.Now.ToString() + " entering main");

        // USED THIS DOS COMMAND TO GET ALL THE DAILY FILES INTO A SINGLE FILE: copy *.log target.log 
        string[] lines = File.ReadAllLines(@"C:\Log File Analysis\12-8 E5.log");

        Debug.WriteLine(lines.Count().ToString());

        string[] a = lines.Where(x => !x.StartsWith("#Software:") &&
                                      !x.StartsWith("#Version:") &&
                                      !x.StartsWith("#Date:") &&
                                      !x.StartsWith("#Fields:") &&
                                      !x.Contains("_vti_") &&
                                      !x.Contains("/c$") &&
                                      !x.Contains("/favicon.ico") &&
                                      !x.Contains("/ - 80")
                                 ).ToArray();

        Debug.WriteLine(a.Count().ToString());

        string[] b = a
                    .Select(l => l.Split(' '))
                    .Select(words => string.Join(",", words))
                    .ToArray()
                    ;

        System.IO.File.WriteAllLines(@"C:\Log File Analysis\12-8 E5.csv", b);

        Debug.WriteLine(DateTime.Now.ToString() + " leaving main");

    }

La verdadera razón por la que usé linq fue por un Distinct () que necesitaba anteriormente:

string[] b = a
    .Select(l => l.Split(' '))
    .Where(l => l.Length > 11)
    .Select(words => string.Format("{0},{1}",
        words[6].ToUpper(), // virtual dir / service
        words[10]) // client ip
    ).Distinct().ToArray()
    ;

Hace un blog escribí sobre esto hace un tiempo, lo que hice parece ser exactamente lo que estás buscando:

http://ondevelopment.blogspot.com/2009/02/string-concatenation-made-easy.html

En la publicación del blog describa cómo implementar métodos de extensión que funcionen en IEnumerable y se denominen Concatenate, esto le permitirá escribir cosas como:

var sequence = new string[] { "foo", "bar" };
string result = sequence.Concatenate();

O cosas más elaboradas como:

var methodNames = typeof(IFoo).GetMethods().Select(x => x.Name);
string result = methodNames.Concatenate(", ");