Dizeleri birleştirmenin en etkili yolu?

Dizeleri birleştirmenin en etkili yolu nedir?

StringBuilder.Append()Yöntem çok daha iyi kullanarak daha +operatörü. Ancak, 1000 veya daha az bitiştirme gerçekleştirirken, String.Join()daha da etkili olduğunu fark ettim StringBuilder.

StringBuilder sb = new StringBuilder();
sb.Append(someString);

Tek sorun String.Joindizeleri ortak bir sınırlayıcı ile birleştirmek zorunda olmasıdır.

Düzenleme: @ryanversaw'ın işaret ettiği gibi , sınırlayıcıyı yapabilirsiniz string.Empty.

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

.NET Performans gurusu Rico Mariani'nin bu konuda bir makalesi vardı . Şüphelendiğiniz kadar basit değil. Temel tavsiye şudur:

Deseniniz aşağıdaki gibi görünüyorsa:

x = f1(...) + f2(...) + f3(...) + f4(...)

Bu bir concat ve zippy, StringBuilder muhtemelen yardımcı olmaz.

Deseniniz aşağıdaki gibi görünüyorsa:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

muhtemelen StringBuilder'ı istersiniz.

Bu iddiayı destekleyen başka bir makale Eric Lippert'den geliyor ve burada bir satırda yapılan +birleşmelerde yapılan optimizasyonları detaylı bir şekilde anlatıyor .

6 tür dize birleşimi vardır:

1. Plus ( +) sembolünü kullanarak .
2. Kullanma string.Concat().
3. Kullanma string.Join().
4. Kullanma string.Format().
5. Kullanma string.Append().
6. Kullanma StringBuilder.

Bir deneyde, string.Concat()kelimeler 1000'den azsa (yaklaşık olarak) ve kelimeler 1000'den fazla ise yaklaşmanın en iyi yolu olduğu kanıtlanmıştır StringBuilder.

Daha fazla bilgi için bu siteyi kontrol edin .

string.Join () ve string.Concat () karşılaştırması

Buradaki string.Concat yöntemi, boş bir ayırıcıyla string.Join yönteminin çağrılmasına eşdeğerdir. Boş bir dize eklemek hızlıdır, ancak bunu yapmamak daha da hızlıdır, bu nedenle string.Concat yöntemi burada daha üstün olacaktır.

Chinh Do Gönderen - StringBuilder her zaman daha hızlı değildir :

Temel Kurallar

• Bitiştirmek zaman üç daha az dinamik dize değerleri veya geleneksel dize birleştirme kullanın.

• Üçten fazla dinamik dize değerini birleştirirken kullanın StringBuilder.

• Birkaç dize değişmezinden büyük bir dize oluştururken, @dize değişmezini veya satır içi + işlecini kullanın.

Çoğu zaman StringBuilderen iyi bahsinizdir, ancak bu yayında gösterildiği gibi, en azından her durumu düşünmeniz gereken durumlar vardır.

Eğer bir döngü içinde çalışıyorsanız, StringBuildermuhtemelen gitmek için bir yoldur; düzenli olarak yeni dizeler oluşturma yükünü azaltır. Ancak sadece bir kez çalışacak kodda String.Concatmuhtemelen iyi.

Bununla birlikte, Rico Mariani (.NET optimizasyon gurusu) sonunda, çoğu durumda tavsiye ettiğini belirttiği bir sınav oluşturdu String.Format.

İşte büyük ölçekli NLP uygulamam için on yıldan fazla bir süredir geliştirdiğim en hızlı yöntem. Ben IEnumerable<T>farklı türler ( Charve String) ayırıcılar ile ve olmadan, ve diğer giriş türleri için varyasyonları var , ama ben burada bir dizideki tüm dizeleri ayırıcı olmadan, tek bir dizeye bitirme basit bir durum gösterir . Buradaki en son sürüm, C # 7 ve .NET 4.7 üzerinde geliştirilmiş ve birim olarak test edilmiştir .

Daha yüksek performans için iki anahtar vardır; birincisi, gereken tam boyutun önceden hesaplanmasıdır. Giriş, burada gösterildiği gibi bir dizi olduğunda bu adım önemsizdir. IEnumerable<T>Bunun yerine işlemek için, toplamı hesaplamak için önce dizeleri geçici bir dizide toplamaya değer (Dizi, aramadan kaçınmak için gereklidirToString() yan etkiler olasılığı göz önüne alındığında, teknik olarak, her bir öğe için birden fazla 'dize birleştirme' işlemi).

Daha sonra, son dizenin toplam tahsis boyutu göz önüne alındığında, performans dizisindeki en büyük artış , sonuç dizesini yerinde oluşturarak elde edilir . Bunu yapmak için String, başlangıçta sıfırlarla dolu olan yeni bir şeyin değişmezliğini geçici olarak askıya alma (belki de tartışmalı) tekniği gerekir . Ancak böyle bir tartışma bir yana ...

... bunun bu sayfada yapıcı tarafından fazladan bir tahsis ve kopyalama turundan tamamen kaçınan tek toplu birleştirme çözümü olduğunu unutmayın String.

Tam kod:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

Bu kodun kendimi kullandığımdan küçük bir değişiklik olduğunu belirtmeliyim. Orijinal, ben çağrı cpblk IL talimat dan C # fiili kopyalama yapmak. Buradaki koddaki basitlik ve taşınabilirlik için memcpy, gördüğünüz gibi, bunun yerine P / Invoke ile değiştirdim . X64'te ( ancak belki x86'da değil ) en yüksek performans için, bunun yerine cpblk yöntemini kullanmak isteyebilirsiniz .

Bu MSDN makalesinden :

Hem zaman hem de bellek olarak bir StringBuilder nesnesi oluşturmayla ilişkili bazı ek yükler vardır. Hızlı belleğe sahip bir makinede, yaklaşık beş işlem yapıyorsanız StringBuilder işe yarar. Genel bir kural olarak, 10 veya daha fazla dize işleminin herhangi bir makinedeki ek yük için bir gerekçe olduğunu, hatta daha yavaş olduğunu söyleyebilirim.

Eğer 10'dan fazla dizgi işlemi / birleştirme yapmanız gerekiyorsa MSDN'e güveniyorsanız StringBuilder ile gidin - aksi takdirde '+' ile basit dize concat gayet iyi.

Dizgi değişmezlerini+ birleştiriyorsanız , işleci kullanmanız gerektiğini belirtmek de önemlidir .

+ İşlecini kullanarak dize değişmezlerini veya dize sabitlerini birleştirdiğinizde, derleyici tek bir dize oluşturur. Çalışma zamanı birleştirmesi gerçekleşmez.

Nasıl yapılır: Birden Fazla Dizeyi Birleştirme (C # Programlama Kılavuzu)

Diğer cevaplara ek olarak, StringBuilder'a tahsis edilecek ilk bellek miktarının söylenebileceğini lütfen unutmayın .

Kapasiteli parametre geçerli örneği tarafından ayrılmış bellekte saklanabilir karakter sayısını tanımlar. Değeri Capacity özelliğine atanır . Geçerli örnekte depolanacak karakter sayısı bu kapasite değerini aşarsa , StringBuilder nesnesi bunları saklamak için ek bellek ayırır.

Eğer kapasite sıfırdır, uygulama özgü varsayılan kapasitesi kullanılır.

Önceden tahsis edilmemiş bir StringBuilder öğesine art arda eklemek, normal dizeleri tekrar tekrar birleştirmek gibi birçok gereksiz ayırmaya neden olabilir.

Son dizenin ne kadar süreceğini biliyorsanız, önemsiz bir şekilde hesaplayabilir veya ortak durum hakkında eğitimli bir tahmin yapabilir (çok fazla ayırmak mutlaka kötü bir şey değildir), bu bilgileri yapıcıya veya Kapasite özelliği. Özellikle StringBuilder'ı dahili olarak aynı şeyi yapan String.Concat gibi diğer yöntemlerle karşılaştırmak için performans testleri çalıştırırken. Çevrimiçi olarak gördüğünüz ve karşılaştırmalarında StringBuilder ön ayırmasını içermeyen tüm testler yanlıştır.

Boyut hakkında herhangi bir tahminde bulunamıyorsanız, büyük olasılıkla ön ayırmayı denetlemek için kendi isteğe bağlı argümanına sahip olması gereken bir yardımcı program işlevi yazıyorsunuzdur.

Birden fazla dizeyi birleştirmek için bir alternatif çözüm daha aşağıda olabilir.

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

dize enterpolasyonu

En verimli StringBuilder'ı kullanmaktır, şöyle:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy: String.Concat birkaç küçük şeyiniz varsa sorun yok. Ancak megabaytlarca veriyi birleştiriyorsanız, programınız büyük olasılıkla tanınır.

Bu 2 kod parçasını deneyin ve çözümü bulacaksınız.

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

Vs

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

1. kodun gerçekten hızlı biteceğini ve hafızanın iyi olduğunu göreceksiniz.

İkinci kod belki hafıza iyi olacak, ama daha uzun sürecek ... çok daha uzun. Bu nedenle, çok sayıda kullanıcı için bir uygulamanız varsa ve hıza ihtiyacınız varsa, 1.'i kullanın. Kısa vadeli bir kullanıcı uygulaması için bir uygulamanız varsa, belki ikisini de kullanabilirsiniz veya 2. geliştiriciler için daha "doğal" olacaktır.

Şerefe.

Sadece iki dize için kesinlikle StringBuilder kullanmak istemezsiniz. Üzerinde StringBuilder ek yükünün birden fazla dize tahsis etme yükünden daha az olduğu bir eşik vardır.

2-3 dizeden fazlası için DannySmurf kodunu kullanın . Aksi takdirde, + operatörünü kullanmanız yeterlidir.

System.String değişmez. Bir string değişkeninin değerini değiştirdiğimizde, yeni değere yeni bir bellek tahsis edilir ve önceki bellek tahsisi serbest bırakılır. System.StringBuilder, değiştirilmiş dize için ayrı bir bellek konumu tahsis edilmeden çeşitli işlemlerin gerçekleştirilebileceği değiştirilebilir bir dize konseptine sahip olacak şekilde tasarlanmıştır.

Başka bir çözüm:

döngü içinde dize yerine Liste'yi kullanın.

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

çok çok hızlı.

Bu gerçekten kullanım şeklinize bağlıdır. String.Join, string, Concat ve string.Format arasında ayrıntılı bir karşılaştırma burada bulunabilir: String.Format Yoğun Günlük Kaydı İçin Uygun Değil

(Bu aslında ben verdiğim aynı cevabı bu soruya)

Bu koda bağlıdır. StringBuilder genel olarak daha verimlidir, ancak yalnızca birkaç dizeyi birleştirir ve hepsini tek bir satırda yapıyorsanız, kod optimizasyonları muhtemelen sizin için ilgilenir. Kodun nasıl göründüğünü düşünmek önemlidir: daha büyük setler için StringBuilder okumayı kolaylaştıracak, küçük olanlar için StringBuilder sadece gereksiz dağınıklık ekleyecektir.