String.Copy(String) Método

Definición

Precaución

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

Crea una nueva instancia de String con el mismo valor que una String especificada.

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

Parámetros

str
String

Cadena que se va a copiar.

Devoluciones

Nueva cadena con el mismo valor que str.

Atributos

Excepciones

str es null.

Comentarios

El Copy método devuelve un String objeto que tiene el mismo valor que la cadena original, pero representa una referencia de objeto diferente. Difiere de una operación de asignación, que asigna una referencia de cadena existente a una variable de objeto adicional.

Importante

A partir de .NET Core 3.0, este método está obsoleto. Sin embargo, no se recomienda su uso en ninguna implementación de .NET. En concreto, debido a los cambios en la internación de cadenas en .NET Core 3.0, en algunos casos el Copy método no creará una nueva cadena, sino que simplemente devolverá una referencia a una cadena interna existente.

Dependiendo de Why you want to call the Copy method, there are a number of alternatives:

  • Si desea usar una instancia de cadena diferente en una operación que modifique la cadena, use la instancia de cadena original. Dado que las cadenas son inmutables, la operación de cadena crea una nueva instancia de cadena y la cadena original sigue sin verse afectada. En este caso, no debe asignar la nueva referencia de cadena a la variable de cadena original. Esto se muestra en el ejemplo siguiente.

    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.
    
    let original = "This is a sentence. This is a second sentence."
    let sentence1 = original.Substring(0, original.IndexOf "." + 1)
    printfn $"{original}"
    printfn $"{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.
    

    En este caso, llamar al Copy método para crear una nueva cadena antes de llamar al Substring método crea innecesariamente una nueva instancia de cadena.

  • Si desea crear un búfer mutable con el mismo contenido que la cadena original, llame al String.ToCharArray constructor o StringBuilder.StringBuilder(String) . Por ejemplo:

    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.
    
    let mergeSentence (span: Span<char>) =
        if span.Length = 0 then
            Span<char>.Empty
        else
            span[0] <- '\000'
            span[2] <- Char.ToLower span[2]
            span
    
    let useMutableBuffer () =
        let original = "This is a sentence. This is a second sentence."
        let chars = original.ToCharArray()
        let span = Span chars
        let slice = span.Slice(span.IndexOf '.', 3)
        let slice = mergeSentence slice
        let span = span.ToString()
        printfn $"Original string: {original}"
        printfn $"Modified string: {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.
    
  • Si desea crear una copia mutable de la cadena para que pueda usar código no seguro para modificar el contenido de la cadena, use Marshal.StringToHGlobalUni el método . En el ejemplo siguiente se usa el Marshal.StringToHGlobalUni método para obtener un puntero a la ubicación de una cadena copiada en memoria no administrada, se incrementa el punto de código Unicode de cada carácter de la cadena por uno y se copia la cadena resultante en una cadena administrada.

    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/'
    
    #nowarn "9"
    open FSharp.NativeInterop
    
    let useUnmanaged () =
        let original = "This is a single sentence."
        let mutable len = original.Length 
        let ptr = Marshal.StringToHGlobalUni original
        let mutable ch = ptr.ToPointer() |> NativePtr.ofVoidPtr<char> 
        while len > 0 do
            len <- len - 1
            Convert.ToUInt16(NativePtr.read ch) + 1us
            |> Convert.ToChar
            |> NativePtr.write (NativePtr.add ch 1)
            ch <- NativePtr.add ch 1
    
        let result = Marshal.PtrToStringUni ptr
        Marshal.FreeHGlobal ptr
        printfn $"Original string: {original}"
        printfn $"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/'
    

Se aplica a