Regex 클래스

정의

변경할 수 없는 정규식을 나타냅니다.Represents an immutable regular expression.

public ref class Regex
public ref class Regex : System::Runtime::Serialization::ISerializable
public class Regex
public class Regex : System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
type Regex = class
    interface ISerializable
[<System.Serializable>]
type Regex = class
    interface ISerializable
Public Class Regex
Public Class Regex
Implements ISerializable
상속
Regex
파생
특성
구현

예제

다음 예제에서는 정규식을 사용 하 여 문자열에서 반복적으로 나타나는 단어를 확인 합니다.The following example uses a regular expression to check for repeated occurrences of words in a string. 정규식은 \b(?<word>\w+)\s+(\k<word>)\b 다음 표와 같이 해석 될 수 있습니다.The regular expression \b(?<word>\w+)\s+(\k<word>)\b can be interpreted as shown in the following table.

무늬Pattern 설명Description
\b 단어 경계에서 일치 항목 찾기를 시작 합니다.Start the match at a word boundary.
(?<word>\w+) 단어 경계까지 하나 이상의 단어 문자를 찾습니다.Match one or more word characters up to a word boundary. 이 캡처된 그룹의 이름을로 word 합니다.Name this captured group word.
\s+ 하나 이상의 공백 문자를 찾습니다.Match one or more white-space characters.
(\k<word>) 라는 캡처된 그룹을 찾습니다 word .Match the captured group that is named word.
\b 단어 경계를 찾습니다.Match a word boundary.
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
   // Define a regular expression for repeated words.
   Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );

   // Define a test string.        
   String^ text = "The the quick brown fox  fox jumps over the lazy dog dog.";

   // Find matches.
   MatchCollection^ matches = rx->Matches( text );

   // Report the number of matches found.
   Console::WriteLine( "{0} matches found.", matches->Count );

   // Report on each match.
   for each (Match^ match in matches)
   {
      String^ word = match->Groups["word"]->Value;
      int index = match->Index;
      Console::WriteLine("{0} repeated at position {1}", word, index);   
   }
}
using System;
using System.Text.RegularExpressions;

public class Test
{

    public static void Main ()
    {

        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54
Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

다음 예제에서는 정규식을 사용 하 여 문자열이 통화 값을 나타내는지 또는 통화 값을 나타내는 형식이 올바른지 여부를 확인 하는 방법을 보여 줍니다.The following example illustrates the use of a regular expression to check whether a string either represents a currency value or has the correct format to represent a currency value. 이 경우 정규식은 NumberFormatInfo.CurrencyDecimalSeparator CurrencyDecimalDigits NumberFormatInfo.CurrencySymbol NumberFormatInfo.NegativeSign NumberFormatInfo.PositiveSign 사용자의 현재 문화권에 대 한,,, 및 속성에서 동적으로 빌드됩니다.In this case, the regular expression is built dynamically from the NumberFormatInfo.CurrencyDecimalSeparator, CurrencyDecimalDigits, NumberFormatInfo.CurrencySymbol, NumberFormatInfo.NegativeSign, and NumberFormatInfo.PositiveSign properties for the user's current culture. 시스템의 현재 문화권이 en-us 인 경우 결과 정규식은 ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$ 입니다.If the system's current culture is en-US, the resulting regular expression is ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. 이 정규식은 다음 표와 같이 해석 될 수 있습니다.This regular expression can be interpreted as shown in the following table.

무늬Pattern 설명Description
^ 문자열의 시작 부분에서 시작 합니다.Start at the beginning of the string.
\s* 0개 이상의 공백 문자가 일치하는지 확인합니다.Match zero or more white-space characters.
[\+-]? 긍정 부호 또는 음수 부호 중 하나를 0 번 또는 한 번 찾습니다.Match zero or one occurrence of either the positive sign or the negative sign.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
\$? 달러 기호를 0 번 또는 한 번 찾습니다.Match zero or one occurrence of the dollar sign.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
\d* 0번 이상 나오는 10진수를 찾습니다.Match zero or more decimal digits.
\.? 0 개 또는 1 개의 소수점 기호를 찾습니다.Match zero or one decimal point symbol.
\d{2}? 두 개의 10 진수를 0 번 또는 한 번 찾습니다.Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} 소수점 기호로 구분 된 정수 및 소수 자릿수의 패턴을 한 번 이상 찾습니다.Match the pattern of integral and fractional digits separated by a decimal point symbol at least one time.
$ 문자열의 끝을 찾습니다.Match the end of the string.

이 경우 정규식은 유효한 통화 문자열이 그룹 구분 기호를 포함 하지 않고 현재 문화권의 속성에 의해 정의 된 소수 자릿수 또는 소수 자릿수를 포함 하 고 있다고 가정 합니다 CurrencyDecimalDigits .In this case, the regular expression assumes that a valid currency string does not contain group separator symbols, and that it has either no fractional digits or the number of fractional digits defined by the current culture's CurrencyDecimalDigits property.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get the current NumberFormatInfo object to build the regular 
      // expression pattern dynamically.
      NumberFormatInfo nfi = NumberFormatInfo.CurrentInfo;

      // Define the regular expression pattern.
      string pattern; 
      pattern = @"^\s*[";
      // Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
      // Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
      // Add integral digits to the pattern.
      pattern += @"(\d*";
      // Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
      // Add the fractional digits.
      pattern += @"\d{";
      // Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$";
      
      Regex rgx = new Regex(pattern);

      // Define some test strings.
      string[] tests = { "-42", "19.99", "0.001", "100 USD", 
                         ".34", "0.34", "1,052.21", "$10.62", 
                         "+1.43", "-$0.23" };

      // Check each test string against the regular expression.
      foreach (string test in tests)
      {
         if (rgx.IsMatch(test))
            Console.WriteLine("{0} is a currency value.", test);
         else
            Console.WriteLine("{0} is not a currency value.", test);
      }
   }
}
// The example displays the following output:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = NumberFormatInfo.CurrentInfo

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "}?){1}$"
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

이 예제의 정규식은 동적으로 작성 되므로 디자인 타임에 현재 문화권의 통화 기호, 10 진수 기호 또는 긍정 및 음수 부호가 정규식 엔진에서 정규식 언어 연산자로 잘못 해석 될 수 있는지 여부를 알 수 없습니다.Because the regular expression in this example is built dynamically, we do not know at design time whether the current culture's currency symbol, decimal sign, or positive and negative signs might be misinterpreted by the regular expression engine as regular expression language operators. 잘못 해석을 방지 하기 위해이 예제에서는 동적으로 생성 된 각 문자열을 Escape 메서드에 전달 합니다.To prevent any misinterpretation, the example passes each dynamically generated string to the Escape method.

설명

Regex클래스는 .NET Framework의 정규식 엔진을 나타냅니다.The Regex class represents the .NET Framework's regular expression engine. 이를 사용 하 여 많은 양의 텍스트를 빠르게 구문 분석 하 여 특정 문자 패턴을 찾을 수 있습니다. 텍스트 부분 문자열을 추출, 편집, 바꾸기 또는 삭제 하려면 그리고 추출 된 문자열을 컬렉션에 추가 하 여 보고서를 생성 합니다.It can be used to quickly parse large amounts of text to find specific character patterns; to extract, edit, replace, or delete text substrings; and to add the extracted strings to a collection to generate a report.

참고

특정 패턴을 따르는지 여부를 확인 하 여 문자열의 유효성을 검사 하는 것이 가장 중요 한 경우 클래스를 사용할 수 있습니다 System.Configuration.RegexStringValidator .If your primary interest is to validate a string by determining whether it conforms to a particular pattern, you can use the System.Configuration.RegexStringValidator class.

정규식을 사용 하려면 정규식 언어-빠른 참조에 설명 된 구문을 사용 하 여 텍스트 스트림에서 식별할 패턴을 정의 합니다.To use regular expressions, you define the pattern that you want to identify in a text stream by using the syntax documented in Regular Expression Language - Quick Reference. 다음으로 개체를 선택적으로 인스턴스화할 수 있습니다 Regex .Next, you can optionally instantiate a Regex object. 마지막으로, 정규식 패턴과 일치 하는 텍스트를 바꾸거나 패턴 일치를 식별 하는 등의 일부 작업을 수행 하는 메서드를 호출 합니다.Finally, you call a method that performs some operation, such as replacing text that matches the regular expression pattern, or identifying a pattern match.

참고

몇 가지 일반적인 정규식 패턴은 정규식 예를 참조 하세요.For some common regular expression patterns, see Regular Expression Examples. Regular-Expressions.info에 있는 것과 같은 정규식 패턴에 대 한 여러 온라인 라이브러리도 있습니다.There are also a number of online libraries of regular expression patterns, such as the one at Regular-Expressions.info.

클래스 사용에 대 한 자세한 내용은 Regex 이 항목의 다음 섹션을 참조 하십시오.For more information about using the Regex class, see the following sections in this topic:

정규식 언어에 대한 자세한 내용은 정규식 언어 - 빠른 참조를 참조하거나, 다음 브로슈어 중 하나를 다운로드하여 인쇄하세요.For more information about the regular expression language, see Regular Expression Language - Quick Reference or download and print one of these brochures:

Word(.docx) 형식의 빠른 참조Quick Reference in Word (.docx) format
PDF(.pdf) 형식의 빠른 참조Quick Reference in PDF (.pdf) format

Regex 및 문자열 메서드Regex vs. String Methods

클래스에는 System.String 텍스트와 패턴 일치를 수행 하는 데 사용할 수 있는 여러 검색 및 비교 메서드가 포함 되어 있습니다.The System.String class includes several search and comparison methods that you can use to perform pattern matching with text. 예를 들어, String.Contains String.EndsWith 및 메서드는 String.StartsWith 문자열 인스턴스에 지정 된 부분 문자열이 포함 되어 있는지 여부를 확인 하 고,, String.IndexOf String.IndexOfAny String.LastIndexOfString.LastIndexOfAny 메서드는 문자열에서 지정 된 부분 문자열의 시작 위치를 반환 합니다.For example, the String.Contains, String.EndsWith, and String.StartsWith methods determine whether a string instance contains a specified substring; and the String.IndexOf, String.IndexOfAny, String.LastIndexOf, and String.LastIndexOfAny methods return the starting position of a specified substring in a string. System.String특정 문자열을 검색할 때 클래스의 메서드를 사용 합니다.Use the methods of the System.String class when you are searching for a specific string. Regex문자열에서 특정 패턴을 검색할 때 클래스를 사용 합니다.Use the Regex class when you are searching for a specific pattern in a string. 자세한 내용 및 예제는 .NET Framework 정규식을 참조 하세요.For more information and examples, see .NET Framework Regular Expressions.

설명으로 돌아가기Back to Remarks

Static 및 Instance 메서드Static vs. Instance Methods

정규식 패턴을 정의한 후에는 다음 두 가지 방법 중 하나로 정규식 엔진에 제공할 수 있습니다.After you define a regular expression pattern, you can provide it to the regular expression engine in either of two ways:

  • Regex정규식을 나타내는 개체를 인스턴스화합니다.By instantiating a Regex object that represents the regular expression. 이렇게 하려면 정규식 패턴을 생성자에 전달 Regex 합니다.To do this, you pass the regular expression pattern to a Regex constructor. 개체는 변경할 수 없습니다 Regex . Regex 정규식을 사용 하 여 개체를 인스턴스화할 때 해당 개체의 정규식은 변경할 수 없습니다.A Regex object is immutable; when you instantiate a Regex object with a regular expression, that object's regular expression cannot be changed.

  • 정규식 및 텍스트를 모두 제공 하 여 static ( Shared Visual Basic) 메서드를 검색 합니다 Regex .By supplying both the regular expression and the text to search to a static (Shared in Visual Basic) Regex method. 이렇게 하면 개체를 명시적으로 만들지 않고도 정규식을 사용할 수 있습니다 Regex .This enables you to use a regular expression without explicitly creating a Regex object.

모든 Regex 패턴 식별 방법에는 정적 및 인스턴스 오버 로드가 포함 됩니다.All Regex pattern identification methods include both static and instance overloads.

정규식 엔진은 패턴을 사용 하려면 먼저 특정 패턴을 컴파일해야 합니다.The regular expression engine must compile a particular pattern before the pattern can be used. Regex개체는 변경할 수 없기 때문에이는 Regex 클래스 생성자 또는 정적 메서드를 호출할 때 발생 하는 일회성 프로시저입니다.Because Regex objects are immutable, this is a one-time procedure that occurs when a Regex class constructor or a static method is called. 단일 정규식을 반복적으로 컴파일할 필요가 없도록 정규식 엔진은 정적 메서드 호출에 사용 된 컴파일된 정규식을 캐시 합니다.To eliminate the need to repeatedly compile a single regular expression, the regular expression engine caches the compiled regular expressions used in static method calls. 결과적으로 정규식 패턴 일치 메서드는 정적 및 인스턴스 메서드에 대해 비슷한 성능을 제공 합니다.As a result, regular expression pattern-matching methods offer comparable performance for static and instance methods.

중요

.NET Framework 버전 1.0 및 1.1에서 인스턴스 또는 정적 메서드 호출에 사용 된 모든 컴파일된 정규식은 캐시 되었습니다.In the .NET Framework versions 1.0 and 1.1, all compiled regular expressions, whether they were used in instance or static method calls, were cached. .NET Framework 2.0부터 정적 메서드 호출에 사용 되는 정규식만 캐시 됩니다.Starting with the .NET Framework 2.0, only regular expressions used in static method calls are cached.

그러나 캐싱은 다음과 같은 두 가지 경우에 성능에 부정적인 영향을 줄 수 있습니다.However, caching can adversely affect performance in the following two cases:

  • 정규식을 많이 사용 하는 정적 메서드 호출을 사용 하는 경우When you use static method calls with a large number of regular expressions. 기본적으로 정규식 엔진은 가장 최근에 사용 된 15 개의 정적 정규식을 캐시 합니다.By default, the regular expression engine caches the 15 most recently used static regular expressions. 15 개 이상의 정적 정규식을 사용 하는 애플리케이션에서 일부 정규식을 컴파일해야 합니다.If your application uses more than 15 static regular expressions, some regular expressions must be recompiled. 이러한 재컴파일을 방지 하기 위해 속성을 늘릴 수 있습니다 Regex.CacheSize .To prevent this recompilation, you can increase the Regex.CacheSize property.

  • Regex이전에 컴파일된 정규식을 사용 하 여 새 개체를 인스턴스화하는 경우When you instantiate new Regex objects with regular expressions that have previously been compiled. 예를 들어 다음 코드에서는 정규식을 정의 하 여 텍스트 스트림에서 중복 된 단어를 찾습니다.For example, the following code defines a regular expression to locate duplicated words in a text stream. 예제에서는 단일 정규식을 사용 하지만 Regex 텍스트의 각 줄을 처리 하기 위해 새 개체를 인스턴스화합니다.Although the example uses a single regular expression, it instantiates a new Regex object to process each line of text. 이로 인해 루프가 반복 될 때마다 정규식이 다시 컴파일됩니다.This results in the recompilation of the regular expression with each iteration of the loop.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

    재컴파일을 방지 하려면 Regex 다음 재작성 된 예제와 같이이를 필요로 하는 모든 코드에서 액세스할 수 있는 단일 개체를 인스턴스화해야 합니다.To prevent recompilation, you should instantiate a single Regex object that is accessible to all code that requires it, as shown in the following rewritten example.

    StreamReader sr = new StreamReader(filename);
    string input;
    string pattern = @"\b(\w+)\s\1\b";
    Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
    
    while (sr.Peek() >= 0)
    {
       input = sr.ReadLine();
       MatchCollection matches = rgx.Matches(input);
       if (matches.Count > 0)
       {
          Console.WriteLine("{0} ({1} matches):", input, matches.Count);
          foreach (Match match in matches)
             Console.WriteLine("   " + match.Value);
       }
    }
    sr.Close();   
    
    Dim sr As New StreamReader(filename)
    Dim input As String
    Dim pattern As String = "\b(\w+)\s\1\b"
    Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
    Do While sr.Peek() >= 0
       input = sr.ReadLine()
       Dim matches As MatchCollection = rgx.Matches(input)
       If matches.Count > 0 Then
          Console.WriteLine("{0} ({1} matches):", input, matches.Count)
          For Each match As Match In matches
             Console.WriteLine("   " + match.Value)
          Next   
       End If
    Loop
    sr.Close()   
    

설명으로 돌아가기Back to Remarks

정규식 작업 수행Performing Regular Expression Operations

개체를 인스턴스화하고 Regex 메서드를 호출 하거나 정적 메서드를 호출 하도록 결정 한 경우 클래스는 Regex 다음과 같은 패턴 일치 기능을 제공 합니다.Whether you decide to instantiate a Regex object and call its methods or call static methods, the Regex class offers the following pattern-matching functionality:

  • 일치 항목의 유효성 검사Validation of a match. 메서드를 호출 IsMatch 하 여 일치 하는 항목이 있는지 여부를 확인 합니다.You call the IsMatch method to determine whether a match is present.

  • 단일 일치 항목을 검색 합니다.Retrieval of a single match. 메서드를 호출 하 여 Match Match 문자열 또는 문자열의 일부에서 첫 번째 일치 항목을 나타내는 개체를 검색 합니다.You call the Match method to retrieve a Match object that represents the first match in a string or in part of a string. 이후 일치 항목은 메서드를 호출 하 여 검색할 수 있습니다 Match.NextMatch .Subsequent matches can be retrieved by calling the Match.NextMatch method.

  • 모든 일치 항목을 검색 합니다.Retrieval of all matches. 메서드를 호출 하 여 Matches System.Text.RegularExpressions.MatchCollection 문자열 또는 문자열의 일부에서 찾은 모든 일치 항목을 나타내는 개체를 검색 합니다.You call the Matches method to retrieve a System.Text.RegularExpressions.MatchCollection object that represents all the matches found in a string or in part of a string.

  • 일치 하는 텍스트를 대체 합니다.Replacement of matched text. 메서드를 호출 Replace 하 여 일치 하는 텍스트를 바꿉니다.You call the Replace method to replace matched text. 정규식을 통해 대체 텍스트를 정의할 수도 있습니다.The replacement text can also be defined by a regular expression. 또한 일부 Replace 메서드는 MatchEvaluator 대체 텍스트를 프로그래밍 방식으로 정의할 수 있도록 하는 매개 변수를 포함 합니다.In addition, some of the Replace methods include a MatchEvaluator parameter that enables you to programmatically define the replacement text.

  • 입력 문자열의 일부에서 형성 되는 문자열 배열 만들기Creation of a string array that is formed from parts of an input string. 메서드를 호출 Split 하 여 정규식에 의해 정의 된 위치에서 입력 문자열을 분할 합니다.You call the Split method to split an input string at positions that are defined by the regular expression.

클래스는 패턴 일치 메서드 외에도 Regex 다음과 같은 몇 가지 특수 용도의 메서드를 포함 합니다.In addition to its pattern-matching methods, the Regex class includes several special-purpose methods:

  • Escape메서드는 정규식 또는 입력 문자열에서 정규식 연산자로 해석 될 수 있는 모든 문자를 이스케이프 합니다.The Escape method escapes any characters that may be interpreted as regular expression operators in a regular expression or input string.

  • Unescape메서드는 이러한 이스케이프 문자를 제거 합니다.The Unescape method removes these escape characters.

  • CompileToAssembly메서드는 미리 정의 된 정규식을 포함 하는 어셈블리를 만듭니다.The CompileToAssembly method creates an assembly that contains predefined regular expressions. .NET Framework에는 네임 스페이스의 특수 용도의 어셈블리 예제가 포함 되어 있습니다 System.Web.RegularExpressions .The .NET Framework contains examples of these special-purpose assemblies in the System.Web.RegularExpressions namespace.

설명으로 돌아가기Back to Remarks

Time-Out 값 정의Defining a Time-Out Value

.NET Framework는 패턴 일치에 상당한 기능과 유연성을 제공 하는 완전 한 기능을 갖춘 정규식 언어를 지원 합니다.The .NET Framework supports a full-featured regular expression language that provides substantial power and flexibility in pattern matching. 그러나 성능이 저하 되는 위험이 있으므로 강력 하 고 유연 합니다.However, the power and flexibility come at a cost: the risk of poor performance. 잘 작동 하는 정규식은 매우 쉽게 만들 수 있습니다.Regular expressions that perform poorly are surprisingly easy to create. 경우에 따라 과도 한 역 추적을 사용 하는 정규식 연산은 정규식 패턴과 거의 일치 하는 텍스트를 처리할 때 응답을 중지 하는 것 처럼 보일 수 있습니다.In some cases, regular expression operations that rely on excessive backtracking can appear to stop responding when they process text that nearly matches the regular expression pattern. .NET Framework 정규식 엔진에 대 한 자세한 내용은 정규식 동작의 세부정보를 참조 하세요.For more information about the .NET Framework regular expression engine, see Details of Regular Expression Behavior. 과도 한 역 추적에 대 한 자세한 내용은 역 추적을 참조 하세요.For more information about excessive backtracking, see Backtracking.

부터 .NET Framework 4.5.NET Framework 4.5 정규식 일치에 대 한 시간 제한 간격을 정의할 수 있습니다.Starting with the .NET Framework 4.5.NET Framework 4.5, you can define a time-out interval for regular expression matches. 정규식 엔진이이 시간 간격 내에 일치 항목을 식별할 수 없는 경우 일치 작업에서 예외가 throw RegexMatchTimeoutException 됩니다.If the regular expression engine cannot identify a match within this time interval, the matching operation throws a RegexMatchTimeoutException exception. 대부분의 경우 정규식 엔진은 정규식 패턴과 거의 일치 하는 텍스트와 일치를 시도 하 여 처리 능력을 낭비 하지 않도록 합니다.In most cases, this prevents the regular expression engine from wasting processing power by trying to match text that nearly matches the regular expression pattern. 그러나 제한 시간 간격이 너무 낮게 설정 되었거나 현재 컴퓨터 로드로 인해 성능 저하가 전반적으로 발생 했음을 나타낼 수도 있습니다.It also could indicate, however, that the timeout interval has been set too low, or that the current machine load has caused an overall degradation in performance.

예외를 처리 하는 방법은 예외의 원인에 따라 달라 집니다.How you handle the exception depends on the cause of the exception. 시간 제한 간격이 너무 낮거나 과도 한 컴퓨터 로드로 인해 예외가 발생 하면 시간 제한 간격을 늘리고 일치 작업을 다시 시도할 수 있습니다.If the exception occurs because the time-out interval is set too low or because of excessive machine load, you can increase the time-out interval and retry the matching operation. 정규식이 과도 한 역 추적을 사용 하기 때문에 예외가 발생 하는 경우 일치 하는 항목이 없는 것으로 가정 하 고, 필요에 따라 정규식 패턴을 수정 하는 데 도움이 되는 정보를 기록할 수 있습니다.If the exception occurs because the regular expression relies on excessive backtracking, you can assume that a match does not exist, and, optionally, you can log information that will help you modify the regular expression pattern.

Regex(String, RegexOptions, TimeSpan)정규식 개체를 인스턴스화할 때 생성자를 호출 하 여 시간 제한 간격을 설정할 수 있습니다.You can set a time-out interval by calling the Regex(String, RegexOptions, TimeSpan) constructor when you instantiate a regular expression object. 정적 메서드의 경우 매개 변수가 있는 일치 하는 메서드의 오버 로드를 호출 하 여 시간 제한 간격을 설정할 수 있습니다 matchTimeout .For static methods, you can set a time-out interval by calling an overload of a matching method that has a matchTimeout parameter. 제한 시간 값을 명시적으로 설정 하지 않으면 기본 시간 제한 값은 다음과 같이 결정 됩니다.If you do not set a time-out value explicitly, the default time-out value is determined as follows:

  • 애플리케이션 수준 시간 제한을 사용 하 여 값 하나 있습니다.By using the application-wide time-out value, if one exists. 이 애플리케이션 도메인에 적용 되는 제한 시간 값 수는 Regex 개체가 인스턴스화되거나 정적 메서드를 호출 합니다.This can be any time-out value that applies to the application domain in which the Regex object is instantiated or the static method call is made. 호출 하 여 애플리케이션 수준 시간 제한 값을 설정할 수 있습니다는 AppDomain.SetData 의 문자열 표현에 할당할 메서드를 TimeSpan "REGEX_DEFAULT_MATCH_TIMEOUT" 속성 값입니다.You can set the application-wide time-out value by calling the AppDomain.SetData method to assign the string representation of a TimeSpan value to the "REGEX_DEFAULT_MATCH_TIMEOUT" property.

  • 값을 사용 하 여 InfiniteMatchTimeout없는 애플리케이션 수준 시간 제한 값이 설정 된 경우.By using the value InfiniteMatchTimeout, if no application-wide time-out value has been set.

중요

모든 정규식 패턴 일치 작업에서 제한 시간 값을 설정 하는 것이 좋습니다.We recommend that you set a time-out value in all regular expression pattern-matching operations. 자세한 내용은 정규식에 대 한 모범 사례를 참조 하세요.For more information, see Best Practices for Regular Expressions.

설명으로 돌아가기Back to Remarks

생성자

Regex()

Regex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Regex class.

Regex(SerializationInfo, StreamingContext)

serialize된 데이터를 사용하여 Regex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Regex class by using serialized data.

Regex(String)

지정된 정규 식에 대해 Regex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Regex class for the specified regular expression.

Regex(String, RegexOptions)

패턴을 수정할 수 있는 옵션을 사용하여 Regex 클래스의 새 인스턴스를 지정된 정규식에 대해 초기화합니다.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern.

Regex(String, RegexOptions, TimeSpan)

시간이 초과되기 전에 패턴 일치 메서드가 일치하도록 시도해야 하는 시간을 지정한 패턴과 값을 수정할 수 있는 옵션을 사용하여 Regex 클래스의 새 인스턴스를 지정된 정규식에 대해 초기화하고 컴파일합니다.Initializes a new instance of the Regex class for the specified regular expression, with options that modify the pattern and a value that specifies how long a pattern matching method should attempt a match before it times out.

필드

capnames

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

caps

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

capsize

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

capslist

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

factory

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

InfiniteMatchTimeout

패턴 일치 작업의 시간이 초과되지 않도록 지정합니다.Specifies that a pattern-matching operation should not time out.

internalMatchTimeout

작업 시간이 초과되기 전에 패턴 일치 작업에서 경과될 수 있는 최대 시간입니다.The maximum amount of time that can elapse in a pattern-matching operation before the operation times out.

pattern

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

roptions

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

속성

CacheSize

컴파일된 정규식에 대한 현재 정적 캐시의 최대 엔트리 수를 가져오거나 설정합니다.Gets or sets the maximum number of entries in the current static cache of compiled regular expressions.

CapNames

명명된 캡처링 그룹을 인덱스 값에 매핑하는 사전을 가져오거나 설정합니다.Gets or sets a dictionary that maps named capturing groups to their index values.

Caps

번호가 매겨진 캡처링 그룹을 인덱스 값에 매핑하는 사전을 가져오거나 설정합니다.Gets or sets a dictionary that maps numbered capturing groups to their index values.

MatchTimeout

현재 인스턴스의 시간 제한 간격을 가져옵니다.Gets the time-out interval of the current instance.

Options

Regex 생성자에 전달된 옵션을 가져옵니다.Gets the options that were passed into the Regex constructor.

RightToLeft

정규식을 사용하여 오른쪽에서 왼쪽으로 검색하는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the regular expression searches from right to left.

메서드

CompileToAssembly(RegexCompilationInfo[], AssemblyName)

하나 이상의 지정된 Regex 개체를 명명된 어셈블리로 컴파일합니다.Compiles one or more specified Regex objects to a named assembly.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[])

지정된 특성을 사용하여 하나 이상의 지정된 Regex 개체를 명명된 어셈블리로 컴파일합니다.Compiles one or more specified Regex objects to a named assembly with the specified attributes.

CompileToAssembly(RegexCompilationInfo[], AssemblyName, CustomAttributeBuilder[], String)

지정된 특성을 사용하여 하나 이상의 지정된 Regex 개체와 지정된 리소스 파일을 명명된 어셈블리로 컴파일합니다.Compiles one or more specified Regex objects and a specified resource file to a named assembly with the specified attributes.

Equals(Object)

지정된 개체가 현재 개체와 같은지 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
Escape(String)

문자(\, *, +, ?, |, {, [, (,), ^, $,., # 및 공백)의 최소 집합을 자체 이스케이프 코드로 대체하여 이스케이프합니다.Escapes a minimal set of characters (\, *, +, ?, |, {, [, (,), ^, $, ., #, and white space) by replacing them with their escape codes. 이렇게 하면 정규식 엔진은 이러한 문자를 메타문자가 아니라 문자 그대로 해석합니다.This instructs the regular expression engine to interpret these characters literally rather than as metacharacters.

Finalize()

이 멤버는 Finalize()를 재정의합니다. 자세한 내용은 해당 항목을 참조하세요.This member overrides Finalize(), and more complete documentation might be available in that topic.

가비지 수집기에서 Object를 회수하기 전에 Object가 리소스를 해제하고 다른 정리 작업을 수행할 수 있게 합니다.Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.

GetGroupNames()

정규식에 대한 캡처링 그룹 이름의 배열을 반환합니다.Returns an array of capturing group names for the regular expression.

GetGroupNumbers()

배열 내의 그룹 이름에 해당하는 캡처링 그룹 번호의 배열을 반환합니다.Returns an array of capturing group numbers that correspond to group names in an array.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
GroupNameFromNumber(Int32)

지정된 그룹 번호에 해당하는 그룹 이름을 가져옵니다.Gets the group name that corresponds to the specified group number.

GroupNumberFromName(String)

지정된 그룹 이름에 해당하는 그룹 번호를 반환합니다.Returns the group number that corresponds to the specified group name.

InitializeReferences()

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

IsMatch(String)

Regex 생성자에 지정된 정규식이 지정된 입력 문자열에서 일치하는 항목을 찾을 것인지 여부를 나타냅니다.Indicates whether the regular expression specified in the Regex constructor finds a match in a specified input string.

IsMatch(String, Int32)

Regex 생성자에 지정된 정규식이 지정된 입력 문자열의 지정된 시작 위치에서부터 일치하는 항목을 찾을 것인지 여부를 나타냅니다.Indicates whether the regular expression specified in the Regex constructor finds a match in the specified input string, beginning at the specified starting position in the string.

IsMatch(String, String)

지정된 정규식이 지정된 입력 문자열에서 일치하는 항목을 찾을 것인지 여부를 나타냅니다.Indicates whether the specified regular expression finds a match in the specified input string.

IsMatch(String, String, RegexOptions)

지정된 정규식이 지정된 일치 옵션을 사용하여 지정된 입력 문자열에서 일치하는 항목을 찾을 것인지 여부를 나타냅니다.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options.

IsMatch(String, String, RegexOptions, TimeSpan)

지정된 정규식이 지정된 일치 옵션 및 시간 제한 간격을 사용하여 지정된 입력 문자열에서 일치하는 항목을 찾을 것인지 여부를 나타냅니다.Indicates whether the specified regular expression finds a match in the specified input string, using the specified matching options and time-out interval.

Match(String)

지정된 입력 문자열에서 Regex 생성자에 지정된 정규식의 처음 발견되는 항목을 검색합니다.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, Int32)

문자열의 지정된 시작 위치에서 시작하여 입력 문자열에서 맨 처음 발견되는 정규식을 검색합니다.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String, Int32, Int32)

지정된 시작 위치에서 시작하고 지정된 수의 문자만 검색하여 입력 문자열에서 첫 번째 정규식을 검색합니다.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String)

지정된 입력 문자열에서 첫 번째 지정된 정규식을 검색합니다.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions)

지정된 일치 옵션을 사용하여 입력 문자열에서 첫 번째 지정된 정규식을 검색합니다.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, String, RegexOptions, TimeSpan)

지정된 일치 옵션 및 제한 시간 간격을 사용하여 입력 문자열에서 첫 번째 지정된 정규식을 검색합니다.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Matches(String)

지정된 입력 문자열에 있는 정규식을 모두 검색합니다.Searches the specified input string for all occurrences of a regular expression.

Matches(String, Int32)

문자열의 지정된 시작 위치에서 시작하여 지정된 입력 문자열에 있는 정규식을 모두 검색합니다.Searches the specified input string for all occurrences of a regular expression, beginning at the specified starting position in the string.

Matches(String, String)

지정된 입력 문자열에서 지정된 정규식을 모두 검색합니다.Searches the specified input string for all occurrences of a specified regular expression.

Matches(String, String, RegexOptions)

지정된 일치 옵션을 사용하여 지정된 입력 문자열에서 지정된 정규식을 모두 검색합니다.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options.

Matches(String, String, RegexOptions, TimeSpan)

지정된 일치 옵션 및 제한 시간 간격을 사용하여 지정된 입력 문자열에서 지정된 정규식을 모두 검색합니다.Searches the specified input string for all occurrences of a specified regular expression, using the specified matching options and time-out interval.

MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
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, 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, 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)

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

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

Split(String)

Regex 생성자에서 지정된 정규식 패턴에 의해 정의된 위치에서 입력 문자열을 부분 문자열의 배열로 분할합니다.Splits an input string into an array of substrings at the positions defined by a regular expression pattern specified in the Regex constructor.

Split(String, Int32)

입력 문자열을 Regex 생성자에서 지정된 정규식에 의해 정의된 위치에서 지정된 최대 수만큼 부분 문자열의 배열로 분할합니다.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor.

Split(String, Int32, Int32)

입력 문자열을 Regex 생성자에서 지정된 정규식에 의해 정의된 위치에서 지정된 최대 수만큼 부분 문자열의 배열로 분할합니다.Splits an input string a specified maximum number of times into an array of substrings, at the positions defined by a regular expression specified in the Regex constructor. 입력 문자열에서 지정된 문자 위치부터 정규식 패턴을 검색합니다.The search for the regular expression pattern starts at a specified character position in the input string.

Split(String, String)

정규식 패턴에 의해 정의된 위치에서 부분 문자열로 이루어진 배열로 입력 문자열을 분할합니다.Splits an input string into an array of substrings at the positions defined by a regular expression pattern.

Split(String, String, RegexOptions)

지정된 정규식 패턴에 의해 정의된 위치에서 부분 문자열로 이루어진 배열로 입력 문자열을 분할합니다.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. 지정한 옵션에 따라 일치 작업이 수정됩니다.Specified options modify the matching operation.

Split(String, String, RegexOptions, TimeSpan)

지정된 정규식 패턴에 의해 정의된 위치에서 부분 문자열로 이루어진 배열로 입력 문자열을 분할합니다.Splits an input string into an array of substrings at the positions defined by a specified regular expression pattern. 추가 매개 변수는 일치하는 항목이 없는 경우 제한 시간 간격과 일치 작업을 수정하는 옵션을 지정합니다.Additional parameters specify options that modify the matching operation and a time-out interval if no match is found.

ToString()

Regex 생성자로 전달된 정규식 패턴을 반환합니다.Returns the regular expression pattern that was passed into the Regex constructor.

Unescape(String)

입력 문자열에서 이스케이프된 문자를 변환합니다.Converts any escaped characters in the input string.

UseOptionC()

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

UseOptionR()

CompileToAssembly 메서드에서 생성되는 Regex 개체에서 사용됩니다.Used by a Regex object generated by the CompileToAssembly method.

ValidateMatchTimeout(TimeSpan)

시간 제한 간격이 허용 범위 내에 있는지 여부를 확인합니다.Checks whether a time-out interval is within an acceptable range.

명시적 인터페이스 구현

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

현재 SerializationInfo 개체를 역직렬화하는 데 필요한 데이터로 Regex 개체를 채웁니다.Populates a SerializationInfo object with the data necessary to deserialize the current Regex object.

적용 대상

스레드 보안

Regex클래스는 변경할 수 없는 (읽기 전용) 스레드로부터 안전 합니다.The Regex class is immutable (read-only) and thread safe. Regex 개체는 모든 스레드에서 생성 되 고 스레드 간에 공유 될 수 있습니다.Regex objects can be created on any thread and shared between threads. 자세한 내용은 스레드 보안을 참조 하세요.For more information, see Thread Safety.

추가 정보