Qual è la differenza tra un mutabili e immutabili stringa in C#?

Qual è la differenza tra un mutabili e immutabili stringa in C#?

InformationsquelleAutor Venkadesh | 2010-11-25

 

14 Replies
  1. 312

    Mutabili e immutabili sono parola inglese che significa “cambio” e “non può cambiare”, rispettivamente. Il significato delle parole è la stessa nel contesto, cioè

    • una stringa mutabile può essere cambiato, e
    • immutabile stringa non può essere cambiato.

    Il significato di queste parole sono le stesse in C# /.NET come in altri linguaggi di programmazione /ambienti, anche se (ovviamente) i nomi dei tipi diversi, come possono gli altri dettagli.


    Per la cronaca:

    • String è lo standard C# /.Net immutabile di tipo stringa
    • StringBuilder è lo standard C# /.Net mutevole di tipo stringa

    Per “effetto di un cambiamento” una stringa rappresentata come un C# String, di creare effettivamente un nuovo String oggetto. Originale String non è cambiato … perché è immutabile.

    Nella maggior parte dei casi è meglio utilizzare String perché è più facile ragionare su di loro; ad esempio, non hai bisogno di a considerare la possibilità che qualche altro thread potrebbe “cambiare la mia stringa”. Tuttavia, quando è necessario creare o modificare una stringa utilizzando una sequenza di operazioni, può essere più efficiente utilizzare un StringBuilder.


    E, infine, per quelle persone che affermano che un StringBuilder non è una stringa, perché non è immutabile, la Microsoft documentazione descrive StringBuilder così:

    “Rappresenta un stringa mutabile di caratteri. Questa classe non può essere ereditata.”

  2. 181

    String è immutabile

    cioè le stringhe non possono essere alterati. Quando si modifica una stringa (con l’aggiunta, per esempio), in realtà si crea una nuova stringa.

    Ma StringBuilder non è immutabile (piuttosto, è mutevole)

    quindi se dovete modificare una stringa molte volte, come più concatenazioni, quindi utilizzare StringBuilder.

    • Cosa succede se si concat immutabile stringhe molte volte? Carichi di utilizzo della memoria per le stringhe, senza riferimenti? O semplicemente lento?
    • entrambi. Ogni concatenazione crea un nuovo oggetto String, e le copie di tutti i personaggi di entrambe le stringhe di input. Porta a O(N^2) comportamento …
    • spiegato con le parole chiave.
    • se si dispone di modificare una stringa molte volte, come più concatenazioni, quindi utilizzare StringBuilder … Che la mia mente eliminato totalmente grazie…
  3. 44

    Un oggetto è modificabile se, una volta creato, il suo stato può essere cambiato chiamando diverse operazioni su di esso, altrimenti è immutabile.

    Immutabile Stringa

    In C# e .NET) una stringa è rappresentato da un Sistema di classe.Stringa. Il string parola chiave è un alias per questa classe.

    Il Sistema.Classe String è immutabile, io.e una volta creato il suo stato non può essere alterato.

    Così tutte le operazioni che è possibile eseguire in una stringa come Substring, Remove, Replace, concatenazione utilizzando operatore ” + ” ecc crea una nuova stringa e ritorno.

    Vedere il seguente programma per la dimostrazione –

    string str = "mystring";
    string newString = str.Substring(2);
    Console.WriteLine(newString);
    Console.WriteLine(str);

    Questa stampa ‘stringa’ e ‘mystring’ rispettivamente.

    Per il benefici di immutabilità e perché le stringhe sono immutabili controllare Perché .NET Stringa è immutabile?.

    Stringa Mutabile

    Se si desidera avere una stringa che si desidera modificare spesso è possibile utilizzare il StringBuilder classe. Operazioni di StringBuilder istanza di modificare l’oggetto stesso.

    Per ulteriori consigli su quando utilizzare StringBuilder consultare Quando utilizzare StringBuilder?.

    • Bella spiegazione!!!
  4. 36

    Tutti string gli oggetti sono immutabili in C#. Gli oggetti della classe string, una volta creato, non può mai rappresentare un qualsiasi valore diverso da quello che essi sono stati costruiti con. Tutte le operazioni che sembrano “modificare” una stringa invece di produrre una nuova. Questo è inefficiente con la memoria, ma estremamente utile per quanto riguarda essere in grado di fiducia che una stringa non cambiare forma sotto di voi – perché finché non si cambia il vostro riferimento, la stringa di cui non cambierà mai.

    Un oggetto mutabile, invece, ha campi di dati che possono essere modificati. Uno o più dei suoi metodi di modificare il contenuto di un oggetto, o si dispone di una Proprietà che, scrittura, modifica il valore dell’oggetto.

    Se si dispone di un mutevole oggetto più simile alla Stringa è StringBuffer– poi devi fare una copia di esso, se si vuole essere assolutamente sicuri di non cambiare fuori da sotto di voi. Questo è il motivo per cui oggetti mutabili sono pericolosi da usare come chiavi in qualsiasi forma di Dictionary o gli oggetti stessi potrebbero cambiare, e la struttura dei dati non avrebbe modo di sapere, portando a dati corrotti che avrebbe, alla fine, in crash il programma.

    Tuttavia, è possibile modificare il contenuto, quindi è molto, molto di più memoria efficiente di effettuare una copia completa perché si voleva cambiare un singolo carattere, o qualcosa di simile.

    In generale, la cosa giusta da fare è utilizzare oggetti mutabili durante la creazione di qualcosa, e gli oggetti immutabili una volta che hai finito. Questo vale per gli oggetti che sono immutabili forme, naturalmente; la maggior parte delle collezioni non. Spesso è utile fornire di sola lettura forme di collezioni, però, che è l’equivalente di immutabile, quando invio la situazione all’interno della vostra collezione per altri contesti – in caso contrario, qualcosa potrebbe richiedere che il valore di ritorno, fare qualcosa per essa, e danneggiare i dati.

  5. 12

    Immutabile :

    Quando si esegue qualche operazione su un oggetto, crea un nuovo oggetto, quindi, non è modificabile, come nel caso della stringa.

    Mutevole

    Quando si eseguono alcune operazioni su un oggetto, oggetto, modificato nessun nuovo obect creato, come nel caso di StringBuilder

  6. 8

    In .NET
    Sistema.String (aka stringa) è un oggetto immutabile. Ciò significa che quando si crea un oggetto non può cambiare il valore di dopo. È possibile ricreare un oggetto immutabile.

    Sistema.Di testo.StringBuilder è mutevole equivalente del Sistema.Stringa e si può chane il suo valore

    Per Esempio:

    class Program
    {
        static void Main(string[] args)
        {
    
            System.String str = "inital value";
            str = "\nsecond value";
            str = "\nthird value";
    
            StringBuilder sb = new StringBuilder();
            sb.Append("initial value");
            sb.AppendLine("second value");
            sb.AppendLine("third value");
        }
    }

    Genera seguenti MSIL :
    Se si analizza il codice. Vedrete che ogni volta che si chane un oggetto di Sistema.Stringa che si sono in realtà la creazione di uno nuovo. Ma nel Sistema.Di testo.StringBuilder ogni volta che si modifica il valore del testo non ricreare l’oggetto.

    .method private hidebysig static void  Main(string[] args) cil managed
    {
      .entrypoint
      //Code size       62 (0x3e)
      .maxstack  2
      .locals init ([0] string str,
               [1] class [mscorlib]System.Text.StringBuilder sb)
      IL_0000:  nop
      IL_0001:  ldstr      "inital value"
      IL_0006:  stloc.0
      IL_0007:  ldstr      "\nsecond value"
      IL_000c:  stloc.0
      IL_000d:  ldstr      "\nthird value"
      IL_0012:  stloc.0
      IL_0013:  newobj     instance void [mscorlib]System.Text.StringBuilder::.ctor()
      IL_0018:  stloc.1
      IL_0019:  ldloc.1
      IL_001a:  ldstr      "initial value"
      IL_001f:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::Append(string)
      IL_0024:  pop
      IL_0025:  ldloc.1
      IL_0026:  ldstr      "second value"
      IL_002b:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::AppendLine(string)
      IL_0030:  pop
      IL_0031:  ldloc.1
      IL_0032:  ldstr      "third value"
      IL_0037:  callvirt   instance class [mscorlib]System.Text.StringBuilder [mscorlib]System.Text.StringBuilder::AppendLine(string)
      IL_003c:  pop
      IL_003d:  ret
    } //end of method Program::Main
    • Ummm … che il codice disassemblato dimostra solo che il puntatore assegnazioni effettuate e metodi vengono chiamati. Ha (quasi) nulla a che fare con il mutevole rispetto immutabile. (Mi sfugge perché alcune persone pensano che lo smontaggio di alcuni irrilevante codice di esempio sta andando per aiutare a capire questo genere di cose. Per cominciare, la maggior parte dei programmatori non sono fluente in codice CLI.)
    • Qualcuno ha ferito.
  7. 6

    Stringhe sono modificabili perché .NET use stringa piscina dietro la scena. Significa :

    string name = "My Country";
    string name2 = "My Country";

    Nome e nome2 riferimento alla stessa locazione di memoria da stringa piscina.
    Ora si supponga di voler modificare nome2 a :

    name2 = "My Loving Country";

    Sarà stringa piscina per la stringa “il Mio amore per il Paese”, se vi saranno mostrati anche il riferimento di altri saggi nuova stringa “il Mio amore per il Paese”, verrà creato nella stringa di piscina e nome2 otterrà riferimento di esso.
    Ma tutto questo processo di “Mio Paese” non è stato modificato a causa di altre variabili come nome è ancora in uso.
    E che è il motivo per cui le stringhe sono IMMUTABILE.

    StringBuilder funziona in modo diverso e non utilizzare la stringa di piscina. Quando si crea un’istanza di StringBuilder :

    var address  = new StringBuilder(500);

    È allocare la memoria blocco di dimensione 500 byte per questa istanza e tutta l’operazione basta modificare questa posizione di memoria e questa memoria non condivisa con altri oggetti. E che è il motivo per cui StringBuilder è MUTEVOLE.

    Spero che sarà di aiuto.

  8. 5

    Nessuno, in realtà. La classe String è mutevole.

    unsafe
    {
        string foo = string.Copy("I am immutable.");
        fixed (char* pChar = foo)
        {
            char* pFoo = pChar;
    
            pFoo[5] = ' ';
            pFoo[6] = ' ';
        }
    
        Console.WriteLine(foo); //"I am   mutable."
    }

    Questo tipo di logica è fatto tutto il tempo Stringa e StringBuilder classi, in realtà. Hanno appena allocare una nuova stringa ogni volta che si chiama Concat, Substring, etc. e l’uso di aritmetica dei puntatori per copiare la nuova stringa. Stringhe semplicemente non mutare se stessi, quindi, perché essi sono considerati “immutabile”.


    Il fatto è non tentativo con valori letterali stringa o si farà male rovinare il vostro programma:

    string bar = "I am a string.";
    
    fixed (char* pChar = bar)
    {
        char* pBar = pChar;
    
        pBar[2] = ' ';
    }
    
    string baz = "I am a string.";
    
    Console.WriteLine(baz); //"I  m a string."

    Questo è perché i valori letterali di stringa sono internati nel desktop .NET Framework; in altre parole, bar e baz punto esattamente con la stessa stringa, così mutando uno possa mutare l’altro. Questo è tutto bene e dandy, però se si sta utilizzando non gestito piattaforma di WinRT, che non manca di stringa in tirocinio.

    • Beh, sì. Se si infrangono le regole, da parte di cracking aperto astrazioni che sono supposti per essere chiuso, quindi quasi niente è immutabile. Si possono fare cose analoghe in Java utilizzando brutto riflessione … ma il JLS afferma che il comportamento che si ottiene è undefined.
  9. 2

    Per chiarire non c’è nessuna tale cosa come un mutevole stringa in C# o .NET in generale). Altre langues supporto mutevole stringhe (string, che possono cambiare) ma la .NET framework non.

    Quindi la risposta corretta alla tua domanda è TUTTE le stringhe sono immutabili in C#.

    stringa ha un significato specifico. “stringa” minuscola parola chiave è semplicemente una scorciatoia per un oggetto istanziato dal Sistema.Classe String. Tutti gli oggetti creati dalla classe string sono SEMPRE immutabile.

    Se si desidera una mutevole rappresentazione di testo, quindi è necessario utilizzare un’altra classe StringBuilder. StringBuilder consente di iterativamente la creazione di una collezione di ‘parole’ e poi convertire in una stringa (ancora una volta immutabile).

  10. 1

    Dati valore non può essere cambiato. Nota: Il valore di una variabile può essere modificato, ma l’originale immutabile valore dei dati è stato scartato e un nuovo valore di dati è stato creato in memoria.

  11. 1

    in dettagli di implementazione.

    CLR2 del Sistema.Stringa è mutevole.
    StringBuilder.Aggiungere la chiamata di Stringa.AppendInplace
    (metodo privato)

    CLR4 del Sistema.Stringa è immutabile.
    StringBuilder hanno array di Char con la suddivisione in blocchi.

  12. 0

    Da http://yassershaikh.com/what-is-the-difference-between-strings-and-stringbuilder-in-c-net/

    Risposta breve : Stringa è immutabile, mentre StringBuilder è mutevole.

    Che cosa significa ?
    Wiki dice : In object-oriented, un immutabile oggetto è un oggetto il cui stato non può essere modificato dopo che è stato creato. Questo è in contrasto con un oggetto mutabile, che può essere modificato dopo che è stato creato.

    Dalla Classe StringBuilder documentazione:

    Oggetto String è immutabile. Ogni volta che si utilizza uno dei metodi nel Sistema.Classe String, si crea un nuovo oggetto stringa in memoria, che richiede una nuova allocazione di spazio per il nuovo oggetto.

    In situazioni in cui è necessario eseguire ripetute modifiche per una stringa, l’overhead associato con la creazione di un nuovo oggetto Stringa può essere costoso.

    Il Sistema.Di testo.Classe StringBuilder può essere utilizzato quando si desidera modificare una stringa senza la creazione di un nuovo oggetto. Per esempio, utilizzando la classe StringBuilder può aumentare le prestazioni quando la concatenazione di due corde insieme in un ciclo.

  13. 0

    Qui è l’esempio per Immutabile stringa e la stringa Mutabile generatore

            Console.WriteLine("Mutable String Builder");
            Console.WriteLine("....................................");
            Console.WriteLine();
            StringBuilder sb = new StringBuilder("Very Good Morning");
            Console.WriteLine(sb.ToString());
            sb.Remove(0, 5);
            Console.WriteLine(sb.ToString());
    
            Console.WriteLine();
    
            Console.WriteLine("Immutable String");
            Console.WriteLine("....................................");
            Console.WriteLine();
            string s = "Very Good Morning";
            Console.WriteLine(s);
            s.Substring(0, 5);
            Console.WriteLine(s);
            Console.ReadLine();
    • Sarebbe molto bello se si può fornire in uscita @Gokul 🙂
    • Sottostringa non cambia il valore sottostante. Restituisce solo un valore.
    • e perché? perché le stringhe sono immutabili 🙂
    • Il 2 linea di codice: s.Substring(0, 5); Console.WriteLine(s); Qui s.substring() non cambia s. questo esempio non mostra se la stringa è immutabile.
  14. 0

    Stringa in C# è immutabile. Se concatenare con qualsiasi stringa, in realtà si sta facendo una nuova stringa, che è nuovo oggetto string !
    Ma StringBuilder crea stringa mutabile.

Lascia un commento