String.Intern(String) Metoda

Definice

Načte odkaz systému na zadaný String.Retrieves the system's reference to the specified String.

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

Parametry

str
String

Řetězec, ve kterém se má hledat ve fondu intern.A string to search for in the intern pool.

Návraty

Odkaz na systém str, pokud je interně. v opačném případě nový odkaz na řetězec s hodnotou str.The system's reference to str, if it is interned; otherwise, a new reference to a string with the value of str.

Výjimky

str je null.str is null.

Příklady

Následující příklad používá tři řetězce, které jsou stejné jako hodnota k určení, zda je nově vytvořený řetězec a interně řetězec shodný.The following example uses three strings that are equal in value to determine whether a newly created string and an interned string are equal.

// 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
*/
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
'

Poznámky

Modul CLR (Common Language Runtime) zachovává úložiště řetězců tím, že udržuje tabulku označovanou jako fond interně, která obsahuje jediný odkaz na každý jedinečný literálový řetězec deklarovaný nebo vytvořený programově v programu.The common language runtime conserves string storage by maintaining a table, called the intern pool, that contains a single reference to each unique literal string declared or created programmatically in your program. V důsledku toho instance literálního řetězce s určitou hodnotou v systému existuje pouze jednou.Consequently, an instance of a literal string with a particular value only exists once in the system.

Například pokud přiřadíte stejný literálový řetězec k několika proměnným, modul runtime načte stejný odkaz na řetězcový literál z fondu internů a přiřadí ho ke každé proměnné.For example, if you assign the same literal string to several variables, the runtime retrieves the same reference to the literal string from the intern pool and assigns it to each variable.

Metoda Intern používá fond interně k hledání řetězce, který se rovná hodnotě str.The Intern method uses the intern pool to search for a string equal to the value of str. Pokud takový řetězec existuje, vrátí se jeho odkaz ve fondu intern.If such a string exists, its reference in the intern pool is returned. Pokud řetězec neexistuje, odkaz na str se přidá do fondu interně, potom se tento odkaz vrátí.If the string does not exist, a reference to str is added to the intern pool, then that reference is returned.

V následujícím příkladu je řetězec S1, který má hodnotu "MyTest", již interně interně, protože se jedná o literál v programu.In the following example, the string s1, which has a value of "MyTest", is already interned because it is a literal in the program. Třída System.Text.StringBuilder generuje nový objekt String, který má stejnou hodnotu jako S1.The System.Text.StringBuilder class generates a new string object that has the same value as s1. Odkaz na tento řetězec je přiřazený S2.A reference to that string is assigned to s2. Metoda Intern vyhledá řetězec, který má stejnou hodnotu jako S2.The Intern method searches for a string that has the same value as s2. Protože takový řetězec existuje, metoda vrátí stejný odkaz, který je přiřazený k S1.Because such a string exists, the method returns the same reference that is assigned to s1. Tento odkaz se pak přiřadí do S3.That reference is then assigned to s3. Odkazy S1 a S2 se neshodují, protože odkazují na různé objekty; odkazuje na porovnání S1 a S3 stejné, protože odkazují na stejný řetězec.References s1 and s2 compare unequal because they refer to different objects; references s1 and s3 compare equal because they refer to the same string.

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.
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.

Porovnejte tuto metodu s metodou IsInterned.Compare this method to the IsInterned method.

Důležité informace o verziVersion Considerations

V .NET Framework 3,5 Service Pack 1.NET Framework 3.5 Service Pack 1se metoda Intern vrátí k chování v .NET Framework 1,0 a 1,1 s ohledem na interning prázdného řetězce.In the .NET Framework 3,5 Service Pack 1.NET Framework 3.5 Service Pack 1, the Intern method reverts to its behavior in the .NET Framework 1.0 and 1.1 with regard to interning the empty string. V následujícím příkladu je proměnné str1 přiřazen odkaz na Emptya proměnná str2 je přiřazena odkaz na Empty, který je vrácen voláním metody Intern po převedení objektu StringBuilder, jehož hodnota je Empty na řetězec.In the following example, the variable str1 is assigned a reference to Empty, and the variable str2 is assigned the reference to Empty that is returned by calling the Intern method after converting a StringBuilder object whose value is Empty to a string. Odkazy obsažené v str1 a str2 jsou porovnávány pro rovnost.Then the references contained in str1 and str2 are compared for equality.

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.");
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	

V .NET Framework 1.0.NET Framework 1.0jsou .NET Framework 1.1.NET Framework 1.1a .NET Framework 3.5 SP1.NET Framework 3.5 SP1str1 a str2 stejné.In the .NET Framework 1.0.NET Framework 1.0, .NET Framework 1.1.NET Framework 1.1, and .NET Framework 3.5 SP1.NET Framework 3.5 SP1, str1 and str2 are equal. V .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 a .NET Framework 3.0.NET Framework 3.0nejsou str1 a str2 stejné.In the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 and .NET Framework 3.0.NET Framework 3.0, str1 and str2 are not equal.

Faktory ovlivňující výkonPerformance Considerations

Pokud se snažíte snížit celkovou velikost paměti, kterou vaše aplikace přiděluje, pamatujte, že interning String má dva nežádoucí vedlejší účinky.If you are trying to reduce the total amount of memory your application allocates, keep in mind that interning a string has two unwanted side effects. Za prvé je paměť přidělená pro interně String objekty pravděpodobně uvolněna, dokud se modul CLR (Common Language Runtime) neukončí.First, the memory allocated for interned String objects is not likely to be released until the common language runtime (CLR) terminates. Důvodem je, že odkaz CLR na interně String objekt může zachovat po vaší aplikaci, nebo dokonce i vaší doméně aplikace, ukončen.The reason is that the CLR's reference to the interned String object can persist after your application, or even your application domain, terminates. Za druhé, pro učně řetězec, je nutné nejprve vytvořit řetězec.Second, to intern a string, you must first create the string. Paměť, kterou používá objekt String, musí být i nadále přidělena, i když paměť bude nakonec uvolněna z paměti.The memory used by the String object must still be allocated, even though the memory will eventually be garbage collected.

.NET Framework verze 2,0 zavádí CompilationRelaxations.NoStringInterning člen výčtu.The .NET Framework version 2.0 introduces the CompilationRelaxations.NoStringInterning enumeration member. Člen NoStringInterning označí sestavení jako nevyžadují interning s řetězcovým literálem.The NoStringInterning member marks an assembly as not requiring string-literal interning. NoStringInterning můžete použít na sestavení pomocí atributu CompilationRelaxationsAttribute.You can apply NoStringInterning to an assembly using the CompilationRelaxationsAttribute attribute. Také při použití nástroje Ngen. exe (generátor nativních bitových kopií) pro zkompilování sestavení před časem spuštění nejsou řetězce interně přenášeny mezi moduly.Also, when you use the Ngen.exe (Native Image Generator) to compile an assembly in advance of run time, strings are not interned across modules.

Platí pro

Viz také