String.Intern(String) Methode

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

Parameters

Retouren

De verwijzing van het systeem naar , als het is geïnterneerd str; anders een nieuwe verwijzing naar een tekenreeks met de waarde van str.

Uitzonderingen

Voorbeelden

In het volgende voorbeeld worden twee tekenreeksen met gelijke waarden gemaakt en wordt gedemonstreert dat het interneren van deze tekenreeksen dezelfde verwijzing oplevert.

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

Opmerkingen

! [OPMERKING] > Hoewel String.Intern wordt gegarandeerd dat twee tekenreeksen met gelijke waarden dezelfde interne verwijzing retourneren, wordt niet gegarandeerd dat de geretourneerde verwijzing hetzelfde is als een letterlijke tekenreeks.

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

De interne pool kan door de runtime worden gebruikt om tekenreeksopslag te besparen. Automatische internering van letterlijke tekenreeksen wordt echter niet gegarandeerd, afhankelijk van de manier waarop de assembly is gecompileerd en uitgevoerd, sommige letterlijke gegevens worden mogelijk niet toegevoegd aan de pool.

In het volgende voorbeeld heeft de tekenreeks s1 de waarde 'MyTest'. De System.Text.StringBuilder klasse genereert een nieuw tekenreeksobject met dezelfde waarde als s1. Er wordt een verwijzing naar die tekenreeks toegewezen aan s2. De Intern methode zoekt naar een tekenreeks met dezelfde waarde als s2. Als s1 al geïnterneerd was (bijvoorbeeld omdat de assembly internering van letterlijke tekenreeksen vereist), retourneert de methode dezelfde verwijzing als s1, die vervolgens wordt toegewezen aan s3, en s1 en s3 zijn gelijk. Anders wordt er een nieuwe interne vermelding gemaakt voor s2 en toegewezen aan s3, en s1 en s3 vergelijken ongelijk. In beide gevallen vergelijken s1 en s2 ongelijk omdat ze naar verschillende objecten verwijzen.

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.

Prestatie-overwegingen

Als u de totale hoeveelheid geheugen wilt verminderen die uw toepassing toewijst, moet u er rekening mee houden dat het interneren van een tekenreeks twee ongewenste bijwerkingen heeft. Ten eerste wordt het geheugen dat is toegewezen voor interne String objecten waarschijnlijk pas vrijgegeven als de COMMON Language Runtime (CLR) wordt beëindigd. De reden hiervoor is dat de verwijzing van de CLR naar het interne String object kan blijven bestaan nadat uw toepassing, of zelfs uw toepassingsdomein, wordt beëindigd. Ten tweede, om een string te internaliseren, moet je eerst de string creëren. Het geheugen dat door het String object wordt gebruikt, moet nog steeds worden toegewezen, ook al zal het uiteindelijk door de vuilnisbakverzameling worden verzameld.

Het CompilationRelaxations.NoStringInterning opsommingslid markeert een assembly als een waarbij geen tekenreeksinternering is vereist. Standaard verzendt de C#-compiler een CompilationRelaxationsAttribute vlag met de NoStringInterning vlag op elke assembly voor betere prestaties, wat betekent dat letterlijke tekenreeksen niet gegarandeerd aan de interne pool worden toegevoegd. U kunt NoStringInterning op een assembly aanpassen met behulp van het CompilationRelaxationsAttribute kenmerk.

Wanneer u een app publiceert met systeemeigen AOT, wordt het uitschakelen NoStringInterning niet ondersteund. Met "native AOT" is het niet gegarandeerd dat letterlijke tekenreeksen worden toegevoegd aan de interne pool, dus Intern kan mogelijk geen overeenkomst vinden voor een tekenreeks die in de broncode als letterlijk lijkt.

Zie ook

• IsInterned(String)