String.Replace Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

Überlädt

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 wurden.
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 wurden.
Replace(String, String, StringComparison)	Gibt mithilfe des bereitgestellten Vergleichstyps eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.
Replace(String, String, Boolean, CultureInfo)	Gibt mithilfe der angegebenen Kultur und der Angabe zur Groß-/Kleinschreibung eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

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 wurden.

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 jedes Vorkommen von oldChar ersetzen soll.

Gibt zurück

String

Eine Zeichenfolge, die dieser Instanz entspricht, außer dass alle Instanzen von oldChar durch newChar ersetzt werden. Wenn oldChar nicht in der aktuellen Instanz gefunden wird, gibt die Methode die aktuelle Instanz unverändert zurück.

Beispiele

Im folgenden Beispiel wird eine Trennzeichenliste durch Substituieren von Kommas für die Leerzeichen zwischen einer Reihe von Zahlen erstellt.

using namespace System;
int main()
{
   String^ str = "1 2 3 4 5 6 7 8 9";
   Console::WriteLine( "Original string: \"{0}\"", str );
   Console::WriteLine( "CSV string:      \"{0}\"", 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"
//

String str = "1 2 3 4 5 6 7 8 9";
Console.WriteLine("Original string: \"{0}\"", str);
Console.WriteLine("CSV string:      \"{0}\"", 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) aus, um zu suchen oldChar.

Hinweis

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

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

String s = new String('a', 3);
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);

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

Siehe auch

Gilt für:

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 wurden.

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 jedes Vorkommen von oldValue ersetzen soll.

Gibt zurück

String

Eine Zeichenfolge, die der aktuellen Zeichenfolge entspricht, außer dass alle Instanzen von oldValue durch newValue ersetzt werden. Wenn oldValue nicht in der aktuellen Instanz 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.

using namespace System;
int main()
{
   String^ errString = "This docment uses 3 other docments to docment the docmentation";
   Console::WriteLine( "The original string is:\n'{0}'\n", errString );

   // Correct the spelling of S"document".
   String^ correctString = errString->Replace( "docment", "document" );
   Console::WriteLine( "After correcting the string, the result is:\n'{0}'", 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'
//

string errString = "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".

string correctString = errString.Replace("docment", "document");

Console.WriteLine("After correcting the string, the result is:{0}'{1}'",
        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 ist null, werden alle Vorkommen oldValue entfernt.

Hinweis

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

Diese Methode führt eine Ordinalsuche (Groß-/Kleinschreibung und Kultur-Insensitive) aus, um zu suchen oldValue.

String s = "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);

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

Siehe auch

Gilt für:

Replace(String, String, StringComparison)

Gibt mithilfe des bereitgestellten Vergleichstyps eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

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 jedes Vorkommen von oldValue ersetzen soll.

comparisonType: StringComparison

Einer der Enumerationswerte, der bestimmt, wie oldValue in dieser Instanz gesucht werden soll.

Gibt zurück

String

Ausnahmen

ArgumentNullException

oldValue ist null.

ArgumentException

oldValue ist die leere Zeichenfolge ("").

Hinweise

Wenn newValue ist null, werden alle Vorkommen oldValue entfernt.

Hinweis

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

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

String s = "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);

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

Gibt mithilfe der angegebenen Kultur und der Angabe zur Groß-/Kleinschreibung eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

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 jedes Vorkommen von oldValue ersetzen soll.

ignoreCase: Boolean

true, um die Groß-/Kleinschreibung beim Vergleich zu ignorieren, andernfalls false.

culture: CultureInfo

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

Gibt zurück

String

Ausnahmen

ArgumentNullException

oldValue ist null.

ArgumentException

oldValue ist die leere Zeichenfolge ("").

Hinweise

Wenn newValue ist null, werden alle Vorkommen oldValue entfernt.

Hinweis

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

Diese Methode führt eine Suche durch, um mithilfe der bereitgestellten culture und Groß-/ignoreCaseKleinschreibung zu suchenoldValue.

String s = "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);

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