String.Intern(String) Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ruft den Verweis des Systems auf den angegebenen String ab.

public:
 static System::String ^ Intern(System::String ^ str);

public static string Intern (string str);

static member Intern : string -> string

Public Shared Function Intern (str As String) As String

Parameter

str: String

Eine im Internpool zu suchende Zeichenfolge.

Gibt zurück

String

Der Verweis des Systems auf str, wenn dieser im Internpool vorhanden ist, andernfalls ein neuer Verweis auf eine Zeichenfolge mit dem Wert von str.

Ausnahmen

ArgumentNullException

str ist null.

Beispiele

Im folgenden Beispiel werden drei wertgleiche Zeichenfolgen verwendet, um zu bestimmen, ob eine neu erstellte Zeichenfolge und eine interne Zeichenfolge gleich sind.

// Sample for String::Intern(String)
using namespace System;
using namespace System::Text;
int main()
{
   String^ s1 = "MyTest";
   String^ s2 = (gcnew StringBuilder)->Append( "My" )->Append( "Test" )->ToString();
   String^ s3 = String::Intern( s2 );
   Console::WriteLine( "s1 == '{0}'", s1 );
   Console::WriteLine( "s2 == '{0}'", s2 );
   Console::WriteLine( "s3 == '{0}'", s3 );
   Console::WriteLine( "Is s2 the same reference as s1?: {0}", s2 == s1 );
   Console::WriteLine( "Is s3 the same reference as s1?: {0}", s3 == s1 );
}

/*
This example produces the following results:
s1 == 'MyTest'
s2 == 'MyTest'
s3 == 'MyTest'
Is s2 the same reference as s1?: False
Is s3 the same reference as s1?: True
*/

// Sample for String.Intern(String)
using System;
using System.Text;

class Sample
{
    public static void Main()
    {
        string s1 = "MyTest";
        string s2 = new StringBuilder().Append("My").Append("Test").ToString();
        string s3 = String.Intern(s2);
        Console.WriteLine($"s1 == {s1}");
        Console.WriteLine($"s2 == {s2}");
        Console.WriteLine($"s3 == {s3}");
        Console.WriteLine($"Is s2 the same reference as s1?: {(Object)s2 == (Object)s1}");
        Console.WriteLine($"Is s3 the same reference as s1?: {(Object)s3 == (Object)s1}");
    }
}
/*
This example produces the following results:
s1 == MyTest
s2 == MyTest
s3 == MyTest
Is s2 the same reference as s1?: False
Is s3 the same reference as s1?: True
*/

// Sample for String.Intern(String)
open System
open System.Text

let s1 = "MyTest"
let s2 = StringBuilder().Append("My").Append("Test").ToString()
let s3 = String.Intern s2
printfn $"s1 = {s1}"
printfn $"s2 = {s2}"
printfn $"s3 = {s3}"
printfn $"Is s2 the same reference as s1?: {s2 :> obj = s1 :> obj}"
printfn $"Is s3 the same reference as s1?: {s3 :> obj = s1 :> obj}"
(*
This example produces the following results:
s1 = MyTest
s2 = MyTest
s3 = MyTest
Is s2 the same reference as s1?: False
Is s3 the same reference as s1?: True
*)

Imports System.Text

Class Sample

    Public Shared Sub Main()
        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($"s1 = {s1}")
        Console.WriteLine($"s2 = {s2}")
        Console.WriteLine($"s3 = {s3}")
        Console.WriteLine($"Is s2 the same reference as s1?: {s2 Is s1}")
        Console.WriteLine($"Is s3 the same reference as s1?: {s3 Is s1}")
    End Sub
End Class
'
's1 = MyTest
's2 = MyTest
's3 = MyTest
'Is s2 the same reference as s1?: False
'Is s3 the same reference as s1?: True
'

Hinweise

Die Common Language Runtime behält den Zeichenfolgenspeicher bei, indem eine Tabelle mit dem Namen intern-Pool verwaltet wird, die einen einzelnen Verweis auf jede eindeutige Literalzeichenfolge enthält, die in Ihrem Programm deklariert oder programmgesteuert erstellt wurde. Folglich ist eine instance einer Literalzeichenfolge mit einem bestimmten Wert nur einmal im System vorhanden.

Wenn Sie beispielsweise mehrere Variablen dieselbe Literalzeichenfolge zuweisen, ruft die Runtime denselben Verweis auf die Literalzeichenfolge aus dem intern-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 ihr Verweis im internen Pool zurückgegeben. Wenn die Zeichenfolge nicht vorhanden ist, wird dem intern-Pool ein Verweis str auf hinzugefügt, und dieser Verweis wird zurückgegeben.

Im folgenden Beispiel ist die Zeichenfolge s1, die den Wert "MyTest" aufweist, bereits interniert, da es sich um ein Literal im Programm handelt. Die System.Text.StringBuilder -Klasse generiert ein neues Zeichenfolgenobjekt, das denselben Wert wie s1 aufweist. s2 ist ein Verweis auf diese Zeichenfolge zugewiesen. Die Intern -Methode sucht nach einer Zeichenfolge, die denselben Wert wie s2 aufweist. Da eine solche Zeichenfolge vorhanden ist, gibt die Methode denselben Verweis zurück, der s1 zugewiesen ist. Dieser Verweis wird dann s3 zugewiesen. Verweise s1 und s2 vergleichen ungleich, da sie sich auf verschiedene Objekte beziehen. Verweise 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.

Versionsüberlegungen

Im .NET Framework 3.5 Service Pack 1 wird das Verhalten der Intern Methode in .NET Framework 1.0 und 1.1 in Bezug auf das Internieren der leeren Zeichenfolge wiederhergestellt. Im folgenden Beispiel wird der Variablen str1 ein Verweis auf Emptyzugewiesen, und der Variablen str2 wird der Verweis auf Empty zugewiesen, der zurückgegeben wird, indem die -Methode nach dem Intern Konvertieren eines StringBuilder Objekts, dessen Wert in eine Zeichenfolge ist, aufgerufen wird Empty . Anschließend werden die in str1 und str2 enthaltenen Verweise auf Gleichheit verglichen.

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

Im .NET Framework 2.0 Service Pack 1 und .NET Framework 3.0 str1str2 und sind nicht gleich. In allen anderen Versionen str1str2 und sind gleich.

Überlegungen zur Leistung

Wenn Sie versuchen, die Gesamtmenge des von der Anwendung zugewiesenen Arbeitsspeichers zu reduzieren, beachten Sie, dass das Internieren einer Zeichenfolge zwei unerwünschte Nebenwirkungen hat. Erstens wird der für interne Objekte zugewiesene String Arbeitsspeicher wahrscheinlich erst freigegeben, wenn die Common Language Runtime (CLR) beendet wird. Der Grund dafür ist, dass der Verweis der CLR auf das interne String Objekt beibehalten werden kann, nachdem Ihre Anwendung oder sogar Ihre Anwendungsdomäne beendet wurde. Zweitens müssen Sie zum Internieren einer Zeichenfolge zuerst die Zeichenfolge erstellen. Der vom String Objekt verwendete Arbeitsspeicher muss weiterhin zugewiesen werden, auch wenn der Speicher schließlich mit Müll gesammelt wird.

Das CompilationRelaxations.NoStringInterning Enumerationsmember kennzeichnet eine Assembly, die keine Zeichenfolgenliteral-Internierung erfordert. 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 modulübergreifend interniert.

Gilt für:

Weitere Informationen

IsInterned(String)