Regex 클래스

정의

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

public ref class Regex : System::Runtime::Serialization::ISerializable
[System.Serializable]
public class Regex : System.Runtime.Serialization.ISerializable
type Regex = class
    interface ISerializable
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, CurrencyDecimalDigitsNumberFormatInfo.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 또는 1 개를 찾습니다.Match zero or one occurrence of either the positive sign or the negative sign.
\s? 0번 이상 나오는 공백 문자를 찾습니다.Match zero or one white-space character.
\$? 달러 기호 0 또는 1 개를 찾습니다.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 개 이상의 소수점 기호를 찾습니다.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.

이 예제에서 정규식을 동적으로 작성 하기 때문에 파악 하지 못해도 디자인 타임에 현재 문화권의 통화 기호, 소수점 기호 또는 양수 기호와 음수 기호를 정기적으로 정규식 엔진의 잘못 해석 될 수 있는지 여부를 식 언어 연산자입니다.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. 또한에 같은 정규식 패턴의 온라인 라이브러리는 여러 가지 일반 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 vs입니다. 문자열 처리 메서드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.IndexOfAnyString.LastIndexOf, 및 String.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 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. A 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

시간 제한 값을 정의합니다.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. 정규식 엔진이이 시간 간격 내에서 일치 하는 항목을 식별할 수 없습니다, 하는 경우 일치 하는 작업에서는 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) regular expression 개체를 인스턴스화할 때 생성자입니다.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 개체를 deserialize하는 데 필요한 데이터로 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.

추가 정보