String.Copy(String) Metódus

Definíció

Névtér:: System

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Forrás:: String.cs

Forrás:: String.cs

Forrás:: String.cs

Forrás:: String.cs

Forrás:: String.cs

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Figyelemfelhívás

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

Létrehoz egy új példányt String , amelynek értéke megegyezik a megadott Stringértékkel.

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

Paraméterek

str: String

A másolandó sztring.

Válaszok

String

Egy új sztring, amely ugyanazzal az értékkel rendelkezik, mint a str.

Attribútumok: ObsoleteAttribute

Kivételek

ArgumentNullException

str az null.

Megjegyzések

A Copy metódus egy String olyan objektumot ad vissza, amelynek értéke megegyezik az eredeti sztringgel, de egy másik objektumhivatkozást jelöl. Ez eltér egy hozzárendelési művelettől, amely egy meglévő sztringhivatkozást rendel hozzá egy további objektumváltozóhoz.

Important

A .NET Core 3.0-tól kezdve ez a módszer elavult. Azonban nem javasoljuk a használatát semmilyen .NET implementációban. Különösen a .NET Core 3.0-s sztringbe illesztésének változásai miatt, bizonyos esetekben a Copy metódus nem hoz létre új sztringet, hanem egyszerűen egy meglévő internált sztringre mutató hivatkozást ad vissza.

Attól függően, hogy miért szeretné meghívni a Copy metódust, számos alternatíva létezik:

Ha azt szeretné, hogy egy másik sztringpéldányt használjon a sztringet módosító műveletben, használja az eredeti sztringpéldányt. Mivel a sztringek nem módosíthatók, a sztringművelet létrehoz egy új sztringpéldányt, és az eredeti sztring változatlan marad. Ebben az esetben ne rendelje hozzá az új sztringhivatkozást az eredeti sztringváltozóhoz. Az alábbi példa egy illusztrációt tartalmaz.

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.

Ebben az esetben a Copy metódus meghívásával hozzon létre egy új sztringet, mielőtt meghívja a Substring metódust, szükségtelenül létrehoz egy új sztringpéldányt.

Ha olyan mutable puffert szeretne létrehozni, amelynek tartalma megegyezik az eredeti sztring tartalmával, hívja meg a konstruktort vagy String.ToCharArray a konstruktortStringBuilder.StringBuilder(String). Például:

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.

Ha a sztring egy módosítható másolatát szeretné létrehozni, hogy a sztring tartalmának módosításához ne biztonságos kódot használjon, használja a metódust Marshal.StringToHGlobalUni . Az alábbi példa a Marshal.StringToHGlobalUni metódussal egy másolt sztring helyére mutató mutatót kap a nem felügyelt memóriában, a sztring egyes karaktereinek Unicode-kódpontját egyenként növeli, majd az eredményül kapott sztringet visszamásolja egy felügyelt sztringbe.

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

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?