Comment obtenir l'adresse d'une variable de référence?

Question

Fondamentalement ici je voudrais montrer les chaînes sont immuables avec un exemple donc j'ai pris l'exemple ci-dessous et je sais que GetHashCode() ne renvoie pas l'adresse mais comment puis-je différencier les deux variables se réfèrent à l'emplacement mémoire différent?

Dans le code ci-dessous je veux l'adresse d'une variable chaîne

 string s = "hello"; 
     Console.WriteLine(s.GetHashCode()); 
     s = s + "User"; 
     Console.WriteLine(s.GetHashCode()); 

Mais dans la chaîne Builder cas GetHashCode() retourne même valeur

 StringBuilder sb = new StringBuilder(); 
     sb.Append("hi"); 
     Console.WriteLine(sb.GetHashCode()); 
     sb.Append("hello"); 
     Console.WriteLine(sb.GetHashCode()); 

Answer 1

utiliser seulement deux variables différentes et object.ReferenceEquals à la place:

string x = "hello"; 
string y = x + "User"; 
Console.WriteLine(ReferenceEquals(x, y)); 

Il est vrai que l'impression juste x et y à ce moment-là montrerait qu'ils » re différent ... comme une légère alternative:

string s = "hello"; 
string original = s; 
Console.WriteLine(ReferenceEquals(s, original)); // True 
s = s + "User"; 
Console.WriteLine(ReferenceEquals(s, original)); // False 

Peut-être que c'est plus proche de ce que vous étiez g pour?

Answer 2

Pour votre exemple donné, vous ne en fait besoin de connaître l'adresse - vous voulez seulement savoir si l'adresse de deux objets est la même.

string s1 = "hi"; 
string s2 = s1; 
Console.WriteLine(object.ReferenceEquals(s1, s2)); // True 
s2 = s2 + " world"; 
Console.WriteLine(object.ReferenceEquals(s1, s2)); // False 

Side Note Fun: object « s == par défaut de l'opérateur à l'aide object.ReferenceEquals(), mais parce string en C# l'emporte sur l'opérateur ==, vérifier l'égalité entre les deux chaînes sera basée sur si les chaînes sont égales. Pour compliquer davantage les choses, le compilateur "interns" toutes les chaînes constantes qu'il peut dire sont exactement égales au moment de la compilation. La combinaison de ces comportements vous laisse avec un comportement vraiment bizarre:

string s1 = "john"; 
object s2 = "john"; 
string s3 = new StringBuilder(s1).ToString(); 
Console.WriteLine(s1 == s2); // True 
Console.WriteLine(s2 == s1); // True 
Console.WriteLine(s1 == s3); // True 
Console.WriteLine(s3 == s1); // True 
Console.WriteLine(s2 == s3); // False 
Console.WriteLine(s3 == s2); // False 

Answer 3

Object.ReferenceEquals(a, b) renvoie false ssi a et b sont des références à différents objets (et donc différentes adresses).

Le code de hachage pour le générateur de chaîne est vraisemblablement construit à partir de l'adresse du générateur de chaîne, et non à partir de la valeur de chaîne qu'il stocke. Par contre,

s + "hello", d'autre part, crée un nouvel objet qui a un code de hachage différent de s.