Partilhar via


String.Copy(String) Método

Definição

Cuidado

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

Cria uma nova instância de String com o mesmo valor que um String especificado.

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

A cadeia de caracteres a ser copiada.

Retornos

Uma nova cadeia de caracteres com o mesmo valor que str.

Atributos

Exceções

str é null.

Comentários

O Copy método retorna um String objeto que tem o mesmo valor que a cadeia de caracteres original, mas representa uma referência de objeto diferente. Ela difere de uma operação de atribuição, que atribui uma referência de cadeia de caracteres existente a uma variável de objeto adicional.

Importante

A partir do .NET Core 3.0, esse método está obsoleto. No entanto, não recomendamos seu uso em nenhuma implementação do .NET. Em particular, devido a alterações na internação de cadeia de caracteres no .NET Core 3.0, em alguns casos o Copy método não criará uma nova cadeia de caracteres, mas simplesmente retornará uma referência a uma cadeia de caracteres interna existente.

Dependendo de Por que você deseja chamar o Copy método , há várias alternativas:

  • Se você quiser que uma instância de cadeia de caracteres diferente use em uma operação que modifique a cadeia de caracteres, use a instância de cadeia de caracteres original. Como as cadeias de caracteres são imutáveis, a operação de cadeia de caracteres cria uma nova instância de cadeia de caracteres e a cadeia de caracteres original permanece não afetada. Nesse caso, você não deve atribuir a nova referência de cadeia de caracteres à variável de cadeia de caracteres original. O exemplo a seguir ilustra esse cenário.

    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.
    

    Nesse caso, chamar o Copy método para criar uma nova cadeia de caracteres antes de chamar o Substring método cria desnecessariamente uma nova instância de cadeia de caracteres.

  • Se você quiser criar um buffer mutável com o mesmo conteúdo que a cadeia de caracteres original, chame o String.ToCharArray construtor ou StringBuilder.StringBuilder(String) . Por exemplo:

    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.
    
  • Se você quiser criar uma cópia mutável da cadeia de caracteres para que possa usar código não seguro para modificar o conteúdo da cadeia de caracteres, use Marshal.StringToHGlobalUni o método . O exemplo a seguir usa o Marshal.StringToHGlobalUni método para obter um ponteiro para o local de uma cadeia de caracteres copiada na memória não gerenciada, incrementa o ponto de código Unicode de cada caractere na cadeia de caracteres em um e copia a cadeia de caracteres resultante de volta para uma cadeia de caracteres gerenciada.

    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/'
    

Aplica-se a