String.Intern(String) String.Intern(String) String.Intern(String) String.Intern(String) Method

Definizione

Recupera il riferimento del sistema all'oggetto String specificato.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

Parametri

str
String String String String

Stringa da cercare nel pool di centralizzazione.A string to search for in the intern pool.

Restituisce

Riferimento del sistema a str, se è centralizzato; in caso contrario, nuovo riferimento a una stringa con il valore di str.The system's reference to str, if it is interned; otherwise, a new reference to a string with the value of str.

Eccezioni

Esempi

Nell'esempio seguente vengono usate tre stringhe equivalenti al valore per determinare se una stringa appena creata e una stringa interna sono uguali.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
'

Commenti

Il Common Language Runtime conserva l'archiviazione di stringhe gestendo una tabella, denominata pool di Intern, che contiene un singolo riferimento a ogni stringa letterale univoca dichiarata o creata a livello di codice nel programma.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. Di conseguenza, un'istanza di una stringa letterale con un determinato valore esiste solo una volta nel sistema.Consequently, an instance of a literal string with a particular value only exists once in the system.

Se ad esempio si assegna la stessa stringa letterale a diverse variabili, il runtime recupera lo stesso riferimento alla stringa letterale dal pool di Intern e lo assegna a ogni variabile.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.

Il Intern metodo usa il pool di Intern per cercare una stringa uguale al valore di str.The Intern method uses the intern pool to search for a string equal to the value of str. Se tale stringa esiste, viene restituito il relativo riferimento nel pool di Intern.If such a string exists, its reference in the intern pool is returned. Se la stringa non esiste, viene aggiunto un riferimento str a al pool di Intern, quindi viene restituito il riferimento.If the string does not exist, a reference to str is added to the intern pool, then that reference is returned.

Nell'esempio seguente la stringa s1, che ha il valore "test", è già interna perché è un valore letterale nel programma.In the following example, the string s1, which has a value of "MyTest", is already interned because it is a literal in the program. La System.Text.StringBuilder classe genera un nuovo oggetto stringa con lo stesso valore di S1.The System.Text.StringBuilder class generates a new string object that has the same value as s1. Un riferimento a tale stringa viene assegnato a S2.A reference to that string is assigned to s2. Il Intern metodo cerca una stringa con lo stesso valore di S2.The Intern method searches for a string that has the same value as s2. Poiché tale stringa esiste, il metodo restituisce lo stesso riferimento assegnato a S1.Because such a string exists, the method returns the same reference that is assigned to s1. Tale riferimento viene quindi assegnato a S3.That reference is then assigned to s3. Fa riferimento a un confronto S1 e S2 non uguale perché si riferiscono a oggetti diversi. fa riferimento al confronto S1 e S3 uguale perché si riferiscono alla stessa stringa.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.

Confrontare questo metodo con il IsInterned metodo.Compare this method to the IsInterned method.

Considerazioni sulla versioneVersion Considerations

.NET Framework 3.5 Service Pack 1.NET Framework 3.5 Service Pack 1 Inilmetodoripristinailpropriocomportamentonell'.NETFramework1,0e1,1perquantoriguardalagestioneIntern interna della stringa vuota.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. Nell' str1 esempio seguente alla variabile viene assegnato un riferimento a Emptye alla variabile str2 viene assegnato il riferimento a Empty restituito chiamando il metodo dopo la Intern conversione di un oggetto StringBuilderoggetto il cui valore Empty è a una stringa.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. Quindi, i riferimenti contenuti str1 in str2 e vengono confrontati per verificarne l'uguaglianza.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	

.NET Framework 1.0.NET Framework 1.0In, .NET Framework 1.1.NET Framework 1.1, e .NET Framework 3.5 SP1.NET Framework 3.5 SP1, estr1 sonougualistr2 .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. .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 In e .NET Framework 3.0.NET Framework 3.0, str1 e nonsonouguali.str2In 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.

Considerazioni sulle prestazioniPerformance Considerations

Se si sta tentando di ridurre la quantità totale di memoria allocata dall'applicazione, tenere presente che la centralizzazione di una stringa ha due effetti collaterali indesiderati.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. In primo luogo, è probabile che la String memoria allocata per gli oggetti interni non venga rilasciata finché non viene terminata la Common Language Runtime (CLR).First, the memory allocated for interned String objects is not likely to be released until the common language runtime (CLR) terminates. Il motivo è che il riferimento di CLR all' String oggetto centralizzato può essere mantenuto dopo la terminazione dell'applicazione o anche del dominio dell'applicazione.The reason is that the CLR's reference to the interned String object can persist after your application, or even your application domain, terminates. In secondo luogo, è necessario creare prima di tutto una stringa.Second, to intern a string, you must first create the string. La memoria utilizzata dall' String oggetto deve comunque essere allocata, anche se la memoria verrà sottoposta a Garbage Collection.The memory used by the String object must still be allocated, even though the memory will eventually be garbage collected.

Il .NET Framework versione 2,0 introduce il CompilationRelaxations.NoStringInterning membro di enumerazione.The .NET Framework version 2.0 introduces the CompilationRelaxations.NoStringInterning enumeration member. Il NoStringInterning membro contrassegna un assembly in modo che non richieda la centralizzazione dei valori letterali stringa.The NoStringInterning member marks an assembly as not requiring string-literal interning. È possibile applicare NoStringInterning a un assembly usando l' CompilationRelaxationsAttribute attributo.You can apply NoStringInterning to an assembly using the CompilationRelaxationsAttribute attribute. Inoltre, quando si usa NGen. exe (Generatore di immagini native) per compilare un assembly in anticipo rispetto alla fase di esecuzione, le stringhe non vengono internamente tra i moduli.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.

Si applica a

Vedi anche