String.Copy(String) Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

String.cs

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);

[<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

Public Shared Function Copy (str As String) As String

Parâmetros

str

String

A cadeia de caracteres a ser copiada.

Retornos

String

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

Atributos

ObsoleteAttribute

Exceções

ArgumentNullException

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