Menggunakan LINQ untuk menggabungkan string

Apa cara paling efisien untuk menulis old-school:

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

... di LINQ?

Jawaban ini menunjukkan penggunaan LINQ ( Aggregate) seperti yang diminta dalam pertanyaan dan tidak dimaksudkan untuk penggunaan sehari-hari. Karena ini tidak menggunakan StringBuilderitu akan memiliki kinerja yang mengerikan untuk urutan yang sangat lama. Untuk penggunaan kode biasa String.Joinseperti yang ditunjukkan pada jawaban lainnya

Gunakan kueri agregat seperti ini:

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

Output ini:

, satu dua tiga

Agregat adalah fungsi yang mengambil koleksi nilai dan mengembalikan nilai skalar. Contoh dari T-SQL termasuk min, max, dan jumlah. Baik VB dan C # memiliki dukungan untuk agregat. Baik agregat dukungan VB dan C # sebagai metode ekstensi. Menggunakan notasi titik, seseorang cukup memanggil metode pada objek IEnumerable .

Ingat bahwa permintaan agregat dieksekusi segera.

Informasi lebih lanjut - MSDN: Kueri Agregat

Jika Anda benar-benar ingin Aggregatemenggunakan varian gunakan StringBuilderdiusulkan dalam komentar oleh CodeMonkeyKing yang akan menjadi kode yang sama seperti biasa String.Jointermasuk kinerja yang baik untuk sejumlah besar objek:

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

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

Di .Net 4, ada kelebihan baru untuk string.Joinmenerima itu IEnumerable<string>. Kode tersebut kemudian akan terlihat seperti:

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

Mengapa menggunakan Linq?

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

Itu bekerja dengan sempurna dan menerima IEnumerable<string>sejauh yang saya ingat. Tidak perlu Aggregateapa pun di sini yang jauh lebih lambat.

Sudahkah Anda melihat metode ekstensi Agregat?

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

Contoh nyata dari kode saya:

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

Kueri adalah objek yang memiliki properti Nama yang merupakan string, dan saya ingin nama semua kueri pada daftar yang dipilih, dipisahkan dengan koma.

Inilah pendekatan gabungan Bergabung / Linq yang saya selesaikan setelah melihat jawaban lain dan masalah yang dibahas dalam pertanyaan serupa (yaitu bahwa Agregat dan Gabungan gagal dengan 0 elemen).

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

atau (jika sbukan string)

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

• Sederhana
• mudah dibaca dan dimengerti
• bekerja untuk elemen generik
• memungkinkan menggunakan objek atau properti objek
• menangani case elemen 0-length
• dapat digunakan dengan pemfilteran Linq tambahan
• berkinerja baik (setidaknya dalam pengalaman saya)
• tidak memerlukan (manual) pembuatan objek tambahan (misalnya StringBuilder) untuk diimplementasikan

Dan tentu saja Bergabunglah mengurus koma akhir sial yang kadang-kadang menyelinap ke pendekatan lain ( for, foreach), itulah sebabnya saya mencari solusi Linq di tempat pertama.

Anda dapat menggunakan StringBuilderdi 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());

(Ada Selectdi sana hanya untuk menunjukkan Anda dapat melakukan lebih banyak hal LINQ.)

data kinerja cepat untuk kasus StringBuilder vs Select & Aggregate lebih dari 3000 elemen:

Uji unit - Durasi (detik)
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);
    }

Saya selalu menggunakan metode ekstensi:

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

Dengan ' cara LINQ super keren ' Anda mungkin berbicara tentang cara LINQ membuat pemrograman fungsional jauh lebih cocok dengan penggunaan metode ekstensi. Maksud saya, gula sintaksis yang memungkinkan fungsi dirantai dalam cara yang linier secara visual (satu demi satu) alih-alih bersarang (satu di dalam yang lain). Sebagai contoh:

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

dapat ditulis seperti ini:

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

Anda dapat melihat bagaimana contoh kedua lebih mudah dibaca. Anda juga dapat melihat bagaimana lebih banyak fungsi dapat ditambahkan dengan lebih sedikit masalah indentasi atau Lispy parens penutup muncul di akhir ekspresi.

Banyak jawaban lain menyatakan bahwa itu String.Joinadalah cara untuk pergi karena ini adalah yang tercepat atau paling sederhana untuk dibaca. Tetapi jika Anda mengambil interpretasi saya tentang ' cara LINQ yang sangat keren ' maka jawabannya adalah menggunakan String.Jointetapi membungkusnya dengan metode ekstensi gaya LINQ yang akan memungkinkan Anda untuk menghubungkan fungsi Anda dengan cara yang menyenangkan secara visual. Jadi, jika Anda ingin menulis, sa.Concatenate(", ")Anda hanya perlu membuat sesuatu seperti ini:

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

Ini akan memberikan kode yang sama berkinerja dengan panggilan langsung (setidaknya dalam hal kompleksitas algoritma) dan dalam beberapa kasus dapat membuat kode lebih mudah dibaca (tergantung pada konteksnya) terutama jika kode lain dalam blok menggunakan gaya fungsi berantai .

Ada berbagai alternatif jawaban pada pertanyaan sebelumnya - yang memang menargetkan penargetan bilangan bulat sebagai sumber, tetapi menerima jawaban umum.

Ini dia menggunakan LINQ murni sebagai ekspresi tunggal:

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

Dan itu sangat cepat!

Saya akan menipu sedikit dan membuang jawaban baru untuk ini yang tampaknya meringkas yang terbaik dari semua yang ada di sini alih-alih menempelkannya di dalam komentar.

Jadi Anda dapat satu baris ini:

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

Sunting: Anda akan ingin memeriksa enumerable kosong terlebih dahulu atau menambahkan.Replace("\a",string.Empty); ke akhir ekspresi. Kurasa aku mungkin mencoba menjadi sedikit terlalu pintar.

Jawaban dari @ a.friend mungkin sedikit lebih berkinerja, saya tidak yakin apa yang Replace lakukan di bawah tenda dibandingkan dengan Hapus. Satu-satunya peringatan lain jika beberapa alasan Anda ingin menyelesaikan string yang berakhir dengan Anda akan kehilangan pemisah Anda ... Saya menemukan itu tidak mungkin. Jika itu masalahnya Anda memiliki karakter mewah lain untuk dipilih.

Anda dapat menggabungkan LINQ dan string.join()cukup efektif. Di sini saya menghapus item dari string. Ada juga cara yang lebih baik untuk melakukan ini, tetapi ini dia:

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

Banyak pilihan di sini. Anda dapat menggunakan LINQ dan StringBuilder sehingga Anda mendapatkan kinerja juga seperti itu:

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

Saya melakukan hal berikut dengan cepat dan kotor ketika mem-parsing file log IIS menggunakan LINQ, itu berhasil @ 1 juta baris cukup baik (15 detik), meskipun mendapat kesalahan memori ketika mencoba 2 juta baris.

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

    }

Alasan sebenarnya saya menggunakan LINQ adalah untuk Distinct () yang saya butuhkan sebelumnya:

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

Saya membuat blog tentang ini beberapa waktu yang lalu, apa yang saya lakukan sesuai dengan apa yang Anda cari:

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

Dalam posting blog menjelaskan cara menerapkan metode ekstensi yang berfungsi di IEnumerable dan diberi nama Concatenate, ini akan memungkinkan Anda menulis hal-hal seperti:

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

Atau lebih banyak hal rumit seperti:

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