Regex.Replace 메서드

정의

지정된 입력 문자열에서 정규식 패턴과 일치하는 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces strings that match a regular expression pattern with a specified replacement string.

오버로드

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 부분 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. 추가 매개 변수는 일치하는 항목이 없는 경우 제한 시간 간격과 일치 작업을 수정하는 옵션을 지정합니다.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, String, String, RegexOptions, TimeSpan)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. 추가 매개 변수는 일치하는 항목이 없는 경우 제한 시간 간격과 일치 작업을 수정하는 옵션을 지정합니다.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

Replace(String, MatchEvaluator, Int32, Int32)

지정된 입력 부분 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String, MatchEvaluator, RegexOptions)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. 지정한 옵션에 따라 일치 작업이 수정됩니다.Specified options modify the matching operation.

Replace(String, String, Int32, Int32)

지정된 입력 부분 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, String, String, RegexOptions)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. 지정한 옵션에 따라 일치 작업이 수정됩니다.Specified options modify the matching operation.

Replace(String, String, MatchEvaluator)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String, String)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

Replace(String, String, Int32)

지정된 입력 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

Replace(String, MatchEvaluator)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

Replace(String, String)

지정된 입력 문자열에서 정규식 패턴과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

Replace(String, MatchEvaluator, Int32)

지정된 입력 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 부분 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all substrings that match a specified regular expression with a string returned by a MatchEvaluator delegate. 추가 매개 변수는 일치하는 항목이 없는 경우 제한 시간 간격과 일치 작업을 수정하는 옵션을 지정합니다.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.A bitwise combination of enumeration values that provide options for matching.

matchTimeout
TimeSpan

시간 제한 간격이거나, 메서드에 시간 제한이 없어야 함을 나타내는 InfiniteMatchTimeout입니다.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 evaluatornull입니다.input, pattern, or evaluator is null.

optionsRegexOptions 값의 유효한 비트 조합이 아닌 경우options is not a valid bitwise combination of RegexOptions values.

또는-or- matchTimeout이 음수, 0 또는 약 24일보다 큰 경우matchTimeout is negative, zero, or greater than approximately 24 days.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 정규식을 사용 하 여 문자열에서 개별 단어를 추출한 다음 MatchEvaluator 대리자를 사용 하 여 단어의 개별 문자를 스크램블 하는 WordScramble 라는 메서드를 호출 합니다.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. 이렇게 하기 위해 WordScramble 메서드는 일치 하는 문자를 포함 하는 배열을 만듭니다.To do this, the WordScramble method creates an array that contains the characters in the match. 또한 병렬 배열을 채우는 임의의 부동 소수점 숫자를 사용 하 여 만듭니다.It also creates a parallel array that it populates with random floating-point numbers. 배열은 Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) 메서드를 호출 하 여 정렬 되 고 정렬 된 배열은 String 클래스 생성자에 대 한 인수로 제공 됩니다.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. 그러면 새로 만든이 문자열이 WordScramble 메서드에서 반환 됩니다.This newly created string is then returned by the WordScramble method. 정규식 패턴 \w+ 하나 이상의 단어 문자를 찾습니다. 정규식 엔진은 공백 문자와 같이 단어가 아닌 문자를 발견할 때까지 일치 항목에 문자를 계속 추가 합니다.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. Replace(String, String, MatchEvaluator, RegexOptions) 메서드에 대 한 호출에는 정규식 엔진에서 정규식 패턴 \w+ # Matches all the characters in a word.의 주석이 무시 되도록 RegexOptions.IgnorePatternWhitespace 옵션이 포함 되어 있습니다.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

설명

Regex.Replace(String, String, MatchEvaluator, RegexOptions) 메서드는 다음 조건 중 하나가 충족 되는 경우 정규식 일치를 대체 하는 데 유용 합니다.The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match if any of the following conditions is true:

  • 대체 문자열을 지정 하 여 정규식 대체 패턴에 의해 쉽게 수 없습니다.If the replacement string cannot readily be specified by a regular expression replacement pattern.

  • 대체 문자열에서 발생 하는 경우 일치 하는 문자열에서 일부 처리 수행 합니다.If the replacement string results from some processing performed on the matched string.

  • 대체 문자열 조건부 처리에서 발생 하는 경우.If the replacement string results from conditional processing.

메서드는 Regex.Matches(String, String, RegexOptions) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 각 Match 개체를 evaluator 대리자에 게 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

options 매개 변수에 대 한 RightToLeft 지정 하면 일치 하는 항목 검색은 입력 문자열의 끝에서 시작 하 여 왼쪽으로 이동 합니다. 그렇지 않으면 입력 문자열의 시작 부분에서 검색을 시작 하 고 오른쪽으로 이동 합니다.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.

matchTimeout 매개 변수는 제한 시간이 초과 되기 전에 패턴 일치 메서드가 일치 항목을 찾으려고 시도 하는 기간을 지정 합니다. 시간 제한 간격을 설정 하면 과도 한 역 추적을 사용 하는 정규식이 거의 일치 하는 항목을 포함 하는 입력을 처리할 때 응답 하지 않습니다.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. 자세한 내용은 정규식에 대 한 모범 사례역 추적을 참조 하세요.For more information, see Best Practices for Regular Expressions and Backtracking. 해당 시간 간격에 일치 하는 항목이 없는 경우이 메서드는 RegexMatchTimeoutException 예외를 throw 합니다.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout 메서드를 실행 하는 애플리케이션 도메인에 대해 정의 된 모든 기본 제한 시간 값을 재정의 합니다.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

호출자 참고

matchTimeout 매개 변수를 적절 한 값 (예: 2 초)으로 설정 하는 것이 좋습니다.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. InfiniteMatchTimeout를 지정 하 여 제한 시간을 사용 하지 않도록 설정 하는 경우 정규식 엔진은 약간 더 나은 성능을 제공 합니다.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.

추가 정보

Replace(String, String, String, RegexOptions, TimeSpan)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. 추가 매개 변수는 일치하는 항목이 없는 경우 제한 시간 간격과 일치 작업을 수정하는 옵션을 지정합니다.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

replacement
String

대체 문자열입니다.The replacement string.

options
RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

시간 제한 간격이거나, 메서드에 시간 제한이 없어야 함을 나타내는 InfiniteMatchTimeout입니다.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 replacementnull입니다.input, pattern, or replacement is null.

optionsRegexOptions 값의 유효한 비트 조합이 아닌 경우options is not a valid bitwise combination of RegexOptions values.

또는-or- matchTimeout이 음수, 0 또는 약 24일보다 큰 경우matchTimeout is negative, zero, or greater than approximately 24 days.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 Replace(String, String, String, RegexOptions, TimeSpan) 메서드를 사용 하 여 UNC 경로의 로컬 컴퓨터 및 드라이브 이름을 로컬 파일 경로로 바꿉니다.The following example uses the Replace(String, String, String, RegexOptions, TimeSpan) method to replace the local machine and drive names in a UNC path with a local file path. 정규식은 Environment.MachineName 속성을 사용 하 여 로컬 컴퓨터의 이름을 포함 하 고 Environment.GetLogicalDrives 메서드를 사용 하 여 논리 드라이브의 이름을 포함 합니다.The regular expression uses the Environment.MachineName property to include the name of the local computer and the Environment.GetLogicalDrives method to include the names of the logical drives. 모든 정규식 문자열 비교는 대/소문자 및 0.5 초에서 일치 하는 항목을 찾을 수 없는 경우 모든 단일 교체 작업 시간이 초과 됩니다.All regular expression string comparisons are case-insensitive, and any single replacement operation times out if a match cannot be found in 0.5 second. 예제를 성공적으로 실행 하려면 리터럴 문자열 "MyMachine" 로컬 컴퓨터 이름으로 바꿔야 합니다.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

정규식 패턴은 다음 식으로 정의 됩니다.The regular expression pattern is defined by the following expression:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

다음 테이블은 정규식 패턴이 해석되는 방법을 보여 줍니다.The following table shows how the regular expression pattern is interpreted.

무늬Pattern 설명Description
\\\\ 두 개의 연속 백슬래시 (\) 문자를 찾습니다.Match two consecutive backslash (\) characters. 백슬래시는 이스케이프 문자로 해석 하기 때문에 각 백슬래시는 다른 백슬래시로 이스케이프 되어야 합니다.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Environment.MachineName 속성이 반환 하는 문자열을 찾습니다.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* 마침표 (.) 문자 다음에 하나 이상의 단어 문자를 찾습니다.Match the period (.) character followed by one or more word characters. 이 일치 항목 0 번 이상 발생할 수 있습니다.This match can occur zero or more times. 일치 하는 하위 식이 캡처되지 않습니다.The matched subexpression is not captured.
\\ 백슬래시 (\) 문자를 찾습니다.Match a backslash (\) character.
([" + driveNames + "]) 개별 드라이브 문자도 이루어진 문자 클래스와 일치 합니다.Match the character class that consists of the individual drive letters. 이 항목은 첫 번째 캡처된 하위 식입니다.This match is the first captured subexpression.
\$ 리터럴 달러 기호 ($) 문자를 찾습니다.Match the literal dollar sign ($) character.

바꾸기 패턴 $1 전체 일치 항목을 캡처된 첫 번째 하위 식으로 바꿉니다.The replacement pattern $1 replaces the entire match with the first captured subexpression. 즉, 드라이브 문자를 사용 하 여 UNC 컴퓨터 및 드라이브 이름을 대체합니다.That is, it replaces the UNC machine and drive name with the drive letter.

설명

정적 Replace 메서드는 지정 된 정규식 패턴을 사용 하 여 Regex 개체를 생성 하 고 Replace인스턴스 메서드를 호출 하는 것과 같습니다.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. options 매개 변수에 대 한 RightToLeft 지정 하면 일치 하는 항목 검색은 입력 문자열의 끝에서 시작 하 여 왼쪽으로 이동 합니다. 그렇지 않으면 입력 문자열의 시작 부분에서 검색을 시작 하 고 오른쪽으로 이동 합니다.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.

replacement 매개 변수는 input에서 일치 하는 항목을 바꿀 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace each match in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

matchTimeout 매개 변수는 제한 시간이 초과 되기 전에 패턴 일치 메서드가 일치 항목을 찾으려고 시도 하는 기간을 지정 합니다. 시간 제한 간격을 설정 하면 과도 한 역 추적을 사용 하는 정규식이 근접 한 일치 항목을 포함 하는 입력을 처리할 때 응답을 중지 하는 데 방해가 되지 않습니다.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. 자세한 내용은 정규식에 대 한 모범 사례역 추적을 참조 하세요.For more information, see Best Practices for Regular Expressions and Backtracking. 해당 시간 간격에 일치 하는 항목이 없는 경우이 메서드는 RegexMatchTimeoutException 예외를 throw 합니다.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout 메서드를 실행 하는 애플리케이션 도메인에 대해 정의 된 모든 기본 제한 시간 값을 재정의 합니다.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

호출자 참고

matchTimeout 매개 변수를 적절 한 값 (예: 2 초)으로 설정 하는 것이 좋습니다.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. InfiniteMatchTimeout를 지정 하 여 제한 시간을 사용 하지 않도록 설정 하는 경우 정규식 엔진은 약간 더 나은 성능을 제공 합니다.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.

추가 정보

Replace(String, MatchEvaluator, Int32, Int32)

지정된 입력 부분 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

바꾸기를 하는 최대 횟수입니다.The maximum number of times the replacement will occur.

startat
Int32

입력 문자열에서 검색을 시작할 문자 위치입니다.The character position in the input string where the search begins.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 evaluatornull인 경우input or evaluator is null.

startat이 0보다 작거나 input의 길이보다 큰 경우startat is less than zero or greater than the length of input.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

설명

Regex.Replace(String, MatchEvaluator, Int32, Int32) 메서드는 다음 조건 중 하나가 충족 되는 경우 정규식 일치를 대체 하는 데 유용 합니다.The Regex.Replace(String, MatchEvaluator, Int32, Int32) 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 some processing done on the matched string.

  • 조건부 처리의 대체 문자열 결과입니다.The replacement string results from conditional processing.

메서드는 Regex.Matches(String, Int32) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 첫 번째 countMatch 개체를 evaluator 대리자에 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String, Int32) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern defined by the constructor for the current Regex object.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, String, MatchEvaluator, RegexOptions)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate. 지정한 옵션에 따라 일치 작업이 수정됩니다.Specified options modify the matching operation.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

options
RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.A bitwise combination of the enumeration values that provide options for matching.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 evaluatornull입니다.input, pattern, or evaluator is null.

optionsRegexOptions 값의 유효한 비트 조합이 아닌 경우options is not a valid bitwise combination of RegexOptions values.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 정규식을 사용 하 여 문자열에서 개별 단어를 추출한 다음 MatchEvaluator 대리자를 사용 하 여 단어의 개별 문자를 스크램블 하는 WordScramble 라는 메서드를 호출 합니다.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. 이렇게 하기 위해 WordScramble 메서드는 일치 하는 문자를 포함 하는 배열을 만듭니다.To do this, the WordScramble method creates an array that contains the characters in the match. 또한 병렬 배열을 채우는 임의의 부동 소수점 숫자를 사용 하 여 만듭니다.It also creates a parallel array that it populates with random floating-point numbers. 배열은 Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) 메서드를 호출 하 여 정렬 되 고 정렬 된 배열은 String 클래스 생성자에 대 한 인수로 제공 됩니다.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. 그러면 새로 만든이 문자열이 WordScramble 메서드에서 반환 됩니다.This newly created string is then returned by the WordScramble method. 정규식 패턴 \w+ 하나 이상의 단어 문자를 찾습니다. 정규식 엔진은 공백 문자와 같이 단어가 아닌 문자를 발견할 때까지 일치 항목에 문자를 계속 추가 합니다.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character. Replace(String, String, MatchEvaluator, RegexOptions) 메서드에 대 한 호출에는 정규식 엔진에서 정규식 패턴 \w+ # Matches all the characters in a word.의 주석이 무시 되도록 RegexOptions.IgnorePatternWhitespace 옵션이 포함 되어 있습니다.The call to the Replace(String, String, MatchEvaluator, RegexOptions) method includes the RegexOptions.IgnorePatternWhitespace option so that the comment in the regular expression pattern \w+ # Matches all the characters in a word. is ignored by the regular expression engine.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

설명

Regex.Replace(String, String, MatchEvaluator, RegexOptions) 메서드는 다음 조건 중 하나라도 충족 되는 경우에서 정규식 일치를 바꾸는 데 유용 합니다.The Regex.Replace(String, String, MatchEvaluator, RegexOptions) method is useful for replacing a regular expression match in 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 some processing done on the matched string.

  • 조건부 처리의 대체 문자열 결과입니다.The replacement string results from conditional processing.

메서드는 Regex.Matches(String, String, RegexOptions) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 각 Match 개체를 evaluator 대리자에 게 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String, String, RegexOptions) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

options 매개 변수에 대 한 RightToLeft 지정 하면 일치 하는 항목 검색은 입력 문자열의 끝에서 시작 하 여 왼쪽으로 이동 합니다. 그렇지 않으면 입력 문자열의 시작 부분에서 검색을 시작 하 고 오른쪽으로 이동 합니다.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.

RegexMatchTimeoutException 바꾸기 작업의 실행 시간이 메서드가 호출 되는 애플리케이션 도메인에 대 한 지정 된 시간 제한 간격을 초과 하는 경우 예외가 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. 시간 제한이 없으며 애플리케이션 도메인의 속성에 정의 된 제한 시간 값이 아니면 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, String, Int32, Int32)

지정된 입력 부분 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input substring, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

replacement
String

대체 문자열입니다.The replacement string.

count
Int32

바꾸기를 하는 최대 횟수입니다.Maximum number of times the replacement can occur.

startat
Int32

입력 문자열에서 검색을 시작할 문자 위치입니다.The character position in the input string where the search begins.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 replacementnull인 경우input or replacement is null.

startat이 0보다 작거나 input의 길이보다 큰 경우startat is less than zero or greater than the length of input.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 문자열의 첫 번째 줄을 제외한 모든 double-spaces 합니다.The following example double-spaces all but the first line of a string. 텍스트 줄과 일치 하는 정규식 패턴 ^.*$를 정의 하 고, Match(String) 메서드를 사용 하 여 문자열의 첫 번째 줄과 일치 시키고, Match.IndexMatch.Count 속성을 사용 하 여 두 번째 줄의 시작 위치를 확인 합니다.It defines a regular expression pattern, ^.*$, that matches a line of text, calls the Match(String) method to match the first line of the string, and uses the Match.Index and Match.Count properties to determine the starting position of the second line.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

정규식 패턴 ^.*$ 는 다음 테이블과 같이 정의됩니다.The regular expression pattern ^.*$ is defined as shown in the following table.

무늬Pattern 설명Description
^ 줄의 시작을 찾습니다.Match the start of a line. Regex 개체는 RegexOptions.Multiline 옵션을 사용 하 여 인스턴스화되어 있습니다. 그렇지 않으면이 문자 클래스는 입력 문자열의 시작 부분과만 일치 합니다.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)
.* 임의의 문자를 0회 이상 찾습니다.Match any character zero or more times.
$ 줄의 끝을 찾습니다.Match the end of a line. Regex 개체는 RegexOptions.Multiline 옵션을 사용 하 여 인스턴스화되어 있습니다. 그렇지 않으면이 문자 클래스는 입력 문자열의 시작 부분과만 일치 합니다.)(Note that the Regex object was instantiated by using the RegexOptions.Multiline option; otherwise, this character class would only match the beginning of the input string.)

대체 문자열 (의 C#vbCrLf + "$&" Visual Basic에서 "\n$&")은 일치 하는 문자열 앞에 새 줄을 추가 합니다.The replacement string (vbCrLf + "$&" in Visual Basic, "\n$&" in C#) adds a new line before the matched string. C# 예제의 \n는 C# 컴파일러에서 줄 바꿈 문자로 해석 됩니다. 정규식 문자 이스케이프를 나타내지 않습니다.Note that \n in the C# example is interpreted as the newline character by the C# compiler; it does not represent a regular expression character escape.

설명

일치 항목에 대 한 검색은 startat 매개 변수로 지정 된 위치에 있는 input 문자열에서 시작 됩니다.The search for matches starts in the input string at the position specified by the startat parameter. 정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern defined by the constructor for the current Regex object. count 음수 이면 대체가 계속 문자열의 끝 부분으로 이동 합니다.If count is negative, replacements continue to the end of the string. count 일치 하는 항목 수를 초과 하는 경우 모든 항목이 바뀝니다.If count exceeds the number of matches, all matches are replaced.

replacement 매개 변수는 input에서 일치 하는 항목을 바꿀 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace each match in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, String, String, RegexOptions)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string. 지정한 옵션에 따라 일치 작업이 수정됩니다.Specified options modify the matching operation.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

replacement
String

대체 문자열입니다.The replacement string.

options
RegexOptions

일치 옵션을 제공하는 열거형 값의 비트 조합입니다.A bitwise combination of the enumeration values that provide options for matching.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 replacementnull입니다.input, pattern, or replacement is null.

optionsRegexOptions 값의 유효한 비트 조합이 아닌 경우options is not a valid bitwise combination of RegexOptions values.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 Replace(String, String, String, RegexOptions) 메서드를 사용 하 여 UNC 경로의 로컬 컴퓨터 및 드라이브 이름을 로컬 파일 경로로 바꿉니다.The following example uses the Replace(String, String, String, RegexOptions) method to replace the local machine and drive names in a UNC path with a local file path. 정규식은 Environment.MachineName 속성을 사용 하 여 로컬 컴퓨터의 이름을 포함 하 고 Environment.GetLogicalDrives 메서드를 사용 하 여 논리 드라이브의 이름을 포함 합니다.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. 모든 정규식 문자열 비교가 대/소문자를 구분 하지 않습니다.All regular expression string comparisons are case-insensitive. 예제를 성공적으로 실행 하려면 리터럴 문자열 "MyMachine" 로컬 컴퓨터 이름으로 바꿔야 합니다.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

정규식 패턴은 다음 식으로 정의 됩니다.The regular expression pattern is defined by the following expression:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

다음 테이블은 정규식 패턴이 해석되는 방법을 보여 줍니다.The following table shows how the regular expression pattern is interpreted.

무늬Pattern 설명Description
\\\\ 두 개의 연속 백슬래시 (\) 문자를 찾습니다.Match two consecutive backslash (\) characters. 백슬래시는 이스케이프 문자로 해석 하기 때문에 각 백슬래시는 다른 백슬래시로 이스케이프 되어야 합니다.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
+ Environment.MachineName + Environment.MachineName 속성이 반환 하는 문자열을 찾습니다.Match the string that is returned by the Environment.MachineName property.
(?:\.\w+)* 마침표 (.) 문자 다음에 하나 이상의 단어 문자를 찾습니다.Match the period (.) character followed by one or more word characters. 이 일치 항목 0 번 이상 발생할 수 있습니다.This match can occur zero or more times. 일치 하는 하위 식이 캡처되지 않습니다.The matched subexpression is not captured.
\\ 백슬래시 (\) 문자를 찾습니다.Match a backslash (\) character.
([" + driveNames + "]) 개별 드라이브 문자도 이루어진 문자 클래스와 일치 합니다.Match the character class that consists of the individual drive letters. 이 항목은 첫 번째 캡처된 하위 식입니다.This match is the first captured subexpression.
\$ 리터럴 달러 기호 ($) 문자를 찾습니다.Match the literal dollar sign ($) character.

바꾸기 패턴 $1 전체 일치 항목을 캡처된 첫 번째 하위 식으로 바꿉니다.The replacement pattern $1 replaces the entire match with the first captured subexpression. 즉, 드라이브 문자를 사용 하 여 UNC 컴퓨터 및 드라이브 이름을 대체합니다.That is, it replaces the UNC machine and drive name with the drive letter.

설명

정적 Replace 메서드는 지정 된 정규식 패턴을 사용 하 여 Regex 개체를 생성 하 고 Replace인스턴스 메서드를 호출 하는 것과 같습니다.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. options 매개 변수에 대 한 RightToLeft 지정 하면 일치 하는 항목 검색은 입력 문자열의 끝에서 시작 하 여 왼쪽으로 이동 합니다. 그렇지 않으면 입력 문자열의 시작 부분에서 검색을 시작 하 고 오른쪽으로 이동 합니다.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.

replacement 매개 변수는 input에서 일치 하는 항목을 바꿀 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace each match in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

RegexMatchTimeoutException 바꾸기 작업의 실행 시간이 메서드가 호출 되는 애플리케이션 도메인에 대 한 지정 된 시간 제한 간격을 초과 하는 경우 예외가 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. 시간 제한이 없으며 애플리케이션 도메인의 속성에 정의 된 제한 시간 값이 아니면 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

호출자 참고

이 메서드는 호출 되는 애플리케이션 도메인의 기본 제한 시간 값에 해당 간격이 지난 후 시간이 합니다.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. 애플리케이션 도메인에 값에 대 한 제한 시간 값을 정의 되지 않은 경우 InfiniteMatchTimeout, 메서드 시간 초과 방지 하는는 데 사용 됩니다.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. 패턴 일치를 바꾸기 위한 권장 되는 정적 메서드는 제한 시간 간격을 설정할 수 있는 Replace(String, String, String, RegexOptions, TimeSpan)입니다.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

추가 정보

Replace(String, String, MatchEvaluator)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that a replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 evaluatornull입니다.input, pattern, or evaluator is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 정규식을 사용 하 여 문자열에서 개별 단어를 추출한 다음 MatchEvaluator 대리자를 사용 하 여 단어의 개별 문자를 스크램블 하는 WordScramble 라는 메서드를 호출 합니다.The following example uses a regular expression to extract the individual words from a string, and then uses a MatchEvaluator delegate to call a method named WordScramble that scrambles the individual letters in the word. 이렇게 하기 위해 WordScramble 메서드는 일치 하는 문자를 포함 하는 배열을 만듭니다.To do this, the WordScramble method creates an array that contains the characters in the match. 또한 병렬 배열을 채우는 임의의 부동 소수점 숫자를 사용 하 여 만듭니다.It also creates a parallel array that it populates with random floating-point numbers. 배열은 Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) 메서드를 호출 하 여 정렬 되 고 정렬 된 배열은 String 클래스 생성자에 대 한 인수로 제공 됩니다.The arrays are sorted by calling the Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) method, and the sorted array is provided as an argument to a String class constructor. 그러면 새로 만든이 문자열이 WordScramble 메서드에서 반환 됩니다.This newly created string is then returned by the WordScramble method. 정규식 패턴 \w+ 하나 이상의 단어 문자를 찾습니다. 정규식 엔진은 공백 문자와 같이 단어가 아닌 문자를 발견할 때까지 일치 항목에 문자를 계속 추가 합니다.The regular expression pattern \w+ matches one or more word characters; the regular expression engine will continue to add characters to the match until it encounters a non-word character, such as a white-space character.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase
Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

설명

Regex.Replace(String, String, MatchEvaluator) 메서드는 다음 조건 중 하나가 충족 되는 경우 정규식 일치를 대체 하는 데 유용 합니다.The Regex.Replace(String, String, MatchEvaluator) 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 some processing done on the matched string.

  • 조건부 처리의 대체 문자열 결과입니다.The replacement string results from conditional processing.

메서드는 Regex.Matches(String, String) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 각 Match 개체를 evaluator 대리자에 게 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String, String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

RegexMatchTimeoutException 바꾸기 작업의 실행 시간이 메서드가 호출 되는 애플리케이션 도메인에 대 한 지정 된 시간 제한 간격을 초과 하는 경우 예외가 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. 시간 제한이 없으며 애플리케이션 도메인의 속성에 정의 된 제한 시간 값이 아니면 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

호출자 참고

이 메서드는 호출 되는 애플리케이션 도메인의 기본 제한 시간 값에 해당 간격이 지난 후 시간이 합니다.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. 애플리케이션 도메인에 값에 대 한 제한 시간 값을 정의 되지 않은 경우 InfiniteMatchTimeout, 메서드 시간 초과 방지 하는는 데 사용 됩니다.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. 패턴 일치를 평가 하 고 대체 하는 데 권장 되는 정적 메서드는 제한 시간 간격을 설정할 수 있는 Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)입니다.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.

추가 정보

Replace(String, String, String)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a specified replacement string.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

pattern
String

일치 항목을 찾을 정규식 패턴입니다.The regular expression pattern to match.

replacement
String

대체 문자열입니다.The replacement string.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.A new string that is identical to the input string, except that the replacement string takes the place of each matched string. 현재 인스턴스에서 pattern이 일치하지 않으면 메서드가 변경되지 않은 현재 인스턴스를 반환합니다.If pattern is not matched in the current instance, the method returns the current instance unchanged.

예외

정규식 구문 분석 오류가 발생한 경우A regular expression parsing error occurred.

input, pattern 또는 replacementnull입니다.input, pattern, or replacement is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 하나 이상의 공백 문자와 일치 하는 정규식 \s+를 정의 합니다.The following example defines a regular expression, \s+, that matches one or more white-space characters. 바꾸기 문자열 "", 단일 공백 문자로 바꿉니다.The replacement string, " ", replaces them with a single space character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

다음 예제에서는 Replace(String, String, String) 메서드를 사용 하 여 UNC 경로의 로컬 컴퓨터 및 드라이브 이름을 로컬 파일 경로로 바꿉니다.The following example uses the Replace(String, String, String) method to replace the local machine and drive names in a UNC path with a local file path. 정규식은 Environment.MachineName 속성을 사용 하 여 로컬 컴퓨터의 이름을 포함 하 고 Environment.GetLogicalDrives 메서드를 사용 하 여 논리 드라이브의 이름을 포함 합니다.The regular expression uses the Environment.MachineName property to include the name of the local computer, and the Environment.GetLogicalDrives method to include the names of the logical drives. 예제를 성공적으로 실행 하려면 리터럴 문자열 "MyMachine" 로컬 컴퓨터 이름으로 바꿔야 합니다.To run the example successfully, you should replace the literal string "MyMachine" with your local machine name.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

정규식 패턴은 다음 식으로 정의 됩니다.The regular expression pattern is defined by the following expression:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

다음 테이블은 정규식 패턴이 해석되는 방법을 보여 줍니다.The following table shows how the regular expression pattern is interpreted.

무늬Pattern 설명Description
\\\\ 두 개의 연속 백슬래시 (\) 문자를 찾습니다.Match two consecutive backslash (\) characters. 백슬래시는 이스케이프 문자로 해석 하기 때문에 각 백슬래시는 다른 백슬래시로 이스케이프 되어야 합니다.Because the backslash character is interpreted as the escape character, each backslash must be escaped with another backslash.
(?i:" + Environment.MachineName + ") Environment.MachineName 속성에서 반환 되는 문자열의 대/소문자를 구분 하지 않는 일치를 수행 합니다.Perform a case-insensitive match of the string that is returned by the Environment.MachineName property.
(?:\.\w+)* 마침표 (.) 문자 다음에 하나 이상의 단어 문자를 찾습니다.Match the period (.) character followed by one or more word characters. 이 일치 항목 0 번 이상 발생할 수 있습니다.This match can occur zero or more times. 일치 하는 하위 식이 캡처되지 않습니다.The matched subexpression is not captured.
\\ 백슬래시 (\) 문자를 찾습니다.Match a backslash (\) character.
((?i:[" + driveNames + "])) 개별 드라이브 문자로 구성 된 문자 클래스의 대/소문자를 구분 하지 않는 일치를 수행 합니다.Perform a case-insensitive match of the character class that consists of the individual drive letters. 이 항목은 첫 번째 캡처된 하위 식입니다.This match is the first captured subexpression.
\$ 리터럴 달러 기호 ($) 문자를 찾습니다.Match the literal dollar sign ($) character.

바꾸기 패턴 $1 전체 일치 항목을 캡처된 첫 번째 하위 식으로 바꿉니다.The replacement pattern $1 replaces the entire match with the first captured subexpression. 즉, 드라이브 문자를 사용 하 여 UNC 컴퓨터 및 드라이브 이름을 대체합니다.That is, it replaces the UNC machine and drive name with the drive letter.

설명

정적 Replace 메서드는 지정 된 정규식 패턴을 사용 하 여 Regex 개체를 생성 하 고 Replace인스턴스 메서드를 호출 하는 것과 같습니다.The static Replace methods are equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance method Replace.

pattern 매개 변수는 일치 하는 문자열을 설명 하는 기호로 정규식 언어 요소로 구성 됩니다.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. 정규식에 대 한 자세한 내용은 .NET Framework 정규식정규식 언어-빠른 참조를 참조 하세요.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference. 일치 항목에 대 한 검색은 input 문자열의 시작 부분에서 시작 됩니다.The search for matches starts at the beginning of the input string.

replacement 매개 변수는 input에서 일치 하는 항목을 바꿀 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace each match in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

RegexMatchTimeoutException 바꾸기 작업의 실행 시간이 메서드가 호출 되는 애플리케이션 도메인에 대 한 지정 된 시간 제한 간격을 초과 하는 경우 예외가 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified for the application domain in which the method is called. 시간 제한이 없으며 애플리케이션 도메인의 속성에 정의 된 제한 시간 값이 아니면 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

호출자 참고

이 메서드는 호출 되는 애플리케이션 도메인의 기본 제한 시간 값에 해당 간격이 지난 후 시간이 합니다.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. 애플리케이션 도메인에 값에 대 한 제한 시간 값을 정의 되지 않은 경우 InfiniteMatchTimeout, 메서드 시간 초과 방지 하는는 데 사용 됩니다.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. 패턴 일치를 바꾸기 위한 권장 되는 정적 메서드는 제한 시간 간격을 설정할 수 있는 Replace(String, String, String, RegexOptions, TimeSpan)입니다.The recommended static method for replacing a pattern match is Replace(String, String, String, RegexOptions, TimeSpan), which lets you set the time-out interval.

추가 정보

Replace(String, String, Int32)

지정된 입력 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a specified replacement string.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

replacement
String

대체 문자열입니다.The replacement string.

count
Int32

바꾸기를 하는 최대 횟수입니다.The maximum number of times the replacement can occur.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 replacementnull인 경우input or replacement is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 단일 문자를 사용 하 여 중복 된 문자의 처음 5 개 항목을 바꿉니다.The following example replaces the first five occurrences of duplicated characters with a single character. 정규식 패턴 (\w)\1는 단일 문자를 연속 해 서 검색 하 고 첫 번째 항목을 첫 번째 캡처링 그룹에 할당 합니다.The regular expression pattern (\w)\1 matches consecutive occurrences of a single character and assigns the first occurrence to the first capturing group. 바꾸기 패턴 $1 전체 일치 항목을 캡처된 첫 번째 그룹으로 바꿉니다.The replacement pattern $1 replaces the entire match with the first captured group.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

설명

일치 항목에 대 한 검색은 input 문자열의 시작 부분에서 시작 됩니다.The search for matches starts at the beginning of the input string. 정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern that is defined by the constructor for the current Regex object. count 음수 이면 대체가 계속 문자열의 끝 부분으로 이동 합니다.If count is negative, replacements continue to the end of the string. count 일치 하는 항목 수를 초과 하는 경우 모든 항목이 바뀝니다.If count exceeds the number of matches, all matches are replaced.

replacement 매개 변수는 input에서 처음 count 일치 항목을 대체할 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace the first count matches in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, MatchEvaluator)

지정된 입력 문자열에서 지정된 정규식과 일치하는 모든 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces all strings that match a specified regular expression with a string returned by a MatchEvaluator delegate.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 evaluatornull인 경우input or evaluator is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 코드 예제는 원래 문자열을 표시, 원래 문자열에서 각 단어와 일치, 첫 번째 문자의 각 일치 항목을 표시 한 다음 대문자로 변환된 된 문자열을 변환 합니다.The following code example displays an original string, matches each word in the original string, converts the first character of each match to uppercase, then displays the converted string.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]
Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

설명

Regex.Replace(String, MatchEvaluator) 메서드는 다음 조건 중 하나가 충족 되는 경우 정규식 일치를 대체 하는 데 유용 합니다.The Regex.Replace(String, MatchEvaluator) 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 some processing done on the matched string.

  • 조건부 처리의 대체 문자열 결과입니다.The replacement string results from conditional processing.

메서드는 Regex.Matches(String) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 각 Match 개체를 evaluator 대리자에 게 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String) method and passing each Match object in the returned MatchCollection collection to the evaluator delegate.

정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern defined by the constructor for the current Regex object.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, String)

지정된 입력 문자열에서 정규식 패턴과 일치하는 모든 문자열을 지정된 대체 문자열로 바꿉니다.In a specified input string, replaces all strings that match a regular expression pattern with a specified replacement string.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

replacement
String

대체 문자열입니다.The replacement string.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 replacementnull인 경우input or replacement is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예제에서는 하나 이상의 공백 문자와 일치 하는 정규식 \s+를 정의 합니다.The following example defines a regular expression, \s+, that matches one or more white-space characters. 바꾸기 문자열 "", 단일 공백 문자로 바꿉니다.The replacement string, " ", replaces them with a single space character.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

다음 예제에서는 숫자 값에서 선행 또는 후행 통화 기호를 제거 하는 정규식, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?및 바꾸기 패턴 $2을 정의 합니다.The following example defines a regular expression, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, and a replacement pattern, $2, that removes either a leading or a trailing currency symbol from a numeric value.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

정규식은 다음 표와 같이 해석됩니다.The regular expression is interpreted as shown in the following table.

무늬Pattern 설명Description
\p{Sc} 통화 기호를 찾습니다.Match a currency symbol. {Sc} 유니코드 기호, 통화 범주에 속하는 모든 문자를 나타냅니다.{Sc} denotes any character that is a member of the Unicode Symbol, Currency category.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
(\p{Sc}\s?)? 0 개 또는 한 개의 조합에 통화 기호 뒤에 0 개 이상의 공백 문자가 일치 합니다.Match zero or one occurrence of the combination of a currency symbol followed by zero or one white-space character. 이 그룹은 첫 번째 캡처링 그룹입니다.This is the first capturing group.
\d+ 하나 이상의 10진수 숫자가 일치하는지 확인합니다.Match one or more decimal digits.
\.? 마침표 (소수 구분 기호 문자로 사용) 0 개 또는 1 번을 찾습니다.Match zero or one occurrence of a period (used as a decimal separator character).
((?<=\.)\d+)? 이전 문자는 기간을 사용 하는 경우 하나 이상의 10 진수를 찾습니다.If a period is the previous character, match one or more decimal digits. 이 패턴은 0 개 또는 한 번 일치할 수 있습니다.This pattern can be matched either zero or one time.
(\d+\.?((?<=\.)\d+)?) 하나 이상의 10 진수 뒤에 마침표와 추가 10 진수가 패턴과 일치 합니다.Match the pattern of one or more decimal digits followed by an optional period and additional decimal digits. 이 그룹은 두 번째 캡처링 그룹입니다.This is the second capturing group. Replace(String, String) 메서드에 대 한 호출은 전체 일치 항목을이 캡처된 그룹의 값으로 바꿉니다.The call to the Replace(String, String) method replaces the entire match with the value of this captured group.
(?(1)|\s?\p{Sc})? 첫 번째 캡처된 그룹이 있는 경우 빈 문자열을 일치 합니다.If the first captured group exists, match an empty string. 그렇지 않은 경우 통화 기호 뒤에 0 개 이상의 공백 문자를 일치 합니다.Otherwise, match zero or one white-space character followed by a currency symbol.

설명

일치 항목에 대 한 검색은 input 문자열의 시작 부분에서 시작 됩니다.The search for matches starts at the beginning of the input string. 정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern defined by the constructor for the current Regex object.

replacement 매개 변수는 input에서 일치 하는 항목을 바꿀 문자열을 지정 합니다.The replacement parameter specifies the string that is to replace each match in input. replacement 리터럴 텍스트와 대체조합으로 구성 될 수 있습니다.replacement can consist of any combination of literal text and substitutions. 예를 들어, 바꾸기 패턴 a*${test}b는 문자열 "a *"와 test 캡처링 그룹 (있는 경우)과 일치 하는 부분 문자열을 삽입 한 다음 문자열 "b"를 삽입 합니다.For example, the replacement pattern a*${test}b inserts the string "a*" followed by the substring that is matched by the test capturing group, if any, followed by the string "b". * 문자는 메타 바꾸기 패턴으로 인식 되지 않습니다.The * character is not recognized as a metacharacter within a replacement pattern.

참고

대체는 바꾸기 패턴에서 인식 되는 유일한 정규식 언어 요소입니다.Substitutions are the only regular expression language elements that are recognized in a replacement pattern. 문자 이스케이프를 비롯 한 다른 정규식 언어 요소는 모두 정규식 패턴 에서만 허용 되며 바꾸기 패턴에서는 인식 되지 않습니다.All other regular expression language elements, including character escapes, are allowed in regular expression patterns only and are not recognized in replacement patterns.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

Replace(String, MatchEvaluator, Int32)

지정된 입력 문자열에서 정규식 패턴과 일치하는 지정된 최대 개수의 문자열을 MatchEvaluator 대리자가 반환한 문자열로 바꿉니다.In a specified input string, replaces a specified maximum number of strings that match a regular expression pattern with a string returned by a MatchEvaluator delegate.

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

매개 변수

input
String

일치 항목을 검색할 문자열입니다.The string to search for a match.

evaluator
MatchEvaluator

각각의 일치 항목을 검사하여 원래 일치하는 문자열 또는 대체 문자열을 반환하는 사용자 지정 메서드입니다.A custom method that examines each match and returns either the original matched string or a replacement string.

count
Int32

바꾸기를 하는 최대 횟수입니다.The maximum number of times the replacement will occur.

반환

입력 문자열과 동일한 새 문자열입니다. 단, 대체 문자열은 일치하는 각 문자열을 대체합니다.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.

예외

input 또는 evaluatornull인 경우input or evaluator is null.

시간이 초과되었습니다.A time-out occurred. 시간 제한에 대한 자세한 내용은 설명 섹션을 참조하세요.For more information about time-outs, see the Remarks section.

예제

다음 예에서는 의도적으로 잘못 입력 목록의 단어의 절반에 정규식을 사용 합니다.The following example uses a regular expression to deliberately misspell half of the words in a list. 정규식 \w*(ie|ei)\w* 사용 하 여 문자 "ie" 또는 "ei"를 포함 하는 단어를 찾습니다.It uses the regular expression \w*(ie|ei)\w* to match words that include the characters "ie" or "ei". 일치 하는 단어의 처음 절반을 ReverseLetter 메서드에 전달 합니다. 그러면이 메서드는 Replace(String, String, String, RegexOptions) 메서드를 사용 하 여 일치 하는 문자열에서 "i" 및 "e"를 역방향으로 바꿉니다.It passes the first half of the matching words to the ReverseLetter method, which, in turn, uses the Replace(String, String, String, RegexOptions) method to reverse "i" and "e" in the matched string. 나머지 단어 그대로 유지 됩니다.The remaining words remain unchanged.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

\w*(ie|ei)\w* 정규식은 다음 테이블과 같이 정의됩니다.The regular expression \w*(ie|ei)\w* is defined as shown in the following table.

무늬Pattern 설명Description
\w* 0개 이상의 단어 문자를 찾습니다.Match zero or more word characters.
(ie|ei) "예" 또는 "ei"를 찾습니다.Match either "ie" or "ei".
\w* 0개 이상의 단어 문자를 찾습니다.Match zero or more word characters.

ReverseLetter 메서드의 정규식 패턴 ([ie])([ie])는 diphthong "ie" 또는 "ei"의 첫 번째 "i" 또는 "e"와 일치 하 고 첫 번째 캡처링 그룹에 문자를 할당 합니다.The regular expression pattern ([ie])([ie]) in the ReverseLetter method matches the first "i" or "e" in the diphthong "ie" or "ei" and assigns the letter to the first capturing group. 두 번째 "i" 또는 "e"와 일치 하 고 두 번째 캡처링 그룹에는 문자를 할당 합니다.It matches the second "i" or "e" and assigns the letter to the second capturing group. 그런 다음 $2$1대체 패턴으로 Replace(String, String, String) 메서드를 호출 하 여 두 문자를 반대로 바꿉니다.The two characters are then reversed by calling the Replace(String, String, String) method with the replacement pattern $2$1.

설명

Regex.Replace(String, MatchEvaluator, Int32) 메서드는 다음 조건 중 하나가 충족 되는 경우 정규식 일치를 대체 하는 데 유용 합니다.The Regex.Replace(String, MatchEvaluator, Int32) 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 some processing done on the matched string.

  • 조건부 처리의 대체 문자열 결과입니다.The replacement string results from conditional processing.

메서드는 Regex.Matches(String) 메서드를 호출 하 고 반환 된 MatchCollection 컬렉션의 첫 번째 countMatch 개체를 evaluator 대리자에 전달 하는 것과 같습니다.The method is equivalent to calling the Regex.Matches(String) method and passing the first countMatch objects in the returned MatchCollection collection to the evaluator delegate.

정규식은 현재 Regex 개체에 대 한 생성자에 의해 정의 되는 패턴입니다.The regular expression is the pattern defined by the constructor for the current Regex object.

evaluator 매개 변수는 사용자가 정의 하 고 각 일치 항목을 검사 하는 사용자 지정 메서드에 대 한 대리자입니다.The evaluator parameter is the delegate for a custom method that you define and that examines each match. 사용자 지정 메서드의 시그니처는 MatchEvaluator 대리자와 일치 해야 합니다.The custom method must have the following signature to match the MatchEvaluator delegate.

public string MatchEvaluatorMethod(Match match)
Public Function MatchEvaluatorMethod(match As Match) As String

사용자 지정 메서드는 일치 하는 입력을 대체 하는 문자열을 반환 합니다.Your custom method returns a string that replaces the matched input.

RegexMatchTimeoutException 예외는 바꾸기 작업의 실행 시간이 Regex.Regex(String, RegexOptions, TimeSpan) 생성자에서 지정한 시간 제한 간격을 초과 하는 경우에 throw 됩니다.The RegexMatchTimeoutException exception is thrown if the execution time of the replacement operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 생성자를 호출할 때 시간 제한 간격을 설정 하지 않으면, 작업이 있는 애플리케이션 도메인에 설정 된 제한 시간 값을 초과 하면 예외가 throw 되는 Regex 개체가 만들어집니다.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. 제한 시간에 정의 된 경우는 Regex 생성자 호출 또는 애플리케이션 도메인의 속성 또는 시간 제한 값이 Regex.InfiniteMatchTimeout, 예외가 throw 되지 않습니다If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown

일치 하는 항목이 없는 경우 메서드는 변경 되지 않은 input 반환 하기 때문에 Object.ReferenceEquals 메서드를 사용 하 여 메서드가 입력 문자열에 대 한 대체를 수행 했는지 여부를 확인할 수 있습니다.Because the method returns input unchanged if there is no match, you can use the Object.ReferenceEquals method to determine whether the method has made any replacements to the input string.

추가 정보

적용 대상