Usando LINQ para concatenar seqüências de caracteres

Qual é a maneira mais eficiente de escrever a velha escola:

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

... em LINQ?

Esta resposta mostra o uso de LINQ ( Aggregate) conforme solicitado na pergunta e não se destina ao uso diário. Como isso não usa a, StringBuilderele terá um desempenho horrível por sequências muito longas. Para código regular, use String.Joincomo mostrado na outra resposta

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

Isso gera:

, um dois três

Um agregado é uma função que pega uma coleção de valores e retorna um valor escalar. Exemplos do T-SQL incluem min, max e sum. O VB e o C # têm suporte para agregados. O VB e o C # suportam agregados como métodos de extensão. Usando a notação de ponto, simplesmente chama-se um método em um objeto IEnumerable .

Lembre-se de que as consultas agregadas são executadas imediatamente.

Mais informações - MSDN: consultas agregadas

Se você realmente deseja Aggregateusar a variante de uso StringBuilderproposta no comentário do CodeMonkeyKing, que seria aproximadamente o mesmo código que o normal, String.Joinincluindo bom desempenho para um grande número de objetos:

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

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

Na Net 4, há uma nova sobrecarga para string.Joinque aceita IEnumerable<string>. O código ficaria assim:

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

Por que usar o Linq?

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

Isso funciona perfeitamente e aceita IEnumerable<string>tanto quanto me lembro. Não precisa de Aggregatenada aqui que seja muito mais lento.

Você já olhou para o método de extensão Agregado?

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

Exemplo real do meu código:

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

Uma consulta é um objeto que possui uma propriedade Name, que é uma string, e eu quero os nomes de todas as consultas na lista selecionada, separados por vírgulas.

Aqui está a abordagem combinada do Join / Linq em que eu decidi depois de examinar as outras respostas e os problemas abordados em uma pergunta semelhante (a saber, que Agregado e Concatenado falham com 0 elementos).

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

ou (se snão for uma string)

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

• Simples
• Fácil de ler e compreender
• funciona para elementos genéricos
• permite usar objetos ou propriedades de objetos
• lida com o caso de elementos de comprimento 0
• poderia ser usado com filtragem Linq adicional
• executa bem (pelo menos na minha experiência)
• não requer a criação (manual) de um objeto adicional (por exemplo StringBuilder) para implementar

E é claro que o Join cuida da vírgula final traquina que às vezes se infiltra em outras abordagens ( for, foreach), e é por isso que eu estava procurando uma solução Linq em primeiro lugar.

Você pode usar StringBuilderem 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());

(O Selectestá lá apenas para mostrar que você pode fazer mais coisas sobre o LINQ.)

dados de desempenho rápido para o caso StringBuilder vs Select & Aggregate, com mais de 3000 elementos:

Teste de unidade - Duração (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);
    }

Eu sempre uso o método de extensão:

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

Por 'maneira super bacana do LINQ ', você pode estar falando sobre o modo como o LINQ torna a programação funcional muito mais agradável com o uso de métodos de extensão. Quero dizer, o açúcar sintático que permite que as funções sejam encadeadas de maneira visualmente linear (uma após a outra) em vez de aninhar (uma dentro da outra). Por exemplo:

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

pode ser escrito assim:

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

Você pode ver como o segundo exemplo é mais fácil de ler. Você também pode ver como mais funções podem ser adicionadas com menos problemas de recuo ou os pontos de fechamento do Lispy aparecendo no final da expressão.

Muitas das outras respostas afirmam que esse String.Joiné o caminho a seguir, porque é a mais rápida ou mais simples de ler. Mas se você entender minha interpretação de ' maneira LINQ super bacana ', a resposta é usá-la, String.Joinmas envolva-a em um método de extensão no estilo LINQ que permitirá que você encadeie suas funções de uma maneira visualmente agradável. Então, se você quiser escrever, sa.Concatenate(", ")basta criar algo como isto:

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

Isso fornecerá um código com desempenho tão alto quanto a chamada direta (pelo menos em termos de complexidade do algoritmo) e, em alguns casos, poderá tornar o código mais legível (dependendo do contexto), especialmente se outro código do bloco estiver usando o estilo de função em cadeia .

Existem várias respostas alternativas nesta pergunta anterior - que reconhecidamente estava mirando uma matriz inteira como a fonte, mas recebeu respostas generalizadas.

Aqui está usando LINQ puro como uma única expressão:

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

E é muito rápido!

Vou trapacear um pouco e dar uma nova resposta a isso que parece resumir o melhor de tudo aqui em vez de colocá-lo dentro de um comentário.

Então você pode uma linha isso:

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: você deseja verificar primeiro um enumerável vazio ou adicionar um.Replace("\a",string.Empty); no final da expressão. Acho que eu poderia estar tentando ficar um pouco inteligente demais.

A resposta de @ a.friend pode ser um pouco mais eficiente, não sei o que o Replace faz sob o capô em comparação com o Remove. A única outra ressalva, se por algum motivo você quisesse concatenar strings que terminassem em \ a's, você perderia seus separadores ... Acho isso improvável. Se for esse o caso, você tem outros personagens sofisticados para escolher.

Você pode combinar o LINQ e com string.join()bastante eficiência. Aqui estou removendo um item de uma string. Também existem maneiras melhores de fazer isso, mas aqui está:

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

Muitas opções aqui. Você pode usar o LINQ e um StringBuilder para obter o desempenho da seguinte forma:

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

Fiz o seguinte rápido e sujo ao analisar um arquivo de log do IIS usando linq, funcionou muito bem a 1 milhão de linhas (15 segundos), embora tenha ocorrido um erro de falta de memória ao tentar 2 milhões de linhas.

    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");

    }

A verdadeira razão pela qual usei o linq foi para um Distinct () que eu precisava 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()
    ;

Eu escrevi sobre isso há um tempo atrás, o que eu fiz para ser exatamente o que você está procurando:

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

Na postagem do blog, descreva como implementar métodos de extensão que funcionam no IEnumerable e são nomeados Concatenar, permitindo escrever coisas como:

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

Ou coisas mais elaboradas, como:

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