String - StringBuilder karşılaştırması

Ben arasındaki farkı anlamak Stringve StringBuilder( StringBuilderdeğişken olmak üzere) fakat bu ikisi arasında büyük performans farkı var mıdır?

Üzerinde çalıştığım programın büyük bir kısmı vaka odaklı dize (500+) ekler. Kullanmak StringBuilderdaha iyi bir seçim mi?

Evet, performans farkı önemlidir. " Visual C # dize birleştirme performansını artırmak için " KB makalesine bakın .

Her zaman önce netlik için kod yazmayı ve daha sonra performans için optimize etmeyi denedim. Bu tam tersini yapmaktan çok daha kolay! Ancak, ikisi arasındaki uygulamalarımdaki muazzam performans farkını gördükten sonra, şimdi biraz daha dikkatli düşünüyorum.

Neyse ki, zamanınızı nerede harcadığınızı görmek için kodunuzda performans analizi çalıştırmak ve sonra StringBuildergerektiğinde kullanmak üzere değiştirmek nispeten kolaydır .

Gillian'ın 4 dize hakkında ne söylediğini açıklığa kavuşturmak için, böyle bir şeyiniz varsa:

string a,b,c,d;
 a = b + c + d;

o zaman dizeleri ve artı operatörünü kullanmak daha hızlı olurdu. Bunun nedeni (Java gibi, Eric'in belirttiği gibi) dahili olarak StringBuilder'ı otomatik olarak kullanmasıdır (Aslında, StringBuilder'ın da kullandığı bir ilkel kullanır)

Ancak, yaptığınız şeye daha yakınsa:

string a,b,c,d;
 a = a + b;
 a = a + c;
 a = a + d;

Sonra açıkça bir StringBuilder kullanmanız gerekir. .Net anlamsız olacağından burada otomatik olarak bir StringBuilder oluşturmaz. Her satırın sonunda, "a" (değişmez) bir dize olmalıdır, bu nedenle her satırda bir StringBuilder oluşturmak ve atamak gerekir. Hız için oluşturmayı bitirene kadar aynı StringBuilder'ı kullanmanız gerekir:

string a,b,c,d;
StringBuilder e = new StringBuilder();
 e.Append(b);
 e.Append(c);
 e.Append(d);
 a = e.ToString();

StringBuilder tercih edilir EĞER PURE performans için, ancak ... kodunuzu geçişte birden döngüler, veya çatal yapıyoruz bir yanına eğer, TEK çok daha performanslısı sonra dize beyanı.

Örneğin:

string myString = "Some stuff" + var1 + " more stuff"
                  + var2 + " other stuff" .... etc... etc...;

daha performanslı

StringBuilder sb = new StringBuilder();
sb.Append("Some Stuff");
sb.Append(var1);
sb.Append(" more stuff");
sb.Append(var2);
sb.Append("other stuff");
// etc.. etc.. etc..

Bu durumda, StringBuild daha sürdürülebilir olarak kabul edilebilir, ancak tek dize bildiriminden daha fazla performans göstermez.

10 üzerinden 9 kez ... string builder kullanın.

Bir yan notta: string + var, string.un içinde dahili olarak bir StringBuilder kullanan Format yaklaşımının (genellikle) daha fazla performans gösterir (şüpheniz olduğunda ... reflektörü kontrol edin!)

StringBirleştirme vs kullanırken hız farkını göstermek için basit bir örnek StringBuilder:

System.Diagnostics.Stopwatch time = new Stopwatch();
string test = string.Empty;
time.Start();
for (int i = 0; i < 100000; i++)
{
    test += i;
}
time.Stop();
System.Console.WriteLine("Using String concatenation: " + time.ElapsedMilliseconds + " milliseconds");

Sonuç:

Dize birleştirmesini kullanma: 15423 milisaniye

StringBuilder test1 = new StringBuilder();
time.Reset();
time.Start();
for (int i = 0; i < 100000; i++)
{
    test1.Append(i);
}
time.Stop();
System.Console.WriteLine("Using StringBuilder: " + time.ElapsedMilliseconds + " milliseconds");

Sonuç:

StringBuilder'ı kullanma: 10 milisaniye

Sonuç olarak, ilk yineleme 15423 ms alırken, ikinci yineleme StringBuilder10 ms sürdü.

Bana göre StringBuilderkullanım daha hızlı, çok daha hızlı.

Bu kıyaslama, 3 veya daha az dizeyi birleştirirken düzenli birleştirme işleminin daha hızlı olduğunu gösterir.

http://www.chinhdo.com/20070224/stringbuilder-is-not-always-faster/

StringBuilder, özellikle 500 dizeyi birlikte eklemeniz durumunda, bellek kullanımında çok önemli bir iyileştirme yapabilir.

Aşağıdaki örneği düşünün:

string buffer = "The numbers are: ";
for( int i = 0; i < 5; i++)
{
    buffer += i.ToString();
}
return buffer;

Hafızada ne olur? Aşağıdaki dizeler oluşturulur:

1 - "The numbers are: "
2 - "0"
3 - "The numbers are: 0"
4 - "1"
5 - "The numbers are: 01"
6 - "2"
7 - "The numbers are: 012"
8 - "3"
9 - "The numbers are: 0123"
10 - "4"
11 - "The numbers are: 01234"
12 - "5"
13 - "The numbers are: 012345"

Dizenin sonuna bu beş sayıyı ekleyerek 13 dize nesnesi oluşturduk! Ve 12 tanesi işe yaramadı! Vaov!

StringBuilder bu sorunu giderir. Sıklıkla duyduğumuz gibi "değiştirilebilir bir dize" değildir (.NET'teki tüm dizeler değişmezdir ). Dahili bir tampon, bir dizi karakter tutarak çalışır. Append () veya AppendLine () öğesini çağırmak, dizeyi char dizisinin sonundaki boş alana ekler; dizi çok küçükse, yeni, daha büyük bir dizi oluşturur ve arabelleği buraya kopyalar. Yukarıdaki örnekte, StringBuilder, arabellek boyutuna bağlı olarak dizeye 5 eklemenin tümünü içeren tek bir diziye ihtiyaç duyabilir. StringBuilder'a yapıcısında arabelleğinin ne kadar büyük olması gerektiğini söyleyebilirsiniz.

Evet, StringBuilderbir dize üzerinde tekrarlanan işlem gerçekleştirirken daha iyi performans verir. Bunun nedeni, tüm değişikliklerin tek bir örnekte yapılması, böylece yeni bir örnek oluşturmak yerine çok zaman kazanmasıdır.String .

String Vs Stringbuilder

• String

  1. altında Systemad alanının
  2. değişmez (salt okunur) örnek
  3. sürekli değer değişikliği meydana geldiğinde performans düşer
  4. iplik güvenli

• StringBuilder (değiştirilebilir dize)

  1. altında System.Textad alanının
  2. değiştirilebilir örnek
  3. mevcut örnekte yeni değişiklikler yapıldığından daha iyi performans gösterir

Kesinlikle dotnet mob makalesini tavsiye: String Vs StringBuilder C # .

İlgili Yığın Taşması sorusu: Dize C # değişmediğinde dizenin değişebilirliği? .

String Vs String Builder:

İlk bilmeniz gereken bu iki sınıf hangi mecliste yaşıyor?

Yani,

dize varSystem isim alanında .

ve

StringBuilder içinde mevcutSystem.Text ad alanında bulunur.

için dize beyanı:

Dahil etmelisiniz SystemAd alanını . böyle bir şey. Using System;

ve

için StringBuilder beyanı:

Dahil etmelisiniz System.textAd alanını . böyle bir şey. Using System.text;

Şimdi asıl soru gel.

String & StringBuilder arasındaki fark nedir ?

Bu ikisi arasındaki temel fark şudur:

sicim değişmez.

ve

StringBuilder değiştirilebilir.

Yani Şimdi arasındaki farkı tartışalım değişmez ve değişken

Değişebilir:: Değiştirilebilir anlamına gelir.

Değişmez:: Değiştirilemez anlamına gelir.

Örneğin:

using System;

namespace StringVsStrigBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            // String Example

            string name = "Rehan";
            name = name + "Shah";
            name = name + "RS";
            name = name + "---";
            name = name + "I love to write programs.";

            // Now when I run this program this output will be look like this.
            // output : "Rehan Shah RS --- I love to write programs."
        }
    }
}

Bu durumda, aynı nesneyi 5 kez değiştireceğiz.

Yani açık soru şudur! Aynı ipi 5 kez değiştirdiğimizde, aslında kaputun altında olan şey.

Aynı dizeyi 5 kez değiştirdiğimizde olan budur.

şekle bakalım.

Açıklama:

Bu değişken "name" i "Rehan" olarak ilk başlattığımızda ie string name = "Rehan" bu değişken "name" yığını üzerinde oluşturulur ve "Rehan" değerine işaret eder. Bu satır yürütüldükten sonra: "name = name +" Shah ". Referans değişkeni artık" Rehan "nesnesini işaret etmiyor, şimdi" Shah "işaret ediyor ve bu böyle devam ediyor.

Yani stringbiz bellekte nesne oluşturmak kez biz bunları değiştiremezsiniz o değişmez anlamıdır.

Bu yüzden namedeğişkeni birleştirdiğimizde önceki nesne bellekte kalır ve başka bir yeni dize nesnesi oluşturulur ...

Yani yukarıdaki şekilde beş nesnemiz var, dört nesne atıldı ve hiç kullanılmadı. Onlar hala hafızada kalırlar ve hafıza miktarını alırlar. "Çöp Toplayıcı" kaynaklardan bellekten o kadar temiz sorumludur.

Bu yüzden dizgiyi her zaman tekrar tekrar manipüle ettiğimizde, bellekte orada kaldığımız birçok nesne var.

Bu Değişken dizesinin hikayesi.

Şimdi StringBuilder Object'e bakalım. Örneğin:

using System;
using System.Text;

namespace StringVsStrigBuilder
{
    class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder Example

            StringBuilder name = new StringBuilder();
            name.Append("Rehan");
            name.Append("Shah");
            name.Append("RS");
            name.Append("---");
            name.Append("I love to write programs.");


            // Now when I run this program this output will be look like this.
            // output : "Rehan Shah Rs --- I love to write programs."
        }
    }
}

Bu durumda, aynı nesneyi 5 kez değiştireceğiz.

Yani açık soru şudur! Aynı StringBuilder'i 5 kez değiştirdiğimizde, aslında başlık altında ne olur?

Aynı StringBuilder'ı 5 kez değiştirdiğimizde olan budur.

şekle bakalım.

Açıklama: StringBuilder nesnesi durumunda. yeni nesneyi elde edemezsiniz. Aynı nesne bellekte değişecektir, bu yüzden 10.000 kez nesneyi değiştirseniz bile, hala sadece bir stringBuilder nesnesine sahip olacağız.

Çöp nesneleriniz veya referans alınmayan stringBuilder nesneleriniz yok, çünkü neden değiştirilebiliyor. Değişebilir mi yani bir zaman içinde değişiyor mu?

farklılıklar:

• String System ad alanında, System.Text ad alanında Stringbuilder olarak bulunur.
• string değişmezdir; burada StringBuilder değişkendir.

StringBuilder, kullanılan ek bellek maliyetiyle, tahsis ve atama sayısını azaltır. Düzgün kullanıldığında, sonuç bulunana kadar derleyicinin daha büyük ve daha büyük dizeleri tekrar tekrar tahsis etme ihtiyacını tamamen ortadan kaldırabilir.

string result = "";
for(int i = 0; i != N; ++i)
{
   result = result + i.ToString();   // allocates a new string, then assigns it to result, which gets repeated N times
}

vs.

String result;
StringBuilder sb = new StringBuilder(10000);   // create a buffer of 10k
for(int i = 0; i != N; ++i)
{
   sb.Append(i.ToString());          // fill the buffer, resizing if it overflows the buffer
}

result = sb.ToString();   // assigns once

Bir String veya StringBuilder nesnesi için bir birleştirme işleminin performansı, bellek ayırmanın ne sıklıkta gerçekleştiğine bağlıdır. Bir String birleştirme işlemi her zaman bellek ayırırken, bir StringBuilder birleştirme işlemi yalnızca StringBuilder nesne arabelleği yeni verileri alacak kadar küçükse belleği ayırır. Sonuç olarak, sabit sayıda String nesnesi birleştirilirse, String sınıfı bir birleştirme işlemi için tercih edilir. Bu durumda, bireysel birleştirme işlemleri derleyici tarafından tek bir işlemde bile birleştirilebilir. Bir StringBuilder nesnesi, rastgele sayıda dizenin birleştirilmesi durumunda bir birleştirme işlemi için tercih edilir; örneğin, bir döngü rasgele sayıda kullanıcı girişi dizesini birleştirirse.

Kaynak: MSDN

StringBuilder sabit olmayan birçok değerden bir dize oluşturmak için daha iyidir.

Bir HTML veya XML belgesindeki birden çok değer satırı veya diğer metin parçaları gibi çok sayıda sabit değerden bir dize oluşturuyorsanız, hemen hemen tüm derleyiciler aynı dizeye eklemekten kurtulabilirsiniz. "sabit katlama", bir grup sabit manipülasyonunuz olduğunda ayrıştırma ağacını azaltma işlemi (aynı zamanda bir şey yazarken de kullanılır int minutesPerYear = 24 * 365 * 60). Ayrıca, sabit olmayan değerlerin birbirine eklenmiş olduğu basit durumlar için, .NET derleyici kodunuzu, buna benzer bir şeye indirecektir StringBuilder.

Ancak, uygulamanız derleyici tarafından daha basit bir şeye indirgenemezse, bir StringBuilder. Fizch'in işaret ettiği gibi, bu bir döngü içinde gerçekleşme olasılığı daha yüksektir.

Birlikte eklemeniz gereken 4'ten fazla dizeniz varsa StringBuilder'ın daha hızlı olduğuna inanıyorum. Ayrıca AppendLine gibi harika şeyler yapabilir.

.NET'te, StringBuilder hala dizeleri eklemekten daha hızlıdır. Java'da, dizeleri eklediğinizde sadece başlık altında bir StringBuffer oluşturduğundan eminim, bu yüzden gerçekten bir fark yok. Bunu neden henüz .NET'te yapmadıklarından emin değilim.

' Mikro-Optimizasyon Tiyatrosunun Üzücü Trajedisi'ni düşünün .

Birleştirme için dizelerin kullanılması, sırasına göre çalışma zamanı karmaşıklığına yol açabilir O(n^2).

A kullanırsanız StringBuilder, yapılması gereken çok daha az bellek kopyası olur. İle StringBuilder(int capacity)nihai ne kadar büyük tahmin edebilir eğer performansını artırabilir Stringolacak. Kesin olmasanız bile, muhtemelen sadece StringBuilderperformansı birkaç kez artıracak kapasiteyi artırmanız gerekecektir .

Herhangi bir dize depolama için kullanmadan önce EnsureCapacity(int capacity)bir örnek üzerinde yöntem çağrısı kullanarak önemli performans kazançları gördük StringBuilder. Genellikle örnekleme sonrasında kod satırında çağırırım. Bunun StringBuildergibi başlatır gibi aynı etkiye sahiptir :

var sb = new StringBuilder(int capacity);

Bu çağrı, gerekli belleği önceden ayırır, bu da birden çok Append()işlem sırasında daha az bellek ayırmaya neden olur . Ne kadar belleğe ihtiyacınız olacağı konusunda eğitimli bir tahminde bulunmalısınız, ancak çoğu uygulama için bu çok zor olmamalıdır. Genellikle biraz fazla belleğin yan tarafında hata yapıyorum (1k kadar konuşuyoruz).

Önceki cevaplara ek olarak, bu gibi konuları düşünürken her zaman yaptığım ilk şey küçük bir test uygulaması oluşturmaktır. Bu uygulamanın içinde, her iki senaryo için de bazı zamanlama testi yapın ve hangisinin daha hızlı olduğunu kendiniz görün.

IMHO, 500'den fazla dize girdisi eklemek kesinlikle StringBuilder kullanmalıdır.

String ve StringBuilder aslında değişmezdir, StringBuilder, boyutunun daha verimli yönetilmesine izin veren arabelleklere sahiptir. StringBuilder yeniden boyutlandırmak gerektiğinde, öbek üzerinde yeniden tahsis edilir. Varsayılan olarak 16 karakter boyutundadır, bunu yapıcıda ayarlayabilirsiniz.

Örneğin.

StringBuilder sb = yeni StringBuilder (50);

Dize birleştirme size daha pahalıya mal olur. Java'da, ihtiyacınıza göre StringBuffer veya StringBuilder kullanabilirsiniz. Senkronize edilmiş ve iş parçacığı için güvenli bir uygulama istiyorsanız StringBuffer'a gidin. Bu, String birleşiminden daha hızlı olacaktır.

Senkronize veya İş Parçacığı güvenli uygulamasına ihtiyacınız yoksa, StringBuilder'a gidin. Bu, bağlantı birleşiminden daha hızlı ve aynı zamanda senkronizasyon yükü olmadığı için StringBuffer'dan daha hızlı olacaktır.

StringBuilder muhtemelen tercih edilir. Bunun nedeni, gelecekteki ekler için yer bırakmak üzere şu anda gerekenden daha fazla yer ayırmasıdır (karakter sayısını ayarlarsınız). O zaman gelecekteki arabelleklere uyan bu ekler pahalı olabilecek herhangi bir bellek ayırma veya çöp toplama gerektirmez. Genel olarak, karmaşık dize birleştirme veya birden çok biçimlendirme için StringBuilder kullanın, sonra veri tamamlandığında normal bir dizeye dönüştürmek ve tekrar değişmez bir nesne istiyorum.

Çok sayıda dize birleştirmesi yapıyorsanız, bir StringBuilder kullanın. Bir Dizeyle bitiştirdiğinizde, her seferinde daha fazla bellek kullanarak yeni bir Dizgi oluşturursunuz.

Alex

Genel bir kural olarak, dizenin değerini bir kereden fazla ayarlamam gerekiyorsa veya dizeye herhangi bir ekleme varsa, o zaman bir dize oluşturucu olmalıdır. Ben sadece büyümeye ve büyümeye devam gibi görünüyor büyük bir bellek ayak izi vardı dize üreticileri öğrenmek önce geçmişte yazdım uygulamaları gördüm. Bu programları dize oluşturucu kullanmak için değiştirmek bellek kullanımını önemli ölçüde azaltır. Şimdi dize üreticisi tarafından yemin ederim.

Benim yaklaşım her zaman 4 veya daha fazla dizeleri birleştirirken StringBuilder kullanmak oldu VEYA birleştirme nasıl olabilir bilmiyorum.

İyi performansla ilgili makale burada

StringBuilder önemli ölçüde daha verimlidir, ancak büyük miktarda dize değişikliği yapmadığınız sürece bu performansı görmezsiniz.

Aşağıda, performansa bir örnek vermek için hızlı bir kod grubu verilmiştir. Gördüğünüz gibi gerçekten sadece büyük iterasyonlara girdiğinizde büyük bir performans artışı görmeye başlıyorsunuz.

Gördüğünüz gibi 200.000 yineleme 22 saniye sürdü, 1 milyon yineleme StringBuilderise neredeyse anında gerçekleşti.

string s = string.Empty;
StringBuilder sb = new StringBuilder();

Console.WriteLine("Beginning String + at " + DateTime.Now.ToString());

for (int i = 0; i <= 50000; i++)
{
    s = s + 'A';
}

Console.WriteLine("Finished String + at " + DateTime.Now.ToString());
Console.WriteLine();

Console.WriteLine("Beginning String + at " + DateTime.Now.ToString());

for (int i = 0; i <= 200000; i++)
{
    s = s + 'A';
}

Console.WriteLine("Finished String + at " + DateTime.Now.ToString());
Console.WriteLine();
Console.WriteLine("Beginning Sb append at " + DateTime.Now.ToString());

for (int i = 0; i <= 1000000; i++)
{
    sb.Append("A");
}
Console.WriteLine("Finished Sb append at " + DateTime.Now.ToString());

Console.ReadLine();

Yukarıdaki kodun sonucu:

String + 'da 28/01/2013 16:55:40 tarihinde.

String + 28/01/2013 16:55:40'da tamamlandı.

String + 'da 28/01/2013 16:55:40 tarihinde.

String + 28/01/2013 16:56:02'de tamamlandı.

Sb'nin başlangıcı 28/01/2013 16:56:02 saatinde eklenir.

Biten Sb eki 28/01/2013 16:56:02 saatinde tamamlandı.

StringBuilder bellek durma noktasından daha iyi performans gösterir. İşlemeye gelince, yürütme süresindeki fark ihmal edilebilir.