String.Replace Methode

Definition

Namespace:
System
Assemblys:
mscorlib.dll, System.Runtime.dll
Assemblys:
netstandard.dll, System.Runtime.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen eines angegebenen Unicode-Zeichens oder String in der aktuellen Zeichenfolge durch ein anderes angegebenes Unicode-Zeichen ersetzt werden.String

Überlädt

Name Beschreibung
Replace(Char, Char)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen eines angegebenen Unicode-Zeichens in dieser Instanz durch ein anderes angegebenes Unicode-Zeichen ersetzt werden.
Replace(String, String)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden.
Replace(Rune, Rune)
Replace(String, String, StringComparison)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden, wobei der angegebene Vergleichstyp verwendet wird.
Replace(String, String, Boolean, CultureInfo)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden, wobei die bereitgestellte Kultur und Groß-/Kleinschreibung verwendet wird.

Replace(Char, Char)

Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen eines angegebenen Unicode-Zeichens in dieser Instanz durch ein anderes angegebenes Unicode-Zeichen ersetzt werden.

public:
 System::String ^ Replace(char oldChar, char newChar);
public string Replace(char oldChar, char newChar);
member this.Replace : char * char -> string
Public Function Replace (oldChar As Char, newChar As Char) As String

Parameter

oldChar
Char

Das zu ersetzende Unicode-Zeichen.

newChar
Char

Das Unicode-Zeichen, das alle Vorkommen von oldChar.

Gibt zurück

String

Eine Zeichenfolge, die dieser Instanz entspricht, mit der Ausnahme, dass alle Instanzen oldChar ersetzt newCharwerden. Wenn oldChar in der aktuellen Instanz nicht gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Beispiele

Im folgenden Beispiel wird eine durch Trennzeichen getrennte Werteliste erstellt, indem Kommas für die Leerzeichen zwischen einer Reihe von Zahlen ersetzt werden.

string str = "1 2 3 4 5 6 7 8 9";
Console.WriteLine($"Original string: \"{str}\"");
Console.WriteLine($"CSV string:      \"{str.Replace(' ', ',')}\"");

// This example produces the following output:
// Original string: "1 2 3 4 5 6 7 8 9"
// CSV string:      "1,2,3,4,5,6,7,8,9"

let str = "1 2 3 4 5 6 7 8 9"
printfn $"Original string: \"{str}\""
printfn $"CSV string:      \"{str.Replace(' ', ',')}\""

// This example produces the following output:
// Original string: "1 2 3 4 5 6 7 8 9"
// CSV string:      "1,2,3,4,5,6,7,8,9"

Class stringReplace1
   Public Shared Sub Main()
      Dim str As [String] = "1 2 3 4 5 6 7 8 9"
      Console.WriteLine("Original string: ""{0}""", str)
      Console.WriteLine("CSV string:      ""{0}""", str.Replace(" "c, ","c))
   End Sub
End Class
' This example produces the following output:
' Original string: "1 2 3 4 5 6 7 8 9"
' CSV string:      "1,2,3,4,5,6,7,8,9"

Hinweise

Diese Methode führt eine Ordinalsuche (Groß-/Kleinschreibung und Kultur-Insensitive) durch, um die Suche durchzuführen oldChar.

Note

Diese Methode ändert nicht den Wert der aktuellen Instanz. Stattdessen wird eine neue Zeichenfolge zurückgegeben, in der oldChar alle Vorkommen durch newCharersetzt werden.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge auszuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = new('a', 3);
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace('a', 'b').Replace('b', 'c').Replace('c', 'd');
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = new string('a', 3)
printfn $"The initial string: '{s}'"
let s2 = s.Replace('a', 'b').Replace('b', 'c').Replace('c', 'd')
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As New String("a"c, 3)
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a"c, "b"c).Replace("b"c, "c"c).Replace("c"c, "d"c)
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Weitere Informationen

Gilt für:

Replace(String, String)

Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden.

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue);
public string Replace(string oldValue, string newValue);
public string Replace(string oldValue, string? newValue);
member this.Replace : string * string -> string
Public Function Replace (oldValue As String, newValue As String) As String

Parameter

oldValue
String

Die zu ersetzende Zeichenfolge.

newValue
String

Die Zeichenfolge, die alle Vorkommen von oldValue.

Gibt zurück

String

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, mit der Ausnahme, dass alle Instanzen oldValue ersetzt newValuewerden. Wenn oldValue in der aktuellen Instanz nicht gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

oldValue ist null.

ArgumentException

oldValue ist die leere Zeichenfolge ("").

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie die Replace Methode verwenden können, um einen Rechtschreibfehler zu korrigieren.

string errString = "This docment uses 3 other docments to docment the docmentation";

Console.WriteLine($"The original string is:{Environment.NewLine}'{errString}'{Environment.NewLine}");

// Correct the spelling of "document".
string correctString = errString.Replace("docment", "document");

Console.WriteLine($"After correcting the string, the result is:{Environment.NewLine}'{correctString}'");

// This code example produces the following output:
//
// The original string is:
// 'This docment uses 3 other docments to docment the docmentation'
//
// After correcting the string, the result is:
// 'This document uses 3 other documents to document the documentation'
//

open System

let errString = "This docment uses 3 other docments to docment the docmentation"

printfn $"The original string is:{Environment.NewLine}'{errString}'{Environment.NewLine}"

// Correct the spelling of "document".

let correctString = errString.Replace("docment", "document")

printfn $"After correcting the string, the result is:{Environment.NewLine}'{correctString}'"

// This code example produces the following output:
//
// The original string is:
// 'This docment uses 3 other docments to docment the docmentation'
//
// After correcting the string, the result is:
// 'This document uses 3 other documents to document the documentation'
//

Public Class ReplaceTest
    
    Public Shared Sub Main()
        Dim errString As String = "This docment uses 3 other docments to docment the docmentation"
                
        Console.WriteLine("The original string is:{0}'{1}'{0}", Environment.NewLine, errString)

        ' Correct the spelling of "document".  
        Dim correctString As String = errString.Replace("docment", "document")
      
        Console.WriteLine("After correcting the string, the result is:{0}'{1}'", Environment.NewLine, correctString)
    End Sub
End Class
'
' This code example produces the following output:
'
' The original string is:
' 'This docment uses 3 other docments to docment the docmentation'
'
' After correcting the string, the result is:
' 'This document uses 3 other documents to document the documentation'
'

Hinweise

Wenn newValue ja null, werden alle Vorkommen oldValue entfernt.

Note

Diese Methode ändert nicht den Wert der aktuellen Instanz. Stattdessen wird eine neue Zeichenfolge zurückgegeben, in der oldValue alle Vorkommen durch newValueersetzt werden.

Diese Methode führt eine Ordinalsuche (Groß-/Kleinschreibung und Kultur-Insensitive) durch, um die Suche durchzuführen oldValue.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge auszuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Weitere Informationen

Gilt für:

Replace(Rune, Rune)

Quelle:
String.Manipulation.cs
public:
 System::String ^ Replace(System::Text::Rune oldRune, System::Text::Rune newRune);
public string Replace(System.Text.Rune oldRune, System.Text.Rune newRune);
member this.Replace : System.Text.Rune * System.Text.Rune -> string
Public Function Replace (oldRune As Rune, newRune As Rune) As String

Parameter

oldRune
Rune
newRune
Rune

Gibt zurück

String

Gilt für:

Replace(String, String, StringComparison)

Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden, wobei der angegebene Vergleichstyp verwendet wird.

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue, StringComparison comparisonType);
public string Replace(string oldValue, string? newValue, StringComparison comparisonType);
public string Replace(string oldValue, string newValue, StringComparison comparisonType);
member this.Replace : string * string * StringComparison -> string
Public Function Replace (oldValue As String, newValue As String, comparisonType As StringComparison) As String

Parameter

oldValue
String

Die zu ersetzende Zeichenfolge.

newValue
String

Die Zeichenfolge, die alle Vorkommen von oldValue.

comparisonType
StringComparison

Einer der Enumerationswerte, der bestimmt, wie oldValue in dieser Instanz durchsucht wird.

Gibt zurück

String

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, mit der Ausnahme, dass alle Instanzen oldValue ersetzt newValuewerden. Wenn oldValue in der aktuellen Instanz nicht gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

oldValue ist null.

ArgumentException

oldValue ist die leere Zeichenfolge ("").

Hinweise

Wenn newValue ja null, werden alle Vorkommen oldValue entfernt.

Note

Diese Methode ändert nicht den Wert der aktuellen Instanz. Stattdessen wird eine neue Zeichenfolge zurückgegeben, in der oldValue alle Vorkommen durch newValueersetzt werden.

Diese Methode führt eine Suche aus, um mithilfe der kultur- und Groß-/Kleinschreibungsempfindlichkeit zu suchen oldValue , die von comparisonType.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge auszuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Gilt für:

Replace(String, String, Boolean, CultureInfo)

Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs
Quelle:
String.Manipulation.cs

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt werden, wobei die bereitgestellte Kultur und Groß-/Kleinschreibung verwendet wird.

public:
 System::String ^ Replace(System::String ^ oldValue, System::String ^ newValue, bool ignoreCase, System::Globalization::CultureInfo ^ culture);
public string Replace(string oldValue, string? newValue, bool ignoreCase, System.Globalization.CultureInfo? culture);
public string Replace(string oldValue, string newValue, bool ignoreCase, System.Globalization.CultureInfo culture);
member this.Replace : string * string * bool * System.Globalization.CultureInfo -> string
Public Function Replace (oldValue As String, newValue As String, ignoreCase As Boolean, culture As CultureInfo) As String

Parameter

oldValue
String

Die zu ersetzende Zeichenfolge.

newValue
String

Die Zeichenfolge, die alle Vorkommen von oldValue.

ignoreCase
Boolean

true die Groß-/Kleinschreibung beim Vergleichen zu ignorieren; false Andernfalls.

culture
CultureInfo

Die Kultur, die beim Vergleich verwendet werden soll. Wenn culture gleich null ist, wird die aktuelle Kultur verwendet.

Gibt zurück

String

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, mit der Ausnahme, dass alle Instanzen oldValue ersetzt newValuewerden. Wenn oldValue in der aktuellen Instanz nicht gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Ausnahmen

ArgumentNullException

oldValue ist null.

ArgumentException

oldValue ist die leere Zeichenfolge ("").

Hinweise

Wenn newValue ja null, werden alle Vorkommen oldValue entfernt.

Note

Diese Methode ändert nicht den Wert der aktuellen Instanz. Stattdessen wird eine neue Zeichenfolge zurückgegeben, in der oldValue alle Vorkommen durch newValueersetzt werden.

Diese Methode führt eine Suche aus, um mithilfe der angegebenen oldValue Und Groß-/cultureKleinschreibung zu suchenignoreCase.

Da diese Methode die geänderte Zeichenfolge zurückgibt, können Sie aufeinander folgende Aufrufe der Replace Methode verketten, um mehrere Ersetzungen für die ursprüngliche Zeichenfolge auszuführen. Methodenaufrufe werden von links nach rechts ausgeführt. Dies wird im folgenden Beispiel veranschaulicht.

string s = "aaa";
Console.WriteLine($"The initial string: '{s}'");
s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d");
Console.WriteLine($"The final string: '{s}'");

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

let s = "aaa"
printfn $"The initial string: '{s}'"
let s2 = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
printfn $"The final string: '{s2}'"

// The example displays the following output:
//       The initial string: 'aaa'
//       The final string: 'ddd'

Module Example
   Public Sub Main()
      Dim s As String = "aaa"
      Console.WriteLine("The initial string: '{0}'", s)
      s = s.Replace("a", "b").Replace("b", "c").Replace("c", "d")
      Console.WriteLine("The final string: '{0}'", s)
   End Sub
End Module
' The example displays the following output:
'       The initial string: 'aaa'
'       The final string: 'ddd'

Gilt für: