String.Copy(String) Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Źródło:: String.cs

Źródło:: String.cs

Źródło:: String.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

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 klasy String o tej samej wartości co określona Stringwartość .

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

Parametry

str: String

Ciąg do skopiowania.

Zwraca

String

Nowy ciąg o tej samej wartości co str.

Atrybuty: ObsoleteAttribute

Wyjątki

ArgumentNullException

str to null.

Uwagi

Metoda Copy zwraca String obiekt, który ma taką samą wartość jak oryginalny ciąg, ale reprezentuje inne odwołanie do obiektu. Różni się ona od operacji przypisania, która przypisuje istniejące odwołanie do ciągu do dodatkowej zmiennej obiektu.

Ważne

Począwszy od platformy .NET Core 3.0, ta metoda jest przestarzała. Nie zalecamy jednak używania jej w żadnej implementacji platformy .NET. W szczególności ze względu na zmiany w ciągu przeplatania w programie .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 internowanego.

W zależności od tego, dlaczego chcesz wywołać metodę Copy , istnieje kilka alternatyw:

Jeśli chcesz, aby inne wystąpienie ciągu było używane w operacji modyfikującej ciąg, użyj oryginalnego wystąpienia ciągu. Ponieważ ciągi są niezmienne, operacja ciągu tworzy nowe wystąpienie ciągu, a oryginalny ciąg pozostaje nienaruszony. W takim przypadku nie należy przypisywać nowego odwołania do ciągu do oryginalnej zmiennej ciągu. Poniższy przykład stanowi ilustrację.

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.

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.

Jeśli chcesz utworzyć bufor modyfikowalny z taką samą zawartością jak oryginalny ciąg, wywołaj String.ToCharArray konstruktor lub StringBuilder.StringBuilder(String) . Przykład:

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.

Jeśli chcesz utworzyć modyfikowalny kopię ciągu, aby można było użyć niebezpiecznego kodu do zmodyfikowania zawartości ciągu, użyj Marshal.StringToHGlobalUni metody . W poniższym przykładzie Marshal.StringToHGlobalUni użyto metody , 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 o jeden i kopiuje wynikowy ciąg z powrotem do zarządzanego ciągu.

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

Dotyczy

Udostępnij za pośrednictwem