System.String.Intern-Methode

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Die Common Language Runtime spart Zeichenfolgenspeicher, indem Standard eine Tabelle, die als Internpool bezeichnet wird, enthalten, die einen einzelnen Verweis auf jede eindeutige Literalzeichenfolge enthält, die in Ihrem Programm deklariert oder programmgesteuert erstellt wurde. Folglich ist eine Instanz einer Literalzeichenfolge mit einem bestimmten Wert nur einmal im System vorhanden.

Wenn Sie beispielsweise mehrere Variablen dieselbe Literalzeichenfolge zuweisen, ruft die Laufzeit denselben Verweis auf die Literalzeichenfolge aus dem internen Pool ab und weist sie jeder Variablen zu.

Die Intern Methode verwendet den intern-Pool, um nach einer Zeichenfolge zu suchen, die dem Wert von strentspricht. Wenn eine solche Zeichenfolge vorhanden ist, wird der Verweis im internen Pool zurückgegeben. Wenn die Zeichenfolge nicht vorhanden ist, wird ein Verweis str auf den intern-Pool hinzugefügt, und dieser Verweis wird zurückgegeben.

Im folgenden Beispiel ist die Zeichenfolge "s1", die den Wert "MyTest" aufweist, bereits interniert, da sie ein Literal im Programm ist. Die System.Text.StringBuilder Klasse generiert ein neues Zeichenfolgenobjekt mit demselben Wert wie s1. Ein Verweis auf diese Zeichenfolge wird s2 zugewiesen. Die Intern Methode sucht nach einer Zeichenfolge mit demselben Wert wie s2. Da eine solche Zeichenfolge vorhanden ist, gibt die Methode denselben Verweis zurück, der s1 zugewiesen ist. Dieser Verweis wird dann s3 zugewiesen. Bezüge s1 und s2 vergleichen ungleich, da sie auf verschiedene Objekte verweisen; Bezüge s1 und s3 vergleichen gleich, da sie auf dieselbe Zeichenfolge verweisen.

string s1 = "MyTest"; 
string s2 = new StringBuilder().Append("My").Append("Test").ToString(); 
string s3 = String.Intern(s2); 
Console.WriteLine((Object)s2==(Object)s1); // Different references.
Console.WriteLine((Object)s3==(Object)s1); // The same reference.

let s1 = "MyTest"
let s2 = StringBuilder().Append("My").Append("Test").ToString()
let s3 = String.Intern s2
printfn $"{s2 :> obj = s1 :> obj}" // Different references.
printfn $"{s3 :> obj = s1 :> obj}" // The same reference.

Dim s1 As String = "MyTest" 
Dim s2 As String = New StringBuilder().Append("My").Append("Test").ToString() 
Dim s3 As String = String.Intern(s2) 
Console.WriteLine(CObj(s2) Is CObj(s1))      ' Different references.
Console.WriteLine(CObj(s3) Is CObj(s1))      ' The same reference.

Vergleichen Sie diese Methode mit der IsInterned Methode.

Im folgenden Beispiel wird der Variablen str1 ein Verweis String.Emptyzugewiesen, und die Variable str2 wird dem Verweis String.Empty zugewiesen, der durch Aufrufen der Intern Methode zurückgegeben wird, nachdem ein StringBuilder Objekt konvertiert wurde, dessen Wert in eine Zeichenfolge ist String.Empty . Anschließend werden die darin str1 enthaltenen Und str2 werden für die Gleichheit verglichen. str1 und str2 sind gleich.

string str1 = String.Empty;
string str2 = String.Empty;

StringBuilder sb = new StringBuilder().Append(String.Empty);
str2 = String.Intern(sb.ToString());

if ((object)str1 == (object)str2)
    Console.WriteLine("The strings are equal.");
else
    Console.WriteLine("The strings are not equal.");

let str1 = String.Empty
let str2 = String.Empty

let sb = StringBuilder().Append String.Empty
let str3 = String.Intern(string sb)

if (str1 :> obj) = (str3 :> obj) then
    printfn "The strings are equal."
else
    printfn "The strings are not equal."

Dim str1 As String = String.Empty
Dim str2 As String = String.Empty

Dim sb As StringBuilder = New StringBuilder().Append(String.Empty)
str2 = String.Intern(sb.ToString())

If CObj(str1) Is CObj(str2) Then
    Console.WriteLine("The strings are equal.")
Else
    Console.WriteLine("The strings are not equal.")
End If

Überlegungen zur Leistung

Wenn Sie versuchen, die Gesamtmenge des Arbeitsspeichers zu reduzieren, den Ihre Anwendung zuweist, denken Sie daran, dass das Internieren einer Zeichenfolge zwei unerwünschte Nebenwirkungen hat. Zunächst wird der für interne Objekte zugewiesene String Speicher wahrscheinlich erst freigegeben, wenn die Common Language Runtime (CLR) beendet wird. Der Grund dafür ist, dass der CLR-Verweis auf das interne String Objekt nach der Anwendung beibehalten werden kann, oder sogar ihre Anwendung Standard beendet wird. Zweitens müssen Sie zuerst die Zeichenfolge erstellen, um eine Zeichenfolge zu internieren. Der vom String Objekt verwendete Speicher muss weiterhin zugewiesen werden, obwohl der Speicher schließlich garbage collection wird.

Das Enumerationsmemmembe CompilationRelaxations.NoStringInterning kennzeichnet eine Assembly als keine Zeichenfolgenliteral-Internierung. Sie können mit dem CompilationRelaxationsAttribute Attribut auf eine Assembly anwendenNoStringInterning. Wenn Sie Ngen.exe (Native Image Generator) verwenden, um eine Assembly vor der Laufzeit zu kompilieren, werden Zeichenfolgen nicht über Module hinweg interniert.