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+) ワード境界までの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.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 NumberFormatInfo.CurrencySymbol、ユーザーの現在のカルチャのCurrencyDecimalDigits、、 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 個または 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}? 2桁の10進数と0回または1回一致します。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.

この例の正規表現は動的に構築されるため、現在のカルチャの通貨記号、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 と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.EndsWithString.ContainsおよびString.StartsWithメソッドは、指定された部分文字列が文字列String.IndexOfインスタンスに含まれるかどうString.LastIndexOfかをString.LastIndexOfAny判断し、、 String.IndexOfAny、、およびの各メソッドが開始を返します。文字列内の指定した部分文字列の位置。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. オブジェクトは変更できません。正規表現Regexを使用してオブジェクトをインスタンス化する場合、そのオブジェクトの正規表現を変更することはできません。 RegexA 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クラスコンストラクターまたは静的メソッドが呼び出されたときに発生する1回限りのプロシージャです。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 バージョン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. この例では1つの正規表現を使用して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.5Starting 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)コンストラクターを呼び出すことによってタイムアウト間隔を設定できます。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)

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

(継承元 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 コンストラクターで指定された正規表現と最初に一致する対象を 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.

(継承元 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.

こちらもご覧ください