String.Intern(String) Metódus

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

Paraméterek

Válaszok

A rendszer hivatkozása str, ha az internálva van; ellenkező esetben egy új hivatkozás egy sztringre, amelynek értéke a következő str.

Kivételek

Példák

Az alábbi példa két azonos értékű sztringet hoz létre, és azt mutatja be, hogy az internálásuk ugyanazt a hivatkozást eredményezi.

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

class Sample
{
    public static void Main()
    {
        string s1 = new StringBuilder().Append("My").Append("Test").ToString();
        string s2 = new StringBuilder().Append("My").Append("Test").ToString();
        Console.WriteLine($"s1 == {s1}");
        Console.WriteLine($"s2 == {s2}");
        Console.WriteLine($"Are s1 and s2 equal in value? {s1 == s2}");
        Console.WriteLine($"Are s1 and s2 the same reference? {Object.ReferenceEquals(s1, s2)}");

        string i1 = String.Intern(s1);
        string i2 = String.Intern(s2);
        Console.WriteLine($"After interning:");
        Console.WriteLine($"  Are i1 and i2 equal in value? {i1 == i2}");
        Console.WriteLine($"  Are i1 and i2 the same reference? {Object.ReferenceEquals(i1, i2)}");
    }
}
/*
This example produces the following results:
s1 == MyTest
s2 == MyTest
Are s1 and s2 equal in value? True
Are s1 and s2 the same reference? False
After interning:
  Are i1 and i2 equal in value? True
  Are i1 and i2 the same reference? True
*/

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

let s1 = StringBuilder().Append("My").Append("Test").ToString()
let s2 = StringBuilder().Append("My").Append("Test").ToString()
printfn $"s1 = {s1}"
printfn $"s2 = {s2}"
printfn $"Are s1 and s2 equal in value? {s1 = s2}"
printfn $"Are s1 and s2 the same reference? {Object.ReferenceEquals(s1, s2)}"

let i1 = String.Intern s1
let i2 = String.Intern s2
printfn "After interning:"
printfn $"  Are i1 and i2 equal in value? {i1 = i2}"
printfn $"  Are i1 and i2 the same reference? {Object.ReferenceEquals(i1, i2)}"
(*
This example produces the following results:
s1 = MyTest
s2 = MyTest
Are s1 and s2 equal in value? True
Are s1 and s2 the same reference? False
After interning:
  Are i1 and i2 equal in value? True
  Are i1 and i2 the same reference? True
*)

Imports System.Text

Class Sample

    Public Shared Sub Run()
        Dim s1 As String = New StringBuilder().Append("My").Append("Test").ToString()
        Dim s2 As String = New StringBuilder().Append("My").Append("Test").ToString()
        Console.WriteLine($"s1 = {s1}")
        Console.WriteLine($"s2 = {s2}")
        Console.WriteLine($"Are s1 and s2 equal in value? {s1 = s2}")
        Console.WriteLine($"Are s1 and s2 the same reference? {s1 Is s2}")

        Dim i1 As String = String.Intern(s1)
        Dim i2 As String = String.Intern(s2)
        Console.WriteLine("After interning:")
        Console.WriteLine($"  Are i1 and i2 equal in value? {i1 = i2}")
        Console.WriteLine($"  Are i1 and i2 the same reference? {i1 Is i2}")
    End Sub
End Class
'
's1 = MyTest
's2 = MyTest
'Are s1 and s2 equal in value? True
'Are s1 and s2 the same reference? False
'After interning:
'  Are i1 and i2 equal in value? True
'  Are i1 and i2 the same reference? True
'

Megjegyzések

! [MEGJEGYZÉS] > Bár String.Intern garantálja, hogy két azonos értékű sztring ugyanazt az internált hivatkozást adja vissza, nem garantálja, hogy a visszaadott hivatkozás megegyezik a sztringkonstanssal.

        The common language runtime maintains a table, called the *intern pool*, that holds a single reference for each unique string value. The <xref:System.String.Intern*> method uses the intern pool to search for a string equal to the value of `str`. If no such string exists, a reference to `str` is added to the pool, and that reference is returned. (In contrast, the <xref:System.String.IsInterned(System.String)> method returns a null reference if the requested string doesn't exist in the intern pool.)

A futtatókörnyezet használhatja a belső tárat a sztringtároló megtakarítására. Azonban a karakterlánc literálok automatikus internálása nem garantált—attól függően, hogy hogyan lett az assembly lefordítva és végrehajtva, előfordulhat, hogy egyes literálok nem lesznek hozzáadva a tárhoz.

Az alábbi példában a sztring s1 értéke "MyTest". Az System.Text.StringBuilder osztály létrehoz egy új sztringobjektumot, amely ugyanolyan értékkel rendelkezik, mint a s1. Az adott sztringre mutató hivatkozás kerül hozzárendelésre a s2-hez. A Intern metódus egy olyan sztringet keres, amelynek ugyanaz az értéke, mint a s2. Ha s1 már internálták (például azért, mert a szerelvény sztringkonstans-internálást igényel), a metódus ugyanazt a hivatkozást adja vissza, mint s1, amelyet hozzárendelnek s3-höz, és így s1 és s3 egyenlőként hasonlítható össze. Ellenkező esetben egy új internált bejegyzés jön létre s2 számára és hozzárendelődik s3, és s1 és s3 összehasonlítása nem egyenlő. Mindkét esetben a s1 és a s2 nem egyenlők, mert különböző objektumokra hivatkoznak.

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.

Teljesítménnyel kapcsolatos szempontok

Ha csökkenteni szeretné az alkalmazás által lefoglalt memória teljes mennyiségét, vegye figyelembe, hogy a sztringek internálásának két nemkívánatos mellékhatása van. Először is, az internált String objektumok számára lefoglalt memória valószínűleg nem lesz felszabadítva, amíg a közös nyelvi futtatókörnyezet (CLR) le nem áll. Ennek az az oka, hogy a CLR az internált String objektumra való hivatkozása az alkalmazás vagy akár az alkalmazástartomány leállása után is megmaradhat. Másodszor, egy lánc beiktatásához először létre kell hoznia a láncot. Az objektum által String használt memóriát továbbra is lefoglalni kell, annak ellenére, hogy a memória végül szemétgyűjtés tárgya lesz.

Az CompilationRelaxations.NoStringInterning enumerálási tag a szerelvényt sztringkonstans-internálást nem igénylőként jelöli meg. Alapértelmezés szerint a C# fordító minden egyes assembly-ben kibocsát egy CompilationRelaxationsAttribute jelölőt a NoStringInterning zászlóval a jobb teljesítmény érdekében, ami azt jelenti, hogy nem garantált, hogy a sztringlitterálok hozzáadásra kerülnek az internálási tárhoz. Az NoStringInterning szerelvényt az CompilationRelaxationsAttribute attribútum használatával testre szabhatja.

Ha egy alkalmazást natív AOT használatával tesz közzé, akkor a NoStringInterning kikapcsolása nem támogatott. Natív AOT esetén a szövegkonstansok nem feltétlenül lesznek hozzáadva az internálási tárhelyhez, ezért Intern előfordulhat, hogy nem talál egyezést egy olyan karakterlánchoz, amely a forráskódban konstansnak tűnik.

Lásd még

• IsInterned(String)