Differenza tra stringhe e StringBuilder in c #

Mi piacerebbe conoscere la differenza tra string e StringBuilder e anche bisogno di alcuni esempi per la comprensione.

Un’istanza di string è immutabile. Non puoi cambiarlo dopo che è stato creato. Qualsiasi operazione che sembra modificare la stringa restituisce invece una nuova istanza:

 string foo = "Foo"; // returns a new string instance instead of changing the old one string bar = foo.Replace('o', 'a'); string baz = foo + "bar"; // ditto here 

Gli oggetti immutabili hanno alcune buone proprietà, come possono essere usati attraverso i thread senza temere i problemi di sincronizzazione o semplicemente distribuire i campi di backing privati ​​senza temere che qualcuno cambi oggetti che non dovrebbero cambiare (vedi array o liste mutabili, che spesso devono essere copiati prima di restituirli se ciò non è desiderato). Ma se usati con noncuranza possono creare gravi problemi di prestazioni (come quasi qualsiasi cosa – se hai bisogno di un esempio di un linguaggio che si vanta della velocità di esecuzione, guarda le funzioni di manipolazione delle stringhe di C).

Quando hai bisogno di una stringa mutabile , come quella che stai costruendo in base al pezzo o dove cambi molte cose, avrai bisogno di un StringBuilder che è un buffer di caratteri che può essere modificato. Ciò ha, per la maggior parte, implicazioni sulle prestazioni. Se vuoi una stringa mutabile e invece lo fai con una normale istanza di string , allora finirai con la creazione e la distruzione di molti oggetti inutilmente, mentre una stessa istanza di StringBuilder cambierà, annullando la necessità di molti nuovi oggetti.

Semplice esempio: quanto segue farà in modo che molti programmatori si vergognino di dolore:

 string s = string.Empty; for (i = 0; i < 1000; i++) { s += i.ToString() + " "; } 

Finirai col creare qui le stringhe 2001, di cui 2000 buttate via. Lo stesso esempio con StringBuilder:

 StringBuilder sb = new StringBuilder(); for (i = 0; i < 1000; i++) { sb.Append(i); sb.Append(' '); } 

Questo dovrebbe mettere meno stress sull'allocatore di memoria 🙂

Dovrebbe essere notato, tuttavia, che il compilatore C # è abbastanza intelligente quando si tratta di stringhe. Ad esempio, la seguente riga

 string foo = "abc" + "def" + "efg" + "hij"; 

sarà unito dal compilatore, lasciando solo una singola stringa in fase di esecuzione. Allo stesso modo, linee come

 string foo = a + b + c + d + e + f; 

sarà riscritto a

 string foo = string.Concat(a, b, c, d, e, f); 

quindi non devi pagare per cinque concatenazioni senza senso che sarebbe il modo ingenuo di gestirlo. Questo non ti salverà nei loop come sopra (a meno che il compilatore non srotoli il loop ma penso che solo la JIT potrebbe effettivamente farlo e meglio non scommettere su quello).

Differenza tra String e StringBuilder?

Stringa:

La stringa è immutabile. Immutabile significa che una volta creato l’object stringa non possiamo modificarlo. Qualsiasi operazione come inserire, sostituire o accodare è accaduto per cambiare stringa, semplicemente scarterà il vecchio valore e creerà una nuova istanza in memoria per contenere il nuovo valore.

Esempio:

 string str = "hi"; str += "hello"; // New string instance will be created, instead of changing the old one str += "hw ru"; // Again new string instance will be created, instead of changing the old one 

StringBuilder:

Il generatore di stringhe è mutabile, significa che una volta creato l’object generatore di stringhe, possiamo eseguire qualsiasi operazione come inserire, sostituire o aggiungere senza creare nuove istanze per ogni volta.

Esempio:

 StringBuilder sb = new StringBuilder(""); sb.Append("hi"); sb.Append("hello"); string str = sb.ToString(); 

Maggiori informazioni su “Differenze tra String e StringBuilder” in formato tabulare con esempio qui.

La stringa è immutabile, il che significa che quando crei una stringa non puoi mai cambiarla, ma creerà una nuova stringa per memorizzare il nuovo valore, questo può essere inefficiente se devi cambiare molto il valore di una variabile di stringa.

Stringbuilder può essere utilizzato per simulare una stringa mutabile, quindi è utile quando è necessario cambiare molto una stringa.

String Vs StringBuilder

  • Stringa
    1. sotto lo spazio dei nomi di sistema
    2. Istanza immutabile (solo in lettura)
    3. le prestazioni diminuiscono quando si verifica un cambiamento continuo di valore
    4. filo sicuro
  • StringBuilder (stringa mutabile)
    1. sotto lo spazio dei nomi System.Text
    2. istanza mutabile
    3. mostra una migliore perfomance poiché vengono apportate nuove modifiche all’istanza esistente

Articolo descrittivo su questo argomento con molti esempi che utilizzano ObjectIDGenerator , segui questo link

Related Stackeoverflow Domanda: Mutabilità della stringa quando la stringa non cambia in C #?

String Un’istanza String è immutabile, ovvero non possiamo cambiarla dopo che è stata creata. Se eseguiamo qualsiasi operazione su una stringa, essa restituirà una nuova istanza (crea una nuova istanza in memoria) invece di modificare il valore di istanza esistente.

StringBuilder StringBuilder è mutabile, ovvero se eseguiamo qualsiasi operazione su StringBuilder aggiornerà il valore dell’istanza esistente e non creerà nuova istanza.

http://www.dotnetlearners.com/blogs/view/180/Difference-between-String-and-StringBuilder.aspx

Un StringBuilder ti aiuterà quando avrai bisogno di build stringhe in più passaggi.

Invece di fare questo:

 String x = ""; x += "first "; x += "second "; x += "third "; 

tu fai

 StringBuilder sb = new StringBuilder(""); sb.Append("first "); sb.Append("second "); sb.Append("third"); String x = sb.ToString(); 

l’effetto finale è lo stesso, ma StringBuilder utilizzerà meno memoria e verrà eseguito più velocemente. Invece di creare una nuova stringa che è la concatenazione dei due, creerà i blocchi separatamente, e solo alla fine li unirà.

Dalla documentazione della class StringBuilder :

L’object String è immutabile. Ogni volta che si utilizza uno dei metodi nella class System.String, si crea un nuovo object stringa in memoria, che richiede una nuova allocazione di spazio per il nuovo object. Nelle situazioni in cui è necessario eseguire ripetute modifiche a una stringa, l’overhead associato alla creazione di un nuovo object String può essere costoso. La class System.Text.StringBuilder può essere utilizzata quando si desidera modificare una stringa senza creare un nuovo object. Ad esempio, l’uso della class StringBuilder può aumentare le prestazioni quando si concatenano più stringhe insieme in un ciclo.

Grande differenza:

La stringa è immutabile. Significa che non è ansible modificare la stringa, il risultato della modifica è una nuova stringa. Questo non è efficace se si pianifica di aggiungere alla stringa

StringBuilder è mutevole. Può essere modificato in qualsiasi modo e non richiede la creazione di nuove istanze. Al termine del lavoro, è ansible chiamare ToString () per ottenere la stringa.

Le stringhe possono partecipare all’internamento, significa che le stringhe con gli stessi contenuti possono avere gli stessi indirizzi. StringBuilder non può essere internato.

String è l’unica class che può avere letterale di riferimento.

Le stringhe sono immutabili, ovvero se modifichi il suo valore, il vecchio valore verrà scartato e verrà creato un nuovo valore nell’heap mentre nel generatore di stringhe possiamo modificare il valore esistente senza che venga creato il nuovo valore. Quindi lo String Builder di Performance Wise è utile perché non occupiamo inutilmente più spazio di memoria.

una stringa è un tipo immutabile. Ciò significa che ogni volta che inizi a concatenare stringhe tra loro, crei ogni volta nuove stringhe. Se lo fai tante volte finisci con un sovraccarico di heap e il rischio di esaurire la memoria.

Viene utilizzata un’istanza StringBuilder per poter aggiungere stringhe alla stessa istanza, creando una stringa quando si chiama il metodo ToString su di essa.

A causa del sovraccarico dell’istanziazione di un object StringBuilder, Microsoft ha detto che è utile quando si hanno più di 5-10 concatenazioni di stringhe.

Per il codice di esempio ti suggerisco di dare un’occhiata qui:

http://msdn.microsoft.com/en-us/library/system.string.aspx http://msdn.microsoft.com/en-us/library/system.text.stringbuilder.aspx

http://msdn.microsoft.com/en-us/library/2839d5h5(VS.71).aspx

Grz, Kris.

Una stringa (System.String) è un tipo definito all’interno del framework .NET. La class String non è mutabile. Ciò significa che ogni volta che si esegue un’azione su un’istanza System.String, il compilatore .NET crea una nuova istanza della stringa. Questa operazione è nascosta allo sviluppatore.

Un System.Text.StringBuilder è una class che rappresenta una stringa mutabile. Questa class fornisce alcuni metodi utili che rendono l’utente in grado di gestire la stringa avvolta da StringBuilder. Si noti che tutte le manipolazioni sono fatte sulla stessa istanza di StringBuilder.

Microsoft incoraggia l’uso della causa StringBuilder è più efficace in termini di utilizzo della memoria.

Anche la complessità delle concatenazioni di String è O (N2) mentre per StringBuffer è O (N). Quindi ci potrebbero essere problemi di prestazioni in cui usiamo concatenazioni nei loop come molti nuovi oggetti creati ogni volta.

È ansible utilizzare il metodo Clone se si desidera eseguire un’iterazione tramite le stringhe insieme al generatore di stringhe. Restituisce un object in modo che sia ansible convertire in string utilizzando il metodo ToString … 🙂

Sistema. La stringa è mutevole La media dell’object non può essere modificata dopo la sua creazione, per favore fai riferimento all’URL qui sotto per capire meglio

http://developer-insight.blogspot.com/2017/04/different-between-system.html