Regex Class

定義

変更不可の正規表現を表します。 Represents an immutable regular expression.

public class Regex : System.Runtime.Serialization.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+) ワード境界までの 1 つまたは複数の単語文字に一致します。Match one or more word characters up to a word boundary. このキャプチャされたグループの名前を付けますwordします。Name this captured group word.
\s+ 1 つ以上の空白文字と一致します。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
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.CurrencyDecimalSeparatorCurrencyDecimalDigitsNumberFormatInfo.CurrencySymbolNumberFormatInfo.NegativeSignNumberFormatInfo.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 個または 1 個の空白文字と一致します。Match zero or one white-space character.
\$? ドル記号の 0 個または 1 回を一致します。Match zero or one occurrence of the dollar sign.
\s? 0 個または 1 個の空白文字と一致します。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}? 0 個または 1 時間を 2 桁の 10 進数字に一致します。Match two decimal digits zero or one time.
(\d*\.?\d{2}?){1} 少なくとも 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

Vs の正規表現。String のメソッド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.ContainsString.EndsWithString.StartsWithメソッドは、文字列のインスタンスが指定した部分文字列を含むかどうかを判断し、 String.IndexOfString.IndexOfAnyString.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 vs. Instance Methods

正規表現パターンを定義した後は、2 つの方法のいずれかで、正規表現エンジンに提供できます。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. ARegexオブジェクトは、変更は、インスタンス化するときに、 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オブジェクトは不変で、これは、1 回限りの手順に発生するときに、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. 繰り返しを 1 つの正規表現をコンパイルする必要をなくすためには、正規表現エンジンは、静的メソッドの呼び出しで使用される、コンパイルされた正規表現をキャッシュします。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 version 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.

ただし、キャッシュ パフォーマンスに悪影響次の 2 つの場合。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()   
    

    再コンパイルを防ぐためには、1 つのインスタンス化する必要があります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:

  • アプリケーション全体のタイムアウトを使用して 1 つの場合は、値が存在します。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)

シリアル化したデータを使用して、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)

1 つ以上の指定した Regex オブジェクトをコンパイルして、名前付きアセンブリに保存します。 Compiles one or more specified Regex objects to a named assembly.

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

指定した 1 つ以上の Regex オブジェクトをコンパイルして、指定した属性を持つ名前付きアセンブリに保存します。 Compiles one or more specified Regex objects to a named assembly with the specified attributes.

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

指定した 1 つ以上の Regex オブジェクトと、指定した 1 つのリソース ファイルをコンパイルして、指定した属性を持つ名前付きアセンブリに保存します。 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.

(Inherited from 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()
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.

(Inherited from Object)
GetType()

現在のインスタンスの Type を取得します。 Gets the Type of the current instance.

(Inherited from 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 コンストラクターで指定された正規表現と最初に一致する対象を 1 つ検索します。 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.

(Inherited from 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.

こちらもご覧ください