Sử dụng LINQ để nối chuỗi

Cách hiệu quả nhất để viết trường học cũ là gì:

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

... trong LINQ?

Câu trả lời này cho thấy việc sử dụng LINQ ( Aggregate) theo yêu cầu trong câu hỏi và không dành cho sử dụng hàng ngày. Bởi vì điều này không sử dụng, StringBuildernó sẽ có hiệu suất khủng khiếp cho các chuỗi rất dài. Đối với sử dụng mã thông thường String.Joinnhư trong câu trả lời khác

Sử dụng các truy vấn tổng hợp như thế này:

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

Kết quả này:

, một hai ba

Tổng hợp là một hàm lấy một tập hợp các giá trị và trả về giá trị vô hướng. Các ví dụ từ T-SQL bao gồm min, max và sum. Cả VB và C # đều có hỗ trợ cho tổng hợp. Cả VB và C # đều hỗ trợ tổng hợp dưới dạng phương thức mở rộng. Sử dụng ký hiệu dấu chấm, người ta chỉ cần gọi một phương thức trên một đối tượng IEnumerable .

Hãy nhớ rằng các truy vấn tổng hợp được thực hiện ngay lập tức.

Thêm thông tin - MSDN: Truy vấn tổng hợp

Nếu bạn thực sự muốn sử Aggregatedụng biến thể sử dụng sử dụng StringBuilderđược đề xuất trong nhận xét của CodeMonkeyKing , đó sẽ là mã giống như thông thường String.Joinbao gồm hiệu năng tốt cho số lượng lớn đối tượng:

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

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

Trong .Net 4, có một sự quá tải mới cho string.Joinsự chấp nhận đó IEnumerable<string>. Mã này sẽ trông như sau:

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

Tại sao nên sử dụng Linq?

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

Điều đó hoạt động hoàn hảo và chấp nhận bất kỳ IEnumerable<string>như tôi nhớ. Không cần Aggregatebất cứ điều gì ở đây là chậm hơn rất nhiều.

Bạn đã xem phương pháp mở rộng Tổng hợp chưa?

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

Ví dụ thực tế từ mã của tôi:

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

Truy vấn là một đối tượng có thuộc tính Tên là một chuỗi và tôi muốn tên của tất cả các truy vấn trong danh sách đã chọn, được phân tách bằng dấu phẩy.

Dưới đây là cách tiếp cận Kết hợp / Linq kết hợp mà tôi đã giải quyết sau khi xem xét các câu trả lời khác và các vấn đề được giải quyết trong một câu hỏi tương tự (cụ thể là Tổng hợp và Kết hợp không thành công với 0 yếu tố).

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

hoặc (nếu skhông phải là một chuỗi)

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

• Đơn giản
• dễ đọc và dễ hiểu
• làm việc cho các yếu tố chung
• cho phép sử dụng các đối tượng hoặc thuộc tính đối tượng
• xử lý trường hợp các phần tử có độ dài 0
• có thể được sử dụng với bộ lọc Linq bổ sung
• thực hiện tốt (ít nhất là theo kinh nghiệm của tôi)
• không yêu cầu (thủ công) tạo một đối tượng bổ sung (ví dụ StringBuilder) để thực hiện

Và tất nhiên, Join sẽ chăm sóc dấu phẩy cuối cùng đáng tiếc mà đôi khi lén lút vào các phương pháp khác ( for, foreach), đó là lý do tại sao tôi tìm kiếm một giải pháp Linq ngay từ đầu.

Bạn có thể sử dụng StringBuildertrong 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());

(Có Selecttrong đó chỉ để cho thấy bạn có thể làm nhiều công cụ LINQ hơn.)

dữ liệu hiệu suất nhanh cho trường hợp StringBuilder vs Chọn & Tổng hợp trên 3000 phần tử:

Kiểm tra đơn vị - Thời lượng (giây)
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);
    }

Tôi luôn sử dụng phương thức mở rộng:

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

Bằng ' cách LINQ cực hay ', bạn có thể nói về cách LINQ làm cho lập trình chức năng trở nên ngon miệng hơn rất nhiều khi sử dụng các phương thức mở rộng. Ý tôi là, đường cú pháp cho phép các chức năng được xâu chuỗi theo cách trực quan tuyến tính (cái này nối tiếp nhau) thay vì lồng nhau (cái này bên trong cái kia). Ví dụ:

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

có thể được viết như thế này:

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

Bạn có thể thấy ví dụ thứ hai dễ đọc hơn. Bạn cũng có thể thấy làm thế nào nhiều chức năng có thể được thêm vào với ít vấn đề thụt đầu dòng hơn hoặc các dấu đóng đóng Lispy xuất hiện ở cuối biểu thức.

Rất nhiều câu trả lời khác nói rằng đó String.Joinlà cách để đi bởi vì nó là cách nhanh nhất hoặc đơn giản nhất để đọc. Nhưng nếu bạn hiểu theo cách của tôi về ' cách LINQ siêu ngầu ' thì câu trả lời là sử dụng String.Joinnhưng hãy gói nó theo phương pháp mở rộng kiểu LINQ sẽ cho phép bạn xâu chuỗi các chức năng của mình theo cách trực quan. Vì vậy, nếu bạn muốn viết, sa.Concatenate(", ")bạn chỉ cần tạo ra một cái gì đó như thế này:

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

Điều này sẽ cung cấp mã có hiệu suất như cuộc gọi trực tiếp (ít nhất là về độ phức tạp thuật toán) và trong một số trường hợp có thể làm cho mã dễ đọc hơn (tùy thuộc vào ngữ cảnh), đặc biệt nếu mã khác trong khối đang sử dụng kiểu hàm chuỗi .

Có nhiều câu trả lời khác nhau cho câu hỏi trước đó - được thừa nhận đang nhắm mục tiêu một mảng số nguyên làm nguồn, nhưng đã nhận được câu trả lời chung chung.

Ở đây, nó sử dụng LINQ thuần túy như một biểu thức:

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

Và nó khá nhanh chết tiệt!

Tôi sẽ gian lận một chút và đưa ra một câu trả lời mới cho điều này dường như tổng hợp những điều tốt nhất ở đây thay vì dán nó vào trong một bình luận.

Vì vậy, bạn có thể một dòng này:

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

Chỉnh sửa: Trước tiên, bạn sẽ muốn kiểm tra vô số trống hoặc thêm một.Replace("\a",string.Empty); vào cuối biểu thức. Đoán tôi có thể đã cố gắng để có được một chút quá thông minh.

Câu trả lời từ @ a.friend có thể hiệu quả hơn một chút, tôi không chắc Thay thế nào dưới mui xe so với Xóa. Một cảnh báo duy nhất khác nếu một số lý do bạn muốn nối chuỗi kết thúc bằng \ a là bạn sẽ mất dấu phân cách của mình ... Tôi thấy điều đó là không thể. Nếu đó là trường hợp bạn có các nhân vật ưa thích khác để lựa chọn.

Bạn có thể kết hợp LINQ và string.join()khá hiệu quả. Ở đây tôi đang loại bỏ một mục từ một chuỗi. Có nhiều cách tốt hơn để làm điều này quá nhưng đây là:

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

Rất nhiều sự lựa chọn ở đây. Bạn có thể sử dụng LINQ và StringBuilder để bạn có được hiệu suất như vậy:

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

Tôi đã làm nhanh và bẩn sau đây khi phân tích tệp nhật ký IIS bằng linq, nó hoạt động khá tốt @ 1 triệu dòng (15 giây), mặc dù đã hết lỗi bộ nhớ khi thử 2 triệu dòng.

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

    }

Lý do thực sự tôi đã sử dụng linq là vì một Sự khác biệt () tôi cần trước đây:

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

Tôi đã viết về điều này một thời gian trước đây, những gì tôi đã thực hiện chính xác những gì bạn đang tìm kiếm:

http://ondevelopment.blogspot.com/2009/02/opes-concatenation-ADE-easy.html

Trong bài đăng trên blog mô tả cách triển khai các phương thức mở rộng hoạt động trên IEnumerable và được đặt tên là Concatenate, điều này sẽ cho phép bạn viết những thứ như:

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

Hoặc những thứ phức tạp hơn như:

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