Freigeben über

String.Intern-Methode

  • Artikel

Ruft den Verweis des Systems auf den angegebenen String ab.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Shared Function Intern ( _
    str As String _
) As String
'Usage
Dim str As String
Dim returnValue As String

returnValue = String.Intern(str)

public static string Intern (
    string str
)

public:
static String^ Intern (
    String^ str
)

public static String Intern (
    String str
)

public static function Intern (
    str : String
) : String

Parameter

Rückgabewert

Wenn der Wert von str bereits im Internpool vorhanden ist, wird der Verweis des Systems zurückgegeben, andernfalls wird ein neuer Verweis auf eine Zeichenfolge mit dem Wert von str zurückgegeben.

Ausnahmen

Ausnahmetyp Bedingung

ArgumentNullException

str ist NULL (Nothing in Visual Basic).

Hinweise

Die Common Language Runtime behält den Speicherplatz von Zeichenfolgen durch Verwalten einer Tabelle bei, die als Internpool bezeichnet wird und einen Verweis auf jedes eindeutige Zeichenfolgenliteral enthält, das im Programm deklariert oder programmgesteuert erstellt wurde. Daher ist eine Instanz eines Zeichenfolgenliterals mit einem bestimmten Wert nur einmal im System vorhanden.

Wenn Sie z. B. dasselbe Zeichenfolgenliteral mehreren Variablen zuweisen, ruft die Common Language Runtime denselben Verweis für das Zeichenfolgenliteral aus dem Internpool ab und weist ihn jeder Variablen zu.

Die Intern-Methode verwendet den Internpool zum Suchen einer Zeichenfolge, die dem Wert von str entspricht. Wenn eine solche Zeichenfolge vorhanden ist, wird ihr Verweis im Internpool zurückgegeben. Wenn die Zeichenfolge nicht vorhanden ist, wird dem Internpool ein Verweis auf str hinzugefügt und dann dieser Verweis zurückgegeben.

Im folgenden C#-Beispiel ist die Zeichenfolge s1 mit dem Wert "MyTest" bereits im Internpool vorhanden, da es sich um ein Literal im Programm handelt.

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, die demselben Wert hat wie s2. Da eine solche Zeichenfolge vorhanden ist, gibt die Methode denselben Verweis zurück, der s1 zugeordnet ist. Anschließend wird dieser Verweis s3 zugewiesen.

Die Verweise s1 und s2 sind ungleich, da sie auf unterschiedliche Objekte verweisen, wohingegen die Verweise s1 und s3 gleich sind, 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.

Vergleichen Sie diese Methode mit der IsInterned-Methode.

Versionsaspekte

Ab .NET Framework, Version 2.0, hat sich das Verhalten der Intern-Methode geändert. In der folgenden C#-Codesequenz wird der Variablen str1 ein Verweis auf Empty und der Variablen str2 der Verweis auf Empty zugewiesen, der von der Intern-Methode zurückgegeben wird. Anschließend werden str1 und str2 auf Gleichheit geprüft.

string str1 = String.Empty;
string str2 = String.Intern(String.Empty);
if ((object) str1) == ((object) str2) …

In .NET Framework, Version 1.1, sind str1 und str2 nicht gleich, in .NET Framework, Version 2.0, sind str1 und str2 hingegen gleich.

Leistungsaspekte

Wenn Sie versuchen, die gesamte für die Anwendung reservierte Speichermenge zu verringern, dass das Internalisieren von Zeichenfolgen zwei unerwünschte Nebeneffekte hat. Zunächst wird der für internalisierte String-Objekte reservierte Speicher wahrscheinlich erst nach Beenden der Common Language Runtime (CLR) freigegeben. Der Grund dafür besteht darin, dass der Verweis der CLR auf das internalisierte String-Objekt auch nach Beenden der Anwendung oder sogar der Anwendungsdomäne beibehalten werden kann. Des weiteren muss eine Zeichenfolge zunächst erstellt werden, um internalisiert werden zu können. Der vom String-Objekt verwendete Speicher muss dennoch reserviert werden, auch wenn der Speicher schließlich durch die Garbage Collection freigegeben wird.

Beispiel

Im folgenden Codebeispiel werden drei Zeichenfolgen mit dem gleichen Wert verwendet, um zu bestimmen, ob eine neu erstellte Zeichenfolge und eine internalisierte Zeichenfolge gleich sind.

' Sample for String.Intern(String)
Imports System
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 = '{0}'", s1)
      Console.WriteLine("s2 = '{0}'", s2)
      Console.WriteLine("s3 = '{0}'", s3)
      Console.WriteLine("Is s2 the same reference as s1?: {0}", s2 Is s1)
      Console.WriteLine("Is s3 the same reference as s1?: {0}", s3 Is s1)
   End Sub 'Main
End Class 'Sample
'
'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 == '{0}'", s1);
    Console.WriteLine("s2 == '{0}'", s2);
    Console.WriteLine("s3 == '{0}'", s3);
    Console.WriteLine("Is s2 the same reference as s1?: {0}", (Object)s2==(Object)s1); 
    Console.WriteLine("Is s3 the same reference as s1?: {0}", (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)
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)
import System.*;
import System.Text.*;

class Sample
{
    public static void main(String[] args)
    {
        String s1 = "MyTest";
        String s2 = (new 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}", 
            System.Convert.ToString((Object)s2 == (Object)s1));
        Console.WriteLine("Is s3 the same reference as s1?: {0}", 
            System.Convert.ToString((Object)s3 == (Object)s1));
    } //main
} //Sample
/*
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
*/

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

String-Klasse
String-Member
System-Namespace
IsInterned