String.Copy(String) Metoda

Definicja

Przestroga

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

Tworzy nowe wystąpienie o String takiej samej wartości jak określona String .Creates a new instance of String with the same value as a specified String.

public:
 static System::String ^ Copy(System::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.")]
public static string Copy (string str);
static member Copy : string -> string
[<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

Parametry

str
String

Ciąg do skopiowania.The string to copy.

Zwraca

String

Nowy ciąg o takiej samej wartości jak str .A new string with the same value as str.

Atrybuty

Wyjątki

str to null.str is null.

Uwagi

CopyMetoda zwraca String obiekt, który ma taką samą wartość jak oryginalny ciąg, ale reprezentuje inne odwołanie do obiektu.The Copy method returns a String object that has the same value as the original string but represents a different object reference. Różni się od operacji przypisania, która przypisuje istniejące odwołanie do ciągu do dodatkowej zmiennej obiektu.It differs from an assignment operation, which assigns an existing string reference to an additional object variable.

Ważne

Począwszy od platformy .NET Core 3,0, ta metoda jest przestarzała.Starting with .NET Core 3.0, this method is obsolete. Nie zaleca się jednak używania ich w żadnej implementacji platformy .NET.However, we do not recommend its use in any .NET implementation. W szczególności ze względu na zmiany w ciągu na platformie .NET Core 3,0, w niektórych przypadkach Copy Metoda nie utworzy nowego ciągu, ale po prostu zwróci odwołanie do istniejącego ciągu z stażystami.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.

W zależności od tego, dlaczego chcesz wywołać Copy metodę, istnieje szereg alternatyw:Depending on Why you want to call the Copy method, there are a number of alternatives:

  • Jeśli chcesz, aby w operacji modyfikującej ciąg użyć innego wystąpienia ciągu, użyj oryginalnego wystąpienia ciągu.If you want a different string instance to use in an operation that modifies the string, use the original string instance. Ponieważ ciągi są niezmienne, operacja String tworzy nowe wystąpienie ciągu, a oryginalny ciąg pozostaje bez zmian.Because strings are immutable, the string operation creates a new string instance, and the original string remains unaffected. W tym przypadku nie należy przypisywać nowego ciągu do oryginalnej zmiennej ciągu.In this case, you should not assign the new string reference to the original string variable. Poniższy przykład stanowi ilustrację.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.            
    

    W takim przypadku wywołanie Copy metody w celu utworzenia nowego ciągu przed wywołaniem Substring metody niepotrzebnie tworzy nowe wystąpienie ciągu.In this case, calling the Copy method to create a new string before calling the Substring method unnecessarily creates a new string instance.

  • Jeśli chcesz utworzyć modyfikowalny bufor o tej samej zawartości co oryginalny ciąg, wywołaj String.ToCharArray StringBuilder.StringBuilder(String) konstruktora or.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. Na przykład: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.        
    
  • Jeśli chcesz utworzyć modyfikowalną kopię ciągu, aby można było użyć niebezpiecznego kodu do modyfikacji zawartości ciągu, użyj Marshal.StringToHGlobalUni metody.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. Poniższy przykład używa metody, Marshal.StringToHGlobalUni Aby uzyskać wskaźnik do lokalizacji skopiowanego ciągu w pamięci niezarządzanej, zwiększa punkt kodu Unicode każdego znaku w ciągu przez jeden, a następnie kopiuje otrzymany ciąg z powrotem do zarządzanego ciągu.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/'      
    

Dotyczy