Assignation de la chaîne en C#

quelle fonctionnalité de langue les chaînes de caractères utilisent-elles pour les garder immuables?

Ce n'est pas une fonctionnalité du langage. C'est la façon dont la classe est définie.

Par exemple,

class Integer {
    private readonly int value;

    public int Value { get { return this.value; } }
    public Integer(int value) { this.value = value; } }
    public Integer Add(Integer other) {
        return new Integer(this.value + other.value);
    }
}

est comme int sauf que c'est un type de référence, mais il est immuable. Nous défini. On peut le Définir comme mutable aussi:

class MutableInteger {
    private int value;

    public int Value { get { return this.value; } }
    public MutableInteger(int value) { this.value = value; } }
    public MutableInteger Add(MutableInteger other) {
        this.value = this.value + other.value;
        return this;
    } 
}

Voir?

je ne comprends pas ce langage fait une copie de valueA quand je l'attribuer à valueB.

Il ne copie pas les string, il copie la référence. stringtype de référence. Cela signifie que les variables de type string s sont des lieux de stockage dont les valeurs sont des références. Dans ce cas, leurs valeurs sont des références à des instances de string. Lorsque vous assignez une variable de type string à l'autre de type string, la valeur est copiée. Dans ce cas, la valeur est une référence et il est copié par l' affectation. C'est vrai pour n'importe quel type de référence, pas seulement string ou seulement des types de référence immuables.

Ou peut-être, la référence à valueA ne change pas lorsque je l'attribuer à valueB, seulement valueA obtient une nouvelle référence à lui-même quand je mets la chaîne.

Non, les valeurs de valueA et valueB reportez-vous à la même instance de string. Leurs valeurs sont des références, et ces valeurs sont égales. Si vous pouviez en quelque sorte muter^* l'instance de string visées par valueA, le référent des deux valueA et valueB verrait cette mutation.

Comme c'est un type d'instance, je ne comprends pas pourquoi cela fonctionne.

il n'existe pas de type d'instance.

en gros, string s sont des types de référence. Mais string sont immuables. Lorsque vous muter un string, ce qui se passe est que vous obtenez une référence à une nouvelle chaîne qui est le résultat de la mutation vers le déjà existant string.

string s = "hello, world!";
string t = s;
string u = s.ToUpper();

Ici s et t sont des variables dont les valeurs se réfèrent à la même instance de string. Le referrent de s n'est pas muté par l'appel à String.ToUpper. Au lieu de cela, s.ToUpper fait une mutation du référent de s et renvoie une référence à une instance de string qu'il crée dans le processus d'appliquer la mutation. Nous attribuons cette référence à u.

je comprends que vous ne pouvez surcharge, par exemple, l' == et != opérateurs, mais je ne semble pas trouver de documentation sur la surcharge des opérateurs=.

Vous ne pouvez pas surcharger =.

^* Vous pouvez, avec quelques astuces. Les ignorer.