String.Intern(String) Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: netstandard.dll

Sestavení:: mscorlib.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Načte odkaz systému na zadaný 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.

Návraty

String

Odkaz systému na str , pokud je interně, v opačném případě nový odkaz na řetězec s hodnotou str .

Výjimky

ArgumentNullException

str je 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ý.

// 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. V důsledku toho instance literálního řetězce s určitou hodnotou v systému existuje pouze jednou.

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

InternMetoda používá fond interně k hledání řetězce, který se rovná hodnotě str . Pokud takový řetězec existuje, vrátí se jeho odkaz ve fondu intern. Pokud řetězec neexistuje, odkaz na str je přidán do fondu interně, pak je tento odkaz vrácen.

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. System.Text.StringBuilderTřída vygeneruje nový objekt String, který má stejnou hodnotu jako S1. Odkaz na tento řetězec je přiřazený S2. InternMetoda vyhledá řetězec, který má stejnou hodnotu jako S2. Protože takový řetězec existuje, metoda vrátí stejný odkaz, který je přiřazený k S1. Tento odkaz se pak přiřadí do 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.

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

Požadavky na verzi

v .NET Framework 3,5 Service Pack 1 se Intern metoda vrátí k chování v .NET Framework 1,0 a 1,1 s ohledem na interning prázdného řetězce. V následujícím příkladu str1 je proměnné přiřazen odkaz Empty a proměnná str2 je přiřazena odkazu, Empty který je vrácen voláním Intern metody po převedení StringBuilder objektu, jehož hodnota je Empty řetězec. Odkazy obsažené v str1 a str2 jsou porovnávány pro rovnost.

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 2,0 Service Pack 1 a .NET Framework 3,0 str1 a str2 se neshodují. Ve všech ostatních verzích str1 a str2 jsou stejné.

Faktory ovlivňující výkon

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. Za prvé je paměť přidělená pro internované String objekty pravděpodobně uvolněna, dokud se modul CLR (Common Language Runtime) neukončí. Důvodem je, že odkaz CLR na interně umístěný String objekt může být zachován po vaší aplikaci, nebo dokonce i vaší doméně aplikace, ukončen. Za druhé, pro učně řetězec, je nutné nejprve vytvořit řetězec. Paměť, kterou objekt používá String , musí být i nadále přidělena, i když bude paměť nakonec uvolněna z paměti.

CompilationRelaxations.NoStringInterningČlen výčtu označuje sestavení jako nevyžadují interning s řetězcovým literálem. Můžete použít NoStringInterning na sestavení pomocí CompilationRelaxationsAttribute atributu. Také při použití Ngen.exe (generátor nativních bitových kopií) ke kompilaci sestavení předem za běhu, řetězce nejsou interně přenášeny mezi moduly.

Platí pro

Viz také

IsInterned(String)