String.Copy(String) Methode

Definition

Warnung

Diese API ist jetzt veraltet.

Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String.Creates a new instance of String with the same value as a specified String.

public:
 static System::String ^ Copy(System::String ^ str);
[System.Obsolete("This API should not be used to create mutable strings. See https://go.microsoft.com/fwlink/?linkid=2084035 for alternatives.")]
public static string Copy (string str);
static member Copy : string -> string
Public Shared Function Copy (str As String) As String

Parameter

str
String

Die zu kopierende Zeichenfolge.The string to copy.

Gibt zurück

Eine neue Zeichenfolge mit demselben Wert wie str.A new string with the same value as str.

Attribute

Ausnahmen

str ist null.str is null.

Hinweise

Die Copy-Methode gibt ein String Objekt zurück, das denselben Wert wie die ursprüngliche Zeichenfolge aufweist, aber einen anderen Objekt Verweis darstellt.The Copy method returns a String object that has the same value as the original string but represents a different object reference. Dies unterscheidet sich von einer Zuweisungs Operation, bei der einer zusätzlichen Objektvariablen ein vorhandener Zeichen folgen Verweis zugewiesen wird.It differs from an assignment operation, which assigns an existing string reference to an additional object variable.

Wichtig

Ab .net Core 3,0 ist diese Methode veraltet.Starting with .NET Core 3.0, this method is obsolete. Es wird jedoch nicht empfohlen, die Verwendung in einer .NET-Implementierung zu verwenden.However, we do not recommend its use in any .NET implementation. Insbesondere aufgrund von Änderungen in der Zeichen folgen Internalisierung in .net Core 3,0 wird in einigen Fällen die Copy-Methode keine neue Zeichenfolge erstellen, sondern lediglich einen Verweis auf eine vorhandene Internpool vorhanden-Zeichenfolge zurückgeben.In particular, because of changes in string interning in .NET Core 3.0, in some cases the Copy method will not create a new string but will simply return a reference to an existing interned string.

Abhängig davon, warum Sie die Copy-Methode abrufen möchten, gibt es eine Reihe von Alternativen:Depending on Why you want to call the Copy method, there are a number of alternatives:

  • Wenn eine andere Zeichen folgen Instanz in einem Vorgang verwendet werden soll, der die Zeichenfolge ändert, verwenden Sie die ursprüngliche Zeichen folgen Instanz.If you want a different string instance to use in an operation that modifies the string, use the original string instance. Da Zeichen folgen unveränderlich sind, wird durch den Zeichen folgen Vorgang eine neue Zeichen folgen Instanz erstellt, und die ursprüngliche Zeichenfolge bleibt unverändert.Because strings are immutable, the string operation creates a new string instance, and the original string remains unaffected. In diesem Fall sollten Sie den neuen Zeichen folgen Verweis nicht der ursprünglichen Zeichen folgen Variablen zuweisen.In this case, you should not assign the new string reference to the original string variable. Dies wird im folgenden Beispiel veranschaulicht.The following example provides an illustration.

    var original = "This is a sentence. This is a second sentence.";
    var sentence1 = original.Substring(0, original.IndexOf(".") + 1);
    Console.WriteLine(original);
    Console.WriteLine(sentence1);
    // The example displays the following output:
    //    This is a sentence. This is a second sentence.
    //    This is a sentence.            
    
    Dim original = "This is a sentence. This is a second sentence."
    Dim sentence1 = original.Substring(0, original.IndexOf(".") + 1)
    Console.WriteLine(original)
    Console.WriteLine(sentence1)
    ' The example displays the following output:
    '    This is a sentence. This is a second sentence.
    '    This is a sentence.            
    

    Wenn Sie die Copy-Methode aufrufen, um eine neue Zeichenfolge zu erstellen, bevor Sie die Substring-Methode aufrufen, wird eine neue Zeichen folgen Instanz erstellt.In this case, calling the Copy method to create a new string before calling the Substring method unnecessarily creates a new string instance.

  • Wenn Sie einen änderbaren Puffer mit dem gleichen Inhalt wie die ursprüngliche Zeichenfolge erstellen möchten, rufen Sie den String.ToCharArray-oder StringBuilder.StringBuilder(String)-Konstruktor auf.If you want to create a mutable buffer with the same contents as the original string, call the String.ToCharArray or StringBuilder.StringBuilder(String) constructor. Beispiel:For example:

    private static void UseMutableBuffer()
    {
        var original = "This is a sentence. This is a second sentence.";
        var chars = original.ToCharArray();
        var span = new Span<char>(chars);
        var slice = span.Slice(span.IndexOf('.'), 3);
        slice = MergeSentence(slice);
        Console.WriteLine($"Original string: {original}");
        Console.WriteLine($"Modified string: {span.ToString()}");
    
        static Span<char> MergeSentence(Span<char> span)
        {
            if (span.Length == 0) return Span<char>.Empty;
    
            span[0] = ';';
            span[2] = Char.ToLower(span[2]);
            return span;
        }
    }
    // The example displays the following output:
    //    Original string: This is a sentence. This is a second sentence.
    //    Modified string: This is a sentence; this is a second sentence.        
    
    Private Sub UseMutableBuffer()
        Dim original = "This is a sentence. This is a second sentence."
        Dim sb = new StringBuilder(original)
        Dim index = original.IndexOf(".")
        sb(index) = ";"
        sb(index + 2) = Char.ToLower(sb(index + 2))
        Console.WriteLine($"Original string: {original}")
        Console.WriteLine($"Modified string: {sb.ToString()}")
    End Sub
    ' The example displays the following output:
    '    Original string: This is a sentence. This is a second sentence.
    '    Modified string: This is a sentence; this is a second sentence.        
    
  • Wenn Sie eine änderbare Kopie der Zeichenfolge erstellen möchten, sodass Sie unsicheren Code verwenden können, um den Inhalt der Zeichenfolge zu ändern, verwenden Sie Marshal.StringToHGlobalUni-Methode.If you want to create a mutable copy of the string so that you can use unsafe code to modify the string contents, use Marshal.StringToHGlobalUni method. Im folgenden Beispiel wird die Marshal.StringToHGlobalUni-Methode verwendet, um einen Zeiger auf den Speicherort einer kopierten Zeichenfolge im nicht verwalteten Speicher zu erhalten, den Unicode-Codepunkt jedes Zeichens in der Zeichenfolge um eins zu erhöhen und die resultierende Zeichenfolge zurück in eine verwaltete Zeichenfolge zu kopieren.The following example uses the Marshal.StringToHGlobalUni method to get a pointer to the location of an copied string in unmanaged memory, increments the Unicode code point of each character in the string by one, and copies the resulting string back to a managed string.

    private static void UseUnmanaged()
    {
        var original = "This is a single sentence.";
        var len = original.Length; 
        var ptr = Marshal.StringToHGlobalUni(original);
        string result;
        unsafe 
        {
            char *ch = (char *) ptr.ToPointer();
            while (len-- > 0)
            {
                char c = Convert.ToChar(Convert.ToUInt16(*ch) + 1);
                *ch++ = c;
            } 
            result = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
        }
        Console.WriteLine($"Original string: {original}");
        Console.WriteLine($"String from interop: '{result}'");
    }
    // The example displays the following output:
    //    Original string: This is a single sentence.
    //    String from interop: 'Uijt!jt!b!tjohmf!tfoufodf/'      
    

Gilt für: