RegexOptions RegexOptions RegexOptions RegexOptions Enum

Определение

Предоставляет перечисленные значения для использования при задании параметров регулярных выражений.Provides enumerated values to use to set regular expression options.

Это перечисление имеет атрибут FlagsAttribute, который разрешает побитовое сочетание значений его элементов.

public enum class RegexOptions
[System.Flags]
public enum RegexOptions
type RegexOptions = 
Public Enum RegexOptions
Наследование
Атрибуты

Поля

Compiled Compiled Compiled Compiled 8

Указывает, что регулярное выражение скомпилировано в сборку.Specifies that the regular expression is compiled to an assembly. Это порождает более быстрое исполнение, но увеличивает время запуска.This yields faster execution but increases startup time. Это значение не должно назначаться свойству Options при обращении к методу CompileToAssembly(RegexCompilationInfo[], AssemblyName).This value should not be assigned to the Options property when calling the CompileToAssembly(RegexCompilationInfo[], AssemblyName) method. Дополнительные сведения см. в подразделе "Скомпилированные регулярные выражения" раздела Параметры регулярных выражений.For more information, see the "Compiled Regular Expressions" section in the Regular Expression Options topic.

CultureInvariant CultureInvariant CultureInvariant CultureInvariant 512

Указывает игнорирование региональных языковых различий.Specifies that cultural differences in language is ignored. Дополнительные сведения см. в подразделе "Сравнение с использованием инвариантного языка и региональных параметров" раздела Параметры регулярных выражений.For more information, see the "Comparison Using the Invariant Culture" section in the Regular Expression Options topic.

ECMAScript ECMAScript ECMAScript ECMAScript 256

Включает ECMAScript-совместимое поведение для выражения.Enables ECMAScript-compliant behavior for the expression. Это значение может быть использовано только вместе со значениями IgnoreCase, Multiline и Compiled.This value can be used only in conjunction with the IgnoreCase, Multiline, and Compiled values. Использование этого значения вместе с любыми другими приводит к исключению.The use of this value with any other values results in an exception.

Дополнительные сведения о параметре ECMAScript см. в подразделе "Поведение сопоставления ECMAScript" раздела Параметры регулярных выражений.For more information on the ECMAScript option, see the "ECMAScript Matching Behavior" section in the Regular Expression Options topic.

ExplicitCapture ExplicitCapture ExplicitCapture ExplicitCapture 4

Указывает, что единственные допустимые записи являются явно именованными или нумерованными группами в форме (?<name>...). Это позволяет использовать неименованные круглые скобки в качестве незахватываемых групп, тем самым не допуская синтаксической громоздкости выражения (?:...). Дополнительные сведения см. в подразделе "Только явные захваты" раздела Параметры регулярных выражений.Specifies that the only valid captures are explicitly named or numbered groups of the form (?<name>...). This allows unnamed parentheses to act as noncapturing groups without the syntactic clumsiness of the expression (?:...). For more information, see the "Explicit Captures Only" section in the Regular Expression Options topic.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Указывает соответствие, не учитывающее регистр.Specifies case-insensitive matching. Дополнительные сведения см. в подразделе "Сопоставление без учета регистра" раздела Параметры регулярных выражений.For more information, see the "Case-Insensitive Matching " section in the Regular Expression Options topic.

IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace IgnorePatternWhitespace 32

Устраняет из шаблона неизбежные пробелы и включает комментарии, помеченные "#".Eliminates unescaped white space from the pattern and enables comments marked with #. Однако это значение не затрагивает и не устраняет пробелы в классах символов, числовых квантификаторах или токенах, отмечающих начало отдельных языковых элементов регулярных выражений.However, this value does not affect or eliminate white space in character classes, numeric quantifiers, or tokens that mark the beginning of individual regular expression language elements. Дополнительные сведения см. в подразделе "Пропуск пробелов" раздела Параметры регулярных выражений.For more information, see the "Ignore White Space" section of the Regular Expression Options topic.

Multiline Multiline Multiline Multiline 2

Многострочный режим.Multiline mode. Изменяет значение символов "^" и "$" так, что они совпадают, соответственно, в начале и конце любой строки, а не только в начале и конце целой строки.Changes the meaning of ^ and $ so they match at the beginning and end, respectively, of any line, and not just the beginning and end of the entire string. Дополнительные сведения см. в подразделе "Многострочный режим" раздела Параметры регулярных выражений.For more information, see the "Multiline Mode" section in the Regular Expression Options topic.

None None None None 0

Указывает на отсутствие заданных параметров.Specifies that no options are set. Дополнительные сведения о поведении по умолчанию обработчика регулярных выражений см. в подразделе "Параметры по умолчанию" раздела Параметры регулярных выражений.For more information about the default behavior of the regular expression engine, see the "Default Options" section in the Regular Expression Options topic.

RightToLeft RightToLeft RightToLeft RightToLeft 64

Указывает, что поиск будет выполнен в направлении справа налево, а не слева направо.Specifies that the search will be from right to left instead of from left to right. Дополнительные сведения см. в подразделе "Режим справа налево" раздела Параметры регулярных выражений.For more information, see the "Right-to-Left Mode" section in the Regular Expression Options topic.

Singleline Singleline Singleline Singleline 16

Указывает однострочный режим.Specifies single-line mode. Изменяет значение точки (.) так, что она соответствует любому символу (вместо любого символа, кроме "\n").Changes the meaning of the dot (.) so it matches every character (instead of every character except \n). Дополнительные сведения см. в подразделе "Однострочный режим" раздела Параметры регулярных выражений.For more information, see the "Single-line Mode" section in the Regular Expression Options topic.

Примеры

В следующем примере определяются два регулярных выражений, которые задают повторяющиеся слова в тексте, но с помощью разных RegexOptions.ExplicitCapture значения.The following example defines two regular expressions that identify repeated words in text but that are instantiated using different RegexOptions.ExplicitCapture values. Первый регулярного выражения учитывается регистр. регистр учитывается при определении, идентичен ли слово предыдущего слова.The first regular expression is case-insensitive; case is ignored when determining whether a word is identical to the preceding word. Второе регулярное выражение с учетом регистра; слово должен соответствовать регистру предыдущего слова, точно считается дубликатом.The second regular expression is case-sensitive; a word must match the case of the preceding word exactly to be considered a duplicate.

using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a case-insensitive regular expression for repeated words.
        Regex rxInsensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);
        // Define a case-sensitive regular expression for repeated words.
        Regex rxSensitive = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled);

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches using case-insensitive regular expression.
        MatchCollection matches = rxInsensitive.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);
        }
        Console.WriteLine();
        
        // Find matches using case-sensitive regular expression.
        matches = rxSensitive.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
//       
//       2 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       '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 case-insensitive regular expression for repeated words.
        Dim rxInsensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)
        ' Define a case-sensitive regular expression for repeated words.
        Dim rxSensitive As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches using case-insensitive regular expression.
        Dim matches As MatchCollection = rxInsensitive.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
        Console.WriteLine()
        
        ' Find matches using case-sensitive regular expression.
        matches = rxSensitive.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
        Console.WriteLine()
    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
'       
'       2 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

Комментарии

Объект RegexOptions значение можно указать в качестве параметра для следующих членов Regex класса:A RegexOptions value can be provided as a parameter to the following members of the Regex class:

Объект RegexOptions значение также может быть передано в качестве параметра RegexCompilationInfo конструктору, или он может быть присвоено непосредственно Options свойство.A RegexOptions value can also be supplied as a parameter to the RegexCompilationInfo constructor, or it can be assigned directly to the Options property. Полученный в результате RegexCompilationInfo объект затем используется в вызове CompileToAssembly метод.The resulting RegexCompilationInfo object is then used in the call to the CompileToAssembly method.

Несколько вариантов, предоставляемые членами RegexOptions перечисления (в частности, с его члены ExplicitCapture, IgnoreCase, однострочный и многострочный) вместо этого можно указать с помощью параметра встроенный символ в шаблоне регулярного выражения.Several options provided by members of the RegexOptions enumeration (in particular, by its ExplicitCapture, IgnoreCase, Multiline, and Singleline members) can instead be provided by using an inline option character in the regular expression pattern. Дополнительные сведения см. в разделе параметры регулярных выражений.For details, see Regular Expression Options.

Применяется к

Дополнительно