String.IsInterned(String) Methode

public:
 static System::String ^ IsInterned(System::String ^ str);

public static string? IsInterned(string str);

public static string IsInterned(string str);

static member IsInterned : string -> string

Public Shared Function IsInterned (str As String) As String

Parameter

Gibt zurück

Ein Verweis daraufstr, ob er sich im internen Pool der Common Language Runtime befindet; andernfalls . null

Ausnahmen

Beispiele

Im folgenden Beispiel wird veranschaulicht, dass Literalzeichenfolgen automatisch vom Compiler interniert werden.

// Sample for String.IsInterned(String)
using System;
using System.Text;
using System.Runtime.CompilerServices;

// In the .NET Framework 2.0 the following attribute declaration allows you to
// avoid the use of the interning when you use NGEN.exe to compile an assembly
// to the native image cache.
[assembly: CompilationRelaxations(CompilationRelaxations.NoStringInterning)]
class Sample
{
    public static void Main()
    {
        // String str1 is known at compile time, and is automatically interned.
        String str1 = "abcd";

        // Constructed string, str2, is not explicitly or automatically interned.
        String str2 = new StringBuilder().Append("wx").Append("yz").ToString();
        Console.WriteLine();
        Test(1, str1);
        Test(2, str2);
    }

    public static void Test(int sequence, String str)
    {
        Console.Write("{0}) The string, '", sequence);
        String strInterned = String.IsInterned(str);
        if (strInterned == null)
            Console.WriteLine("{0}', is not interned.", str);
        else
            Console.WriteLine("{0}', is interned.", strInterned);
    }
}

//This example produces the following results:

//1) The string, 'abcd', is interned.
//2) The string, 'wxyz', is not interned.

//If you use NGEN.exe to compile the assembly to the native image cache, this
//example produces the following results:

//1) The string, 'abcd', is not interned.
//2) The string, 'wxyz', is not interned.

// Sample for String.IsInterned(String)
open System
open System.Text
open System.Runtime.CompilerServices

// In the .NET Framework 2.0 the following attribute declaration allows you to
// avoid the use of the interning when you use NGEN.exe to compile an assembly
// to the native image cache.
[<assembly: CompilationRelaxations(CompilationRelaxations.NoStringInterning)>]
do ()

let test sequence str =
    printf $"%d{sequence}) The string, '"
    let strInterned = String.IsInterned str
    if isNull strInterned then
        printfn $"{str}', is not interned."
    else
        printfn $"{strInterned}', is interned."

// String str1 is known at compile time, and is automatically interned.
let str1 = "abcd"

// Constructed string, str2, is not explicitly or automatically interned.
let str2 = StringBuilder().Append("wx").Append("yz").ToString()
printfn ""
test 1 str1
test 2 str2


//This example produces the following results:

//1) The string, 'abcd', is interned.
//2) The string, 'wxyz', is not interned.

//If you use NGEN.exe to compile the assembly to the native image cache, this
//example produces the following results:

//1) The string, 'abcd', is not interned.
//2) The string, 'wxyz', is not interned.

' Sample for String.IsInterned(String)
Imports System.Text
Imports System.Runtime.CompilerServices

' In the .NET Framework 2.0 the following attribute declaration allows you to 
' avoid the use of the interning when you use NGEN.exe to compile an assembly 
' to the native image cache.
<Assembly: CompilationRelaxations(CompilationRelaxations.NoStringInterning)> 
Class Sample
    Public Shared Sub Main()
        ' String str1 is known at compile time, and is automatically interned.
        Dim str1 As [String] = "abcd"

        ' Constructed string, str2, is not explicitly or automatically interned.
        Dim str2 As [String] = New StringBuilder().Append("wx").Append("yz").ToString()
        Console.WriteLine()
        Test(1, str1)
        Test(2, str2)
    End Sub

    Public Shared Sub Test(ByVal sequence As Integer, ByVal str As [String])
        Console.Write("{0}) The string, '", sequence)
        Dim strInterned As [String] = [String].IsInterned(str)
        If strInterned Is Nothing Then
            Console.WriteLine("{0}', is not interned.", str)
        Else
            Console.WriteLine("{0}', is interned.", strInterned)
        End If
    End Sub
End Class

'This example produces the following results:

'1) The string, 'abcd', is interned.
'2) The string, 'wxyz', is not interned.

'If you use NGEN.exe to compile the assembly to the native image cache, this
'example produces the following results:

'1) The string, 'abcd', is not interned.
'2) The string, 'wxyz', is not interned.

Hinweise

Die Common Language Runtime verwaltet automatisch eine Tabelle, die als Internpool bezeichnet wird, die eine einzelne Instanz jeder eindeutigen Literalzeichenfolgenkonstante enthält, die in einem Programm deklariert ist, sowie jede eindeutige Instanz, die String Sie programmgesteuert hinzufügen, indem Sie die Intern Methode aufrufen.

Der Internpool spart Zeichenfolgenspeicher. Wenn Sie mehreren Variablen eine Literalzeichenfolgenkonstante zuweisen, wird jede Variable so festgelegt, dass auf dieselbe Konstante im intern-Pool verwiesen wird, anstatt auf mehrere verschiedene Instanzen zu verweisen, deren String Werte identisch sind.

Diese Methode wird im Internpool nachschlagen str . Wenn str bereits interniert wurde, wird ein Verweis auf diese Instanz zurückgegeben. Andernfalls null wird ein Verweis zurückgegeben.

Vergleichen Sie diese Methode mit der Intern Methode.

Diese Methode gibt keinen booleschen Wert zurück. Wenn Sie die Methode aufrufen, da Sie einen booleschen Wert benötigen, der angibt, ob eine bestimmte Zeichenfolge interniert ist, können Sie Code wie den folgenden verwenden.

using System;

public class Example
{
   public static void Main()
   {
      string str1 = "a";
      string str2 = str1 + "b";
      string str3 = str2 + "c";
      string[] strings = { "value", "part1" + "_" + "part2", str3, 
                           String.Empty, null };
      foreach (var value in strings) {
         if (value == null) continue;
         
         bool interned = String.IsInterned(value) != null;
         if (interned)
            Console.WriteLine("'{0}' is in the string intern pool.", 
                              value);
         else
            Console.WriteLine("'{0}' is not in the string intern pool.",
                              value);                      
      }
   }
}
// The example displays the following output:
//       'value' is in the string intern pool.
//       'part1_part2' is in the string intern pool.
//       'abc' is not in the string intern pool.
//       '' is in the string intern pool.

open System

let str1 = "a"
let str2 = str1 + "b"
let str3 = str2 + "c"
let strings = 
    [| "value"; "part1" + "_" + "part2"; str3
       String.Empty; null |]
for value in strings do
    if value <> null then
        let interned = String.IsInterned(value) <> null
        if interned then
            printfn $"'{value}' is in the string intern pool."
        else
            printfn $"'{value}' is not in the string intern pool."
// The example displays the following output:
//       'value' is in the string intern pool.
//       'part1_part2' is in the string intern pool.
//       'abc' is not in the string intern pool.
//       '' is in the string intern pool.

Module Example
   Public Sub Main()
      Dim str1 As String = "a"
      Dim str2 As String = str1 + "b"
      Dim str3 As String = str2 + "c"
      Dim strings() As String = { "value", "part1" + "_" + "part2", str3, 
                                  String.Empty, Nothing }
      For Each value In strings
         If value Is Nothing Then Continue For
         
         Dim interned As Boolean = (String.IsInterned(value) IsNot Nothing)
         If interned Then
            Console.WriteLine("'{0}' is in the string intern pool.", 
                              value)
         Else
            Console.WriteLine("'{0}' is not in the string intern pool.",
                              value)                      
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       'value' is in the string intern pool.
'       'part1_part2' is in the string intern pool.
'       'abc' is not in the string intern pool.
'       '' is in the string intern pool.

Weitere Informationen

• Intern(String)