String.Intern(String) Méthode

Définition

Récupère la référence du système au String spécifié.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

Paramètres

str
String

Chaîne à rechercher dans le pool interne.A string to search for in the intern pool.

Retours

Référence du système à str si elle se trouve dans le pool interne, sinon, nouvelle référence à une chaîne ayant la valeur str.The system's reference to str, if it is interned; otherwise, a new reference to a string with the value of str.

Exceptions

str est null.str is null.

Exemples

L’exemple suivant utilise trois chaînes qui sont égales en valeur pour déterminer si une chaîne nouvellement créée et une chaîne internée sont égales.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
'

Remarques

Le common language runtime conserve le stockage de chaînes en conservant une table, appelée pool interne, qui contient une référence unique à chaque chaîne littérale unique déclarée ou créée par programme dans votre programme.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. Par conséquent, une instance d’une chaîne littérale avec une valeur particulière n’existe qu’une seule fois dans le système.Consequently, an instance of a literal string with a particular value only exists once in the system.

Par exemple, si vous assignez la même chaîne littérale à plusieurs variables, le runtime récupère la même référence à la chaîne littérale à partir du pool interne et l’assigne à chaque variable.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.

La méthode Intern utilise le pool interne pour rechercher une chaîne égale à la valeur de str.The Intern method uses the intern pool to search for a string equal to the value of str. Si une telle chaîne existe, sa référence dans le pool interne est retournée.If such a string exists, its reference in the intern pool is returned. Si la chaîne n’existe pas, une référence à str est ajoutée au pool interne, puis cette référence est retournée.If the string does not exist, a reference to str is added to the intern pool, then that reference is returned.

Dans l’exemple suivant, la chaîne S1, qui a la valeur « MyTest », est déjà internée, car il s’agit d’un littéral dans le programme.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 classe System.Text.StringBuilder génère un nouvel objet String ayant la même valeur que S1.The System.Text.StringBuilder class generates a new string object that has the same value as s1. Une référence à cette chaîne est assignée à S2.A reference to that string is assigned to s2. La méthode Intern recherche une chaîne ayant la même valeur que S2.The Intern method searches for a string that has the same value as s2. Comme une telle chaîne existe, la méthode retourne la même référence qui est assignée à S1.Because such a string exists, the method returns the same reference that is assigned to s1. Cette référence est ensuite assignée à S3.That reference is then assigned to s3. Les références S1 et S2 ne sont pas comparées, car elles font référence à des objets différents ; les références S1 et S3 sont égales, car elles font référence à la même chaîne.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.

Comparez cette méthode à la méthode IsInterned.Compare this method to the IsInterned method.

Considérations sur la versionVersion Considerations

Dans le .NET Framework 3,5 Service Pack 1.NET Framework 3.5 Service Pack 1, la méthode Intern revient à son comportement dans la .NET Framework 1,0 et 1,1 en ce qui concerne l’interning de la chaîne vide.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. Dans l’exemple suivant, une référence à Emptyest assignée à la variable str1, et la variable str2 est assignée à la référence à Empty qui est retournée en appelant la méthode Intern après la conversion d’un objet StringBuilder dont la valeur est Empty en chaîne.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. Les références contenues dans str1 et str2 sont comparées pour déterminer leur égalité.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	

Dans les .NET Framework 1.0.NET Framework 1.0, .NET Framework 1.1.NET Framework 1.1et .NET Framework 3.5 SP1.NET Framework 3.5 SP1, str1 et str2 sont égaux.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. Dans les .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1 et .NET Framework 3.0.NET Framework 3.0, str1 et str2 ne sont pas égaux.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.

Considérations sur les performancesPerformance Considerations

Si vous essayez de réduire la quantité totale de mémoire allouée par votre application, gardez à l’esprit que l’interning d’une chaîne a deux effets secondaires indésirables.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. Premièrement, la mémoire allouée pour les objets String internés n’est pas susceptible d’être libérée tant que le common language runtime (CLR) ne s’est pas terminé.First, the memory allocated for interned String objects is not likely to be released until the common language runtime (CLR) terminates. La raison en est que la référence du CLR à l’objet de String interne peut persister après l’arrêt de votre application, ou même votre domaine d’application.The reason is that the CLR's reference to the interned String object can persist after your application, or even your application domain, terminates. Deuxièmement, pour internier une chaîne, vous devez d’abord créer la chaîne.Second, to intern a string, you must first create the string. La mémoire utilisée par l’objet String doit toujours être allouée, même si la mémoire est finalement récupérée par le garbage collector.The memory used by the String object must still be allocated, even though the memory will eventually be garbage collected.

La version de .NET Framework 2,0 introduit le membre de l’énumération CompilationRelaxations.NoStringInterning.The .NET Framework version 2.0 introduces the CompilationRelaxations.NoStringInterning enumeration member. Le membre NoStringInterning marque un assembly comme ne nécessitant pas l’Internation de littéral de chaîne.The NoStringInterning member marks an assembly as not requiring string-literal interning. Vous pouvez appliquer des NoStringInterning à un assembly à l’aide de l’attribut CompilationRelaxationsAttribute.You can apply NoStringInterning to an assembly using the CompilationRelaxationsAttribute attribute. En outre, lorsque vous utilisez Ngen. exe (Native Image Generator) pour compiler un assembly avant l’exécution, les chaînes ne sont pas internées entre les modules.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.

S’applique à

Voir aussi