String.Copy(String) Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: String.cs

Source:: String.cs

Source:: String.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Attention

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

Crée une instance de String ayant la même valeur qu'un String spécifié.

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ètres

str: String

Chaîne à copier.

Retours

String

Nouvelle chaîne ayant la même valeur que str.

Attributs: ObsoleteAttribute

Exceptions

ArgumentNullException

str a la valeur null.

Remarques

La Copy méthode retourne un String objet qui a la même valeur que la chaîne d’origine, mais qui représente une référence d’objet différente. Elle diffère d’une opération d’affectation, qui affecte une référence de chaîne existante à une variable objet supplémentaire.

Important

À compter de .NET Core 3.0, cette méthode est obsolète. Toutefois, nous vous déconseillons de l’utiliser dans une implémentation .NET. En particulier, en raison des modifications apportées à l’internement de chaîne dans .NET Core 3.0, dans certains cas, la Copy méthode ne crée pas de chaîne, mais retourne simplement une référence à une chaîne interne existante.

Selon la raison pour laquelle vous souhaitez appeler la Copy méthode, il existe un certain nombre d’alternatives :

Si vous souhaitez qu’une autre instance de chaîne soit utilisée dans une opération qui modifie la chaîne, utilisez l’instance de chaîne d’origine. Étant donné que les chaînes sont immuables, l’opération de chaîne crée une nouvelle instance de chaîne et la chaîne d’origine reste inchangée. Dans ce cas, vous ne devez pas affecter la nouvelle référence de chaîne à la variable de chaîne d’origine. L'exemple suivant illustre cette situation.

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.

Dans ce cas, l’appel de la Copy méthode pour créer une chaîne avant d’appeler inutilement la Substring méthode crée une nouvelle instance de chaîne.

Si vous souhaitez créer une mémoire tampon mutable avec le même contenu que la chaîne d’origine, appelez le String.ToCharArray constructeur ou StringBuilder.StringBuilder(String) . Exemple :

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.

Si vous souhaitez créer une copie mutable de la chaîne afin de pouvoir utiliser du code non sécurisé pour modifier le contenu de la chaîne, utilisez Marshal.StringToHGlobalUni la méthode . L’exemple suivant utilise la Marshal.StringToHGlobalUni méthode pour obtenir un pointeur vers l’emplacement d’une chaîne copiée dans la mémoire non managée, incrémente le point de code Unicode de chaque caractère de la chaîne d’un, puis copie la chaîne résultante dans une chaîne managée.

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

S’applique à

Partage via