Regex.Replace Method

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);

public static string Replace(string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

The static Replace(String, String, String, RegexOptions) methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace(String, String).

The replacement parameter specifies the string that replaces each match in input. replacement can consist of any combination of literal text and substitutions. Substitutions are the only regular expression language elements that are recognized in a replacement pattern.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

Notes to Callers

This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

See also

• RegexOptions
• Substitutions in Regular Expressions
• Regular Expression Language Elements

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace(string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

The static Replace(String, String, String, RegexOptions, TimeSpan) methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace(String, String).

The replacement parameter specifies the string that replaces each match in input. replacement can consist of any combination of literal text and substitutions. Substitutions are the only regular expression language elements that are recognized in a replacement pattern.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notes to Callers

We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. However, you should disable time-outs only under the following conditions:

• When the input processed by a regular expression is derived from a known and trusted source or consists of static text. This excludes text that has been dynamically input by users.

• When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

• When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

See also

• RegexOptions
• Substitutions in Regular Expressions
• Regular Expression Language Elements
• Backtracking in Regular Expressions
• Best practices for regular expressions in .NET

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

For more details about startat, see the Remarks section of Match(String, Int32).

The method passes the first countMatch objects to the evaluator delegate.

See also

• MatchEvaluator
• Substitutions in Regular Expressions
• Regular Expression Language - Quick Reference

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);

public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

This method is useful for replacing a regular expression match if any of the following conditions is true: the replacement string cannot readily be specified by a regular expression replacement pattern, the replacement string results from processing the matched string, or the replacement string results from conditional processing.

The method is equivalent to calling the Matches(String, String) method and passing each Match object in the returned MatchCollection to the evaluator delegate.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

See also

• MatchEvaluator
• RegexOptions
• Substitutions in Regular Expressions
• Regular Expression Language Elements

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

This method is useful for replacing a regular expression match if any of the following conditions is true: the replacement string cannot readily be specified by a regular expression replacement pattern, the replacement string results from processing the matched string, or the replacement string results from conditional processing.

The method is equivalent to calling the Matches(String, String) method and passing each Match object in the returned MatchCollection to the evaluator delegate.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

If you specify RightToLeft for the options parameter, the search for matches begins at the end of the input string and moves left; otherwise, the search begins at the start of the input string and moves right.

The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notes to Callers

We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. However, you should disable time-outs only under the following conditions:

• When the input processed by a regular expression is derived from a known and trusted source or consists of static text. This excludes text that has been dynamically input by users.

• When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

• When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

See also

• RegexOptions
• Substitutions in Regular Expressions
• Regular Expression Language Elements
• Backtracking in Regular Expressions
• Best practices for regular expressions in .NET

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);

public string Replace(string input, string replacement, int count, int startat);

member this.Replace : string * string * int * int -> string

Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

For more details about startat, see the Remarks section of Match(String, Int32).

The replacement parameter specifies the string that replaces each match and supports substitutions.

If count is negative, replacements continue to the end of the string.

See also

• Substitutions in Regular Expressions
• Regular Expression Language - Quick Reference

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);

public static string Replace(string input, string pattern, string replacement);

static member Replace : string * string * string -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

The static Replace(String, String, String) methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace(String, String).

The replacement parameter specifies the string that replaces each match in input. replacement can consist of any combination of literal text and substitutions. Substitutions are the only regular expression language elements that are recognized in a replacement pattern.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

Notes to Callers

This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

See also

• Substitutions in Regular Expressions
• Regular Expression Language Elements

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

This method is useful for replacing a regular expression match if any of the following conditions is true: the replacement string cannot readily be specified by a regular expression replacement pattern, the replacement string results from processing the matched string, or the replacement string results from conditional processing.

The method is equivalent to calling the Matches(String, String) method and passing each Match object in the returned MatchCollection to the evaluator delegate.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

Notes to Callers

This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. The recommended static method for evaluating and replacing a pattern match is Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), which lets you set the time-out interval.

See also

• MatchEvaluator
• Substitutions in Regular Expressions
• Regular Expression Language Elements

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);

public string Replace(string input, string replacement, int count);

member this.Replace : string * string * int -> string

Public Function Replace (input As String, replacement As String, count As Integer) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

The search begins at the start of the input string. The replacement parameter specifies the string that replaces each match and supports substitutions.

If count is negative, replacements continue to the end of the string.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

See also

• Regular Expression Language - Quick Reference
• Substitutions in Regular Expressions

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

This method is useful for replacing a regular expression match if any of the following conditions is true: the replacement string cannot readily be specified by a regular expression replacement pattern, the replacement string results from processing the matched string, or the replacement string results from conditional processing.

The method is equivalent to calling the Matches(String) method and passing each Match object in the returned MatchCollection to the evaluator delegate.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

See also

• MatchEvaluator
• Substitutions in Regular Expressions
• Regular Expression Language - Quick Reference

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);

public string Replace(string input, string replacement);

member this.Replace : string * string -> string

Public Function Replace (input As String, replacement As String) As String

Parameters

Returns

A new string that is identical to the input string, except that the replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

The search for the pattern begins at the beginning of the input string.

The replacement parameter specifies the string that replaces each match. replacement can consist of any combination of literal text and substitutions. Substitutions are the only regular expression language elements that are recognized in a replacement pattern.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

See also

• Regular Expression Language - Quick Reference
• Substitutions in Regular Expressions

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

Source:

Regex.Replace.cs

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parameters

Returns

A new string that is identical to the input string, except that a replacement string takes the place of each matched string. If the regular expression pattern is not matched in the current instance, the method returns the current instance unchanged.

Exceptions

Remarks

This method is useful for replacing a regular expression match if any of the following conditions is true: the replacement string cannot readily be specified by a regular expression replacement pattern, the replacement string results from processing the matched string, or the replacement string results from conditional processing.

The method is equivalent to calling the Matches(String) method and passing the first countMatch objects in the returned MatchCollection to the evaluator delegate.

If count is negative, replacements continue to the end of the string.

Because the method returns input unchanged if there is no match, you can use the ReferenceEquals(Object, Object) method to determine whether the method has made any replacements.

See also

• MatchEvaluator
• Substitutions in Regular Expressions
• Regular Expression Language - Quick Reference