Dizeleri birleştirmek için LINQ kullanma

Eski okulu yazmanın en etkili yolu nedir:

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

... LINQ'da mı?

Bu cevap, Aggregatesoruda talep edildiği gibi LINQ ( ) kullanımını gösterir ve günlük kullanım için tasarlanmamıştır. Bu bir kullanmadığı StringBuilderiçin çok uzun diziler için korkunç bir performansa sahip olacaktır. String.JoinDiğer cevapta gösterildiği gibi düzenli kod kullanımı için

Bunun gibi toplu sorguları kullanın:

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

Bu çıktılar:

, bir, iki, üç

Toplama, bir değer koleksiyonu alan ve skaler bir değer döndüren bir işlevdir. T-SQL örnekleri arasında min, maks ve sum sayılabilir. Hem VB hem de C #, kümeler için desteğe sahiptir. Hem VB hem de C #, uzantı yöntemleri olarak toplamaları destekler. Nokta gösterimini kullanarak, bir kişi IEnumerable nesnesinde bir yöntemi çağırır .

Toplam sorguların hemen yürütüldüğünü unutmayın.

Daha fazla bilgi - MSDN: Toplu Sorgular

Gerçekten CodeMonkeyKing tarafından yorumda önerilen Aggregatekullanarak , çok sayıda nesne için iyi performans da dahil olmak üzere normal kodla aynı olan bir varyantı kullanmak istiyorsanız :StringBuilderString.Join

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

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

.Net 4, yeni bir var aşırı yük için string.Joinolduğunu kabul IEnumerable<string>. Kod daha sonra şöyle görünecektir:

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

Neden Linq kullanıyorsunuz?

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

Mükemmel çalışıyor ve IEnumerable<string>hatırladığım kadarıyla kabul ediyor . AggregateBurada çok daha yavaş olan hiçbir şeye gerek yok.

Agrega uzatma yöntemine baktınız mı?

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

Kodumdan gerçek örnek:

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

Bir sorgu bir dize olan bir Name özelliği olan bir nesnedir ve seçilen listedeki tüm sorguların virgülle ayrılmış adlarını istiyorum.

Burada, diğer cevaplara ve benzer bir soruda ele alınan sorunlara (yani Toplama ve Birleştirme'nin 0 öğeyle başarısız olması) baktıktan sonra yerleştiğim birleştirilmiş Birleştirme / Linq yaklaşımı .

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

veya ( sdize değilse)

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

• Basit
• okuması ve anlaması kolay
• jenerik elemanlar için çalışır
• nesnelerin veya nesne özelliklerinin kullanılmasına izin verir
• 0 uzunluklu elemanların durumunu ele alır
• ek Linq filtreleme ile kullanılabilir
• iyi performans gösterir (en azından tecrübelerime göre)
• uygulamak için ek bir nesnenin (örn. StringBuilder) oluşturulmasını (manuel olarak) gerektirmez

Ve tabii ki Join bazen diğer yaklaşımlara ( for, foreach) gizlenen sinir bozucu son virgülle ilgilenir , bu yüzden ilk etapta bir Linq çözümü arıyordum.

Sen kullanabilirsiniz StringBuilderin 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());

( SelectSadece daha fazla LINQ işi yapabileceğinizi göstermek için orada.)

3000'den fazla element ve StringBuilder vs Select & Aggregate durumu için hızlı performans verileri:

Birim testi - Süre (saniye)
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);
    }

Ben her zaman uzantısı yöntemini kullanı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);
}

' Süper havalı LINQ yolu ' ile, LINQ'nun işlevsel programlamayı genişletme yöntemlerinin kullanımı ile çok daha lezzetli hale getirme şeklinden bahsediyor olabilirsiniz. Demek istediğim, fonksiyonların iç içe yerleştirme yerine (diğerinin içinde) görsel olarak doğrusal bir şekilde (birbiri ardına) zincirlenmesine izin veren sözdizimsel şeker. Örneğin:

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

şöyle yazılabilir:

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

İkinci örneğin daha kolay okunmasını görebilirsiniz. Ayrıca, girintileme sorunlarından veya ifadenin sonunda görünen Lispy kapanış çözümleriyle daha fazla işlevin nasıl eklenebileceğini görebilirsiniz .

Diğer cevapların birçoğu, String.Joinbunun en hızlı veya en basit yol olduğu için gidilecek yol olduğunu belirtiyor. Ama eğer ' süper havalı LINQ yolu ' hakkındaki yorumumu alırsanız , cevap kullanmaktır, String.Joinancak fonksiyonlarınızı görsel olarak hoş bir şekilde zincirlemenize izin verecek bir LINQ tarzı uzatma yöntemine sarılmış olmalıdır. Yani yazmak sa.Concatenate(", ")istiyorsanız sadece böyle bir şey oluşturmanız gerekir:

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

Bu, doğrudan çağrı kadar performans gösteren kod sağlayacaktır (en azından algoritma karmaşıklığı açısından) ve bazı durumlarda özellikle bloktaki diğer kodlar zincirlenmiş fonksiyon stilini kullanıyorsa, kodu daha fazla okunabilir hale getirebilir (içeriğe bağlı olarak). .

Bu önceki soruda , kaynak olarak bir tamsayı dizisini hedefleyen, ancak genelleştirilmiş yanıtlar alan çeşitli alternatif cevaplar var.

Burada tek bir ifade olarak saf LINQ kullanıyor:

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

Ve oldukça hızlı!

Biraz hile yapacağım ve bir yorumun içine yapışmak yerine burada her şeyin en iyisini özetleyen yeni bir cevap vereceğim.

Yani bunu bir satır yapabilirsiniz:

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

Düzenleme: Önce boş bir numaralandırılabilir olup olmadığını kontrol etmek veya .Replace("\a",string.Empty);ifadenin sonuna bir eklemek istersiniz . Sanırım biraz fazla zeki olmaya çalışıyordum.

@ A.friend'in cevabı biraz daha performanslı olabilir, Kaldır'ın yerine Replace'ın kaputun altında ne yaptığından emin değilim. \ A's ile biten dizeleri concat etmek istediğiniz bir sebep varsa, ayırıcılarınızı kaybedersiniz ... Bu durumda, aralarından seçim yapabileceğiniz başka süslü karakterleriniz var .

LINQ ve string.join()oldukça etkili bir şekilde birleştirebilirsiniz . Burada bir öğeyi bir dizeden kaldırıyorum. Bunu yapmanın daha iyi yolları var ama işte burada:

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

Burada bir sürü seçenek var. LINQ ve bir StringBuilder kullanabilirsiniz, böylece performansı da şöyle elde edebilirsiniz:

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

Linq kullanarak bir IIS günlük dosyasını ayrıştırırken aşağıdaki hızlı ve kirli yaptım, 2 milyon satır çalışırken bellek yetersizliği var, ancak 1 milyon satır oldukça iyi çalıştı (15 saniye).

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

    }

Linq kullanmamın gerçek nedeni, daha önce kullandığım bir Distinct () içindi:

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

Bir süre önce bunun hakkında blog yazdım, dikişleri tam olarak aradığınız şey olarak yaptım:

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

Blog yazısında, IEnumerable üzerinde çalışan ve Concatenate olarak adlandırılan uzantı yöntemlerinin nasıl uygulanacağını açıklayın, bu aşağıdaki gibi şeyler yazmanıza izin verir:

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

Veya daha ayrıntılı şeyler:

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