String.Copy(String) Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Achtung

This API should not be used to create mutable strings. See https://go.microsoft.com/fwlink/?linkid=2084035 for alternatives.

Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von 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);

public static string Copy (string str);

[<System.Obsolete("This API should not be used to create mutable strings. See https://go.microsoft.com/fwlink/?linkid=2084035 for alternatives.")>]
static member Copy : string -> string

static member Copy : string -> string

Public Shared Function Copy (str As String) As String

Parameter

str: String

Die zu kopierende Zeichenfolge.

Gibt zurück

String

Eine neue Zeichenfolge mit demselben Wert wie str.

Attribute: ObsoleteAttribute

Ausnahmen

ArgumentNullException

str ist null.

Hinweise

Die Copy -Methode gibt ein String -Objekt zurück, das den gleichen Wert wie die ursprüngliche Zeichenfolge hat, aber einen anderen Objektverweis darstellt. Er unterscheidet sich von einem Zuweisungsvorgang, der einer zusätzlichen Objektvariablen einen vorhandenen Zeichenfolgenverweis zuweist.

Wichtig

Ab .NET Core 3.0 ist diese Methode veraltet. Die Verwendung in einer .NET-Implementierung wird jedoch nicht empfohlen. Insbesondere aufgrund von Änderungen bei der Zeichenfolgeninternierung in .NET Core 3.0 erstellt die Methode in einigen Fällen Copy keine neue Zeichenfolge, sondern gibt einfach einen Verweis auf eine vorhandene interne Zeichenfolge zurück.

Je nachdem, warum Sie die Methode aufrufen Copy möchten, gibt es eine Reihe von Alternativen:

Wenn Sie eine andere Zeichenfolgeninstanz in einem Vorgang verwenden möchten, der die Zeichenfolge ändert, verwenden Sie die ursprüngliche Zeichenfolgeninstanz. Da Zeichenfolgen unveränderlich sind, erstellt der Zeichenfolgenvorgang eine neue Zeichenfolgeninstanz, und die ursprüngliche Zeichenfolge bleibt davon nicht betroffen. In diesem Fall sollten Sie den neuen Zeichenfolgenverweis nicht der ursprünglichen Zeichenfolgenvariablen zuweisen. Dies wird im folgenden Beispiel veranschaulicht.
```
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.
```
In diesem Fall wird durch Aufrufen der Copy -Methode zum Erstellen einer neuen Zeichenfolge vor dem unnötigen Aufrufen der Substring -Methode eine neue Zeichenfolgeninstanz erstellt.

Wenn Sie einen änderbaren Puffer mit demselben Inhalt wie die ursprüngliche Zeichenfolge erstellen möchten, rufen Sie den String.ToCharArray -Konstruktor oder den StringBuilder.StringBuilder(String) -Konstruktor auf. Beispiel:

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.

Wenn Sie eine änderbare Kopie der Zeichenfolge erstellen möchten, damit Sie unsicheren Code zum Ändern des Zeichenfolgeninhalts verwenden können, verwenden Sie die Marshal.StringToHGlobalUni -Methode. Im folgenden Beispiel wird die Marshal.StringToHGlobalUni -Methode verwendet, um einen Zeiger auf die Position einer kopierten Zeichenfolge im nicht verwalteten Speicher abzurufen, 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.

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

Freigeben über