C# Регулярное выражение

Регулярное выражениеЭто формула поиска, используемая для описания и сопоставления текстовых шаблонов. Проще говоря, его можно понимать как специальный язык подстановочных знаков, используемый для точного поиска, проверки или замены содержимого в строках.

Например, если вы хотите определить, является ли введённое пользователем значение допустимым адресом электронной почты или номером телефона, или хотите извлечь все даты из текста — это типичные случаи использования регулярных выражений.

В .NET Framework есть встроенный полнофункциональный движок регулярных выражений, реализованный черезSystem.Text.RegularExpressionsПространство имён обеспечивает поддержку.

Шаблон регулярного выражения состоит из одного или нескольких символов, операторов и конструкций, которые вместе описывают правила сопоставления текста.

Если вы ещё не понимаете регулярные выражения, можете сначала прочитать нашУчебник по регулярным выражениям。

Определение регулярного выражения

Регулярные выражения состоят из следующих типов строительных блоков, каждый из которых отвечает за разные функции сопоставления:

  • Экранирование символов: обрабатывать специальные символы как обычные символы (например,\.сопоставить буквальную точку)
  • класс символов: сопоставляет "определённый тип" символов (например,\dСопоставить любую цифру)
  • Якорь: указывает "позицию", в которой происходит сопоставление (например,^обозначает начало строки)
  • Конструкция группировки: группирует подшаблоны вместе для удобного захвата или ссылки
  • Квантификаторы: управляют числом появлений элемента (например,+означает одно или более раз)
  • Конструкция обратной ссылки: ссылается на ранее захваченное содержимое для повторного сопоставления
  • Конструкция альтернативы: реализует логику "или" (например,cat|dog)
  • replace: ссылается на захваченное содержимое в операциях замены
  • Прочие конструкции: вспомогательные функции, такие как встроенные параметры, комментарии и т. д.

Экранирование символов

В регулярных выражениях символ обратной косой черты (\) имеет две функции: во-первых, он экранирует следующиеОбычные символы приобретают особое значение(например,\nобозначает перевод строки), и во-вторых, он превращаетСпециальные символы экранируются в литеральные символы(например,\.сопоставить настоящую точку вместо "любого символа").

Распространённое заблуждение новичков: в строках C#,\сам является экранирующим символом, поэтому при записи в регулярном выражении\d, в строках C# нужно написать"\\d", или использовать verbatim-строку@"\d"(Рекомендуется).

В следующей таблице перечислены распространённые экранирующие символы:

Экранирующие символыОписаниеModeсовпадение
\aСоответствует символу звонка (alarm/bell) \u0007.\aСимвол "\u0007" в "Warning!" + '\u0007'
\bВ классах символов соответствует клавише Backspace \u0008. (Примечание: вне классов символов \b обозначает границу слова, см. раздел "Якоря")[\b]{3,}"\b\b\b\b" в "\b\b\b\b"
\tСоответствует символу табуляции \u0009. Обычно используется для сопоставления текста, разделённого табуляцией.(\w+)\t"Name\t" и "Addr\t" в "Name\tAddr\t"
\rСоответствует символу возврата каретки \u000D. (\r не эквивалентен переводу строки \n. В Windows разрывы строк обычно имеют вид \r\n)\r\n(\w+)"\r\nHello" в "\r\nHello\nWorld."
\vСоответствует символу вертикальной табуляции \u000B.[\v]{2,}"\v\v\v" в "\v\v\v"
\fСоответствует символу перевода страницы \u000C.[\f]{2,}"\f\f\f" в "\f\f\f"
\nСоответствует переводу строки \u000A. В Unix/Linux окончания строк обычно содержат только \n.\r\n(\w+)"\r\nHello" в "\r\nHello\nWorld."
\eСоответствует escape-символу \u001B.\e"\x001B" в "\x001B"
\ nnnЗадает символ с использованием восьмеричного представления (nnn состоит из двух или трех цифр).\w\040\w"a b" и "c d" в "a bc d"
\x nnЗадает символ с использованием шестнадцатеричного представления (nn состоит ровно из двух цифр).\w\x20\w"a b" и "c d" в "a bc d"
\c X \c x Соответствует управляющему символу ASCII, заданному X или x, где X или x — буква управляющего символа.\cC"\x0003" внутри "\x0003" (Ctrl-C)
\u nnnnСоответствует символу Unicode с использованием шестнадцатеричного представления (четыре цифры, обозначенные nnnn).\w\u0020\w"a b" и "c d" в "a bc d"
\Если за ним следует нераспознанный escape-символ, соответствует этому символу.\d+[\+-x\*]\d+\d+[\+-x\*\d+"2+2" и "3*9" в "(2+2) * 3*9"

класс символов

Классы символов используются для сопоставления символа среди "определенного типа" символовЛюбой один. Например[aeiou]совпадает с любой одной гласной буквой,\dСоответствует любой одной цифре. Это одна из наиболее часто используемых базовых функций в регулярных выражениях.

В следующей таблице перечислены классы символов:

класс символовОписаниеModeсовпадение
[character_group]Соответствует любому отдельному символу в character_group. По умолчанию сопоставление чувствительно к регистру.[mn]'m' в 'mat', 'm' и 'n' в 'moon'
[^character_group]Отрицание: соответствует любому отдельному символу, не входящему в character_group. По умолчанию символы в character_group чувствительны к регистру.[^aei]"v" и "l" в "avail"
[ first - last ]Диапазон символов: соответствует любому одиночному символу в диапазоне от первого до последнего.[b-d][b-d]irds может соответствовать Birds, Cirds, Dirds
.Подстановочный знак: соответствует любому одиночному символу, кроме \n.
Чтобы сопоставить литеральный символ точки (. или \u002E), необходимо предварить его экранирующим символом (\.).
a.e"ave" в "have", "ate" в "mate"
\p{ name }иnameСоответствует любому одиночному символу в указанной общей категории Unicode или именованном блоке.\p{Lu} "C" и "L" в "City Lights"
\P{ name }и не вnameСоответствует любому одиночному символу в указанной общей категории Unicode или именованном блоке.\P{Lu}"i", "t" и "y" в "City"
\wСоответствует любому словесному символу (буквы, цифры, подчёркивание). Эквивалентно [a-zA-Z0-9_] (в диапазоне ASCII).\w"R", "o", "m" и "1" в "Room#1"
\WСоответствует любому несловесному символу. Это отрицание \w.\W"#" в "Room#1"
\sСоответствует любому пробельному символу (пробел, табуляция, перевод строки и т. д.).\w\s"D " в "ID A1.3"
\SСоответствует любому непробельному символу. Это отрицание \s.\s\S" _" в "int __ctr"
\dСоответствует любой десятичной цифре. Эквивалентно [0-9].\d"4" в "4 = IV"
\DСоответствует любому символу, не являющемуся десятичной цифрой. Это отрицание \d.\DСимволы " ", "=", " ", "I" и "V" в "4 = IV"

Точка привязки

Якоря (также называемые "якорями") не совпадают ни с одним конкретным символом, а совпадают с определённой позицией в строке.Позиция. Они "нулевой ширины", не потребляют ни одного символа, лишь утверждают, что текущая позиция удовлетворяет определённому условию.

Например^\d{3}означает "три цифры в начале строки",\bозначает "граница между словесными и несловесными символами".

В следующей таблице перечислены якоря:

УтверждениеОписаниеModeсовпадение
^Совпадение должно начинаться с начала строки или отдельной строки.^\d{3}"567" в "567-777-"
$Совпадение должно находиться в конце строки или перед\nперед.-\d{4}$"-2012" в "8-12-2012"
\AСовпадение должно находиться в начале строки (не зависит от многострочного режима; всегда самое начало всей строки).\A\w{4}"Code" в "Code-007-"
\ZСовпадение должно находиться в конце строки или перед\nперед.-\d{3}\Z"-007" в "Bond-901-007"
\zСовпадение должно находиться в конце строки (строгий конец, \n в конце не допускается).-\d{3}\z"-333" в "-901-333"
\GСовпадение должно находиться там, где закончилось предыдущее совпадение. Обычно используется в сценариях последовательного сопоставления.\G\(\d\)"(1)", "(3)" и "(5)" в "(1)(3)(5)[7](9)"
\bСоответствует границе слова, то есть позиции между словом и пробелом.er\bСоответствует "er" в "never", но не может соответствовать "er" в "verb".
\BСоответствует негранице слова.er\BСоответствует "er" в "verb", но не может соответствовать "er" в "never".

Конструкция группировки

Конструкции группировки используют круглые скобки( )Заключите часть регулярного выражения в скобки, чтобы сформировать подвыражение. Группировка имеет две основные цели:

  • захват: "сохранить" совпавшую подстроку для последующего извлечения или ссылки при замене.
  • Ограничение области действия: позволяет квантификаторам или конструкциям чередования применяться только к подвыражению внутри группы.

Эта часть относительно сложна для понимания; вы можете прочитатьРегулярное выражение — Выбор 、Опережающие и ретроспективные утверждения в регулярных выраженияхПомогает пониманию.

В следующей таблице перечислены конструкции группировки:

Конструкция группировкиОписаниеModeсовпадение
( subexpression )Захватывает совпавшее подвыражение и присваивает ему порядковый номер, начинающийся с нуля.(\w)\1"ee" в "deep"
(?< name >subexpression)Захватывает сопоставленное подвыражение в именованную группу. Именованные группы удобнее для чтения, чем числовая нумерация, и рекомендуются для использования в сложных регулярных выражениях.(?< double>\w)\k< double>"ee" в "deep"
(?< name1 -name2 >subexpression)Задает определение балансирующей группы. Используется для сопоставления вложенных структур (например, парных скобок); это расширенная возможность.(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$"((1-3)*(3-1))" в "3+2^((1-3)*(3-1))"
(?: subexpression)Определяет незахватывающую группу. Используется, когда требуется только группировка (ограничение области действия) без сохранения сопоставленного содержимого; производительность немного выше, чем у захватывающих групп.Write(?:Line)?"WriteLine" в "Console.WriteLine()"
(?imnsx-imnsx:subexpression)Применить или отключить параметры, указанные вподвыражении.A\d{2}(?i:\w+)\b"A12xl" и "A12XL" в "A12xl A12XL a12xl"
(?= подвыражение)Утверждение положительного просмотра вперёд нулевой ширины. Соответствует позиции, за которой следует подвыражение, но не потребляет символы.\w+(?=\.)"He is. The dog ran. The sun is out." в "is"、 "ran" и "out"
(?! подвыражение)Утверждение отрицательного просмотра вперёд нулевой ширины. Соответствует позиции, за которой не следует подвыражение.\b(?!un)\w+\b"sure" и "used" в "unsure sure unity used"
(?<=подвыражение)Утверждение положительного просмотра назад нулевой ширины. Соответствует позиции, непосредственно перед которой находится подвыражение.(?<=19)\d{2}\b"99", "50", и "05" в "1851 1999 1950 1905 2003"
(?<! подвыражение)Утверждение отрицательного просмотра назад нулевой ширины. Совпадает с позицией, перед которой нет подвыражения.(?<!wo)man\b"man" в "Hi woman Hi man"
(?> подвыражение)Подвыражение без возврата (атомарная группа). После совпадения откат не допускается, что может повысить производительность в некоторых сценариях.[13579](?>A+B+)"1ABB", "3ABB" и "5AB" в "1ABB 3ABBC 5AB 5AC"

Пример

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "1851 1999 1950 1905 2003";
      string pattern = @"(?<=19)\d{2}\b";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}


Квалификаторы

Квантификаторы указывают, что предшествующий элемент (символ, класс символов или группа) должен встретитьсясколько разТолько тогда совпадение считается успешным.

По умолчанию квантификаторы являютсяжадными, то есть совпадают с как можно большим количеством символов. Добавление после квантификатора?может статьленивым (нежадным)шаблоном, то есть совпадать с как можно меньшим количеством символов. Новичкам можно сначала освоить*、+、?、{n}Эти четыре основных квантификатора.

В следующей таблице перечислены квантификаторы:

КвалификаторыОписаниеModeсовпадение
*Соответствует предыдущему элементу ноль или более раз. (Ноль вхождений также считается совпадением)\d*\.\d".0"、 "19.9"、 "219.9"
+Соответствует предыдущему элементу один или более раз. (Как минимум один раз)"be+""bee" в "been", и "be" в "bent"
?Соответствует предыдущему элементу ноль или один раз. (то есть элемент необязателен)"rai?n""ran"、 "rain"
{ n }Совпадает с предыдущим элементом ровно n раз.",\d{3}""1,043.6" в ",043", "9,876,543,210" в ",876"、 ",543" и ",210"
{ n ,}Совпадает с предыдущим элементом не менее n раз."\d{2,}""166"、 "29"、 "1930"
{ n , m }Совпадает с предыдущим элементом не менее n раз, но не более m раз."\d{3,5}""19302" в "166", "17668", "193024"
*?Совпадает с предыдущим элементом ноль или более раз, но как можно меньше раз (ленивый режим).\d*?\.\d".0"、 "19.9"、 "219.9"
+?Совпадает с предыдущим элементом один или более раз, но как можно меньше раз (ленивый режим)."be+?""be" в "been", "be" в "bent"
??Совпадает с предыдущим элементом ноль или один раз, но как можно меньше раз (ленивый режим)."rai??n""ran"、 "rain"
{ n }?Совпадает с предшествующим элементом ровно n раз.",\d{3}?""1,043.6" в ",043", "9,876,543,210" в ",876"、 ",543" и ",210"
{ n ,}?Соответствует предыдущему элементу не менее n раз, но как можно меньше раз."\d{2,}?""166", "29" и "1930"
{ n , m }?Соответствует предыдущему элементу от n до m раз, но как можно меньше раз."\d{3,5}?""166", "17668", а также "193" и "024" в "193024"

Конструкции обратных ссылок

Обратные ссылки позволяют в одном и том же регулярном выражении ссылаться насодержимое ранее захваченных групп, которое снова выполняет сопоставление. Например, используя(\w)\1можно найти идущие подряд повторяющиеся символы, такие как "ee", "ll".

В следующей таблице перечислены конструкции обратных ссылок:

Конструкции обратных ссылокОписаниеModeсовпадение
\ numberОбратная ссылка. Соответствует значению нумерованного подвыражения.(\w)\1"ee" в "seek"
\k< name >Именованная обратная ссылка. Соответствует значению именованного выражения. Более удобочитаемо, чем числовые ссылки; рекомендуется.(?< char>\w)\k< char>"ee" в "seek"

Конструкция чередования

Конструкции чередования используют вертикальную черту|Реализует логику "или", позволяя регулярному выражению соответствовать любому из нескольких возможных шаблонов. Аналогично||Операторы.

В следующей таблице перечислены конструкции чередования:

Конструкция чередованияОписаниеModeсовпадение
|Соответствует любому одному из элементов, разделённых символом вертикальной черты (|).th(e|is|at)Слова "the" и "this" в "this is the day. "
(?( expression )yes | no )Если шаблон регулярного выражения сопоставляется с указанным выражением, то сопоставляетсяyes; иначе сопоставляется необязательнаяnoчасть. выражение интерпретируется как утверждение нулевой ширины.(?(A)A\d{2}\b|\b\d{3}\b)"A10" и "910" в "A10 C103 910"
(?( name )yes | no )Если name или именованная или нумерованная захватывающая группа имеет совпадение, то сопоставляется сyes; иначе сопоставляется с необязательнымno。(?< quoted>")?(?(quoted).+?"|\S+\s)"Dogs.jpg "Yiska playing.jpg"" в Dogs.jpg и "Yiska playing.jpg"

замена

Синтаксис замены используется дляRegex.Replace()методаСтрока шаблона заменыВ, можно использовать$Используйте числа или имена для ссылки на ранее захваченное содержимое группы, что позволяет гибко реорганизовывать текст.

В следующей таблице перечислены символы, используемые для замены:

СимволОписаниеModeШаблон заменыВходная строкаРезультирующая строка
$числоЗамена по группеnumberСовпавшая подстрока.\b(\w+)(\s)(\w+)\b$3$2$1"one two""two one"
${name}Заменить на именованную группуnameСовпавшая подстрока.\b(?< word1>\w+)(\s)(?< word2>\w+)\b${word2} ${word1}"one two""two one"
$$Символ замены "$".\b(\d+)\s?USD$$$1"103 USD""$103"
$&Заменяет копией всего совпадения.(\$*(\d*(\.+\d+)?){1})**$&"$1.30""**$1.30"
$`Заменяет весь текст входной строки перед совпадением.B+$`"AABBCC""AAAACC"
$'Заменяет весь текст входной строки после совпадения.B+$'"AABBCC""AACCCC"
$+Заменяет последнюю захваченную группу.B+(C+)$+"AABBCCDD"AACCDD
$_Заменяет всю входную строку.B+$_"AABBCC""AAAABBCCCC"

Прочая конструкция

В следующей таблице перечислены прочие конструкции:

КонструкторОписаниеПример
(?imnsx-imnsx)Устанавливает или отключает такие параметры, как нечувствительность к регистру, в середине шаблона.\bA(?i)b\w+\b совпадает с "ABA" и "Able" в "ABA Able Act"
(?#comment)Встроенный комментарий. Этот комментарий завершается на первой закрывающей скобке.\bA(?#matches a word starting with A)\w+\b
# [Конец строки]Этот комментарий начинается с неэкранированного # и продолжается до конца строки.(?x)\bA\w+\b#Matches words starting with A

Класс Regex

Класс Regex — это основной класс для использования регулярных выражений в .NET, расположенный вSystem.Text.RegularExpressionsпространстве имён. Перед его использованием необходимо добавить в начале файла:

using System.Text.RegularExpressions;

В следующей таблице перечислены некоторые часто используемые методы класса Regex:

Порядковый номерМетод и описание
1public bool IsMatch( string input )
Определяет, содержит ли входная строка содержимое, соответствующее шаблону регулярного выражения. Обычно используется при проверке форм, например для проверки формата номера телефона или адреса электронной почты.
2public bool IsMatch( string input, int startat )
Выполняет проверку совпадения, начиная с указанной позиции в строке.
3public static bool IsMatch( string input, string pattern )
Статический метод; не нужно сначала создавать объект Regex. Передайте строку шаблона напрямую для проверки совпадения. Подходит для разовых сценариев использования.
4public MatchCollection Matches( string input )
Ищет все совпадения во входной строке, возвращает MatchCollection, которую можно перебирать с помощью foreach по каждому результату совпадения.
5public string Replace( string input, string replacement )
Заменяет всё содержимое во входной строке, соответствующее шаблону регулярного выражения, на указанную строку.
6public string[] Split( string input )
Разбивает входную строку на массив подстрок в соответствии с разделителями, заданными шаблоном регулярного выражения. Более гибкий, чем string.Split(), поддерживает сложные правила разделителей.

Полный список свойств класса Regex см. в документации Microsoft по C#.

Пример 1

В следующем примере сопоставляются слова, начинающиеся с 'S':

Анализ:\b— это граница слова,Sсоответствует заглавной букве S,\S*Соответствует нулю или более непробельным символам; вместе это означает "целые слова, начинающиеся с S".

Пример

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("Выражение: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "Тысяча сияющих солнц";

         Console.WriteLine("Совпадающие слова, начинающиеся с 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

Когда приведённый выше код компилируется и выполняется, он выдаёт следующий результат:

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

Пример 2

Следующий пример сопоставляет слова, начинающиеся с 'm' и заканчивающиеся на 'e':

Анализ:\bmсопоставляет слова, начинающиеся с m,\S*сопоставляет любой непробельный символ в середине,e\bТребует окончания на e, за которым следует граница слова; вместе это находит все слова, начинающиеся с m и заканчивающиеся на e.

Пример

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("Выражение: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

Когда приведённый выше код компилируется и выполняется, он выдаёт следующий результат:

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure

Пример 3

Следующий пример заменяет лишние пробелы:

Анализ:\\s+Сопоставляет один или несколько последовательных пробельных символов (пробелы, табуляции и т. д.) и заменяет их все одним пробелом, тем самым объединяя лишние пробелы.

Пример

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         string pattern = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Исходная строка: {0}", input);
         Console.WriteLine("Строка замены: {0}", result);    
         Console.ReadKey();
      }
   }
}

Когда приведённый выше код компилируется и выполняется, он выдаёт следующий результат:

Original String: Hello   World   
Replacement String: Hello World   

GeneratedRegex: оптимизация с помощью генератора исходного кода (.NET 7+)

Начиная с .NET 7, C# представил[GeneratedRegex]атрибут (генератор исходного кода), который является значительным улучшением по сравнению с традиционнымRegexважное улучшение класса, особенно длякритичных к производительностиилимногократного использованиясценариев с регулярными выражениями.

Проблемы традиционных подходов

Использовать традиционныйnew Regex(pattern)Когда ..., синтаксический анализ и компиляция регулярного выражения происходят во времявыполнения, каждое создание имеет накладные расходы. Хотя можно использоватьRegexOptions.CompiledПовышает скорость выполнения, но компиляция всё ещё происходит во время выполнения и увеличивает время запуска и использование памяти.

Традиционный способ

using System.Text.RegularExpressions;

// Метод 1: повторный разбор каждый раз (самый медленный)
bool isMatch = Regex.IsMatch(input, @"\d{4}-\d{2}-\d{2}");

// Метод 2: статическое поле + Compiled (распространённая практика оптимизации)
private static readonly Regex DateRegex = new Regex(@"\d{4}-\d{2}-\d{2}", RegexOptions.Compiled);

Использование GeneratedRegex

Использование[GeneratedRegex]С помощью этого атрибута компилятор наэтапе компиляциисгенерирует регулярное выражение напрямую как эффективный код C# без синтаксического анализа или компиляции во время выполнения.

Требования к использованию: требуется .NET 7 или выше, а метод должен бытьpartialметод, класс, содержащий его, также должен бытьpartialclass.

Базовое использование GeneratedRegex

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   // Класс должен быть объявлен как partial
   partial class Program
   {
      // Используйте атрибут [GeneratedRegex], компилятор автоматически генерирует реализацию
      [GeneratedRegex(@"\d{4}-\d{2}-\d{2}")]
      private static partial Regex DateRegex();

      // Также можно добавить параметры, например игнорирование регистра
      [GeneratedRegex(@"\bS\S*", RegexOptions.IgnoreCase)]
      private static partial Regex StartsWithSRegex();

      static void Main(string[] args)
      {
         string input = "Сегодня 2024-06-18, следующее событие: 2025-01-01";

         // Используйте его как вызов обычного метода, возвращает экземпляр Regex
         foreach (Match m in DateRegex().Matches(input))
         {
            Console.WriteLine("Найдена дата:" + m.Value);
         }

         // Проверить, совпадает ли оно
         Console.WriteLine(StartsWithSRegex().IsMatch("Великолепно")); // Истина
      }
   }
}

Когда приведённый выше код компилируется и выполняется, он выдаёт следующий результат:

找到日期:2024-06-18
找到日期:2025-01-01
True

GeneratedRegex против традиционного Regex

В следующей таблице сравниваются два подхода по нескольким аспектам, чтобы помочь вам выбрать подходящий вариант использования:

Критерий сравненияТрадиционный RegexGeneratedRegex (генератор исходного кода)Рекомендуется
Минимальное требование.NET Framework / .NET Core: поддерживаются все версии.NET 7 и выше—
Момент компиляцииРазбор и компиляция во время выполненияВо время компиляции (на этапе сборки) генератор исходного кода Roslyn генерирует кодGeneratedRegex
Производительность выполненияОбычный: медленнее; с опцией Compiled: быстрее, но высокие накладные расходы при запускеСамый быстрый, близок по производительности к коду, написанному вручную, и без накладных расходов на запускGeneratedRegex
Использование памятиСкомпилированный режим генерирует IL-код и потребляет больше памятиОн генерирует обычный код C#, который более экономно использует памятьGeneratedRegex
Совместимость с AOTRegexOptions.Compiled несовместим с AOT (предварительная компиляция)Полностью совместим с Native AOT, подходит для публикации автономных приложенийGeneratedRegex
Читаемость кодаСтрока шаблона записывается непосредственно в коде, что более интуитивноТребуется определить частичный метод, и структура кода немного сложнееТрадиционный Regex (простые сценарии)
Динамический режимПоддерживается, шаблон может быть переменной времени выполненияНе поддерживается, шаблон должен быть константой времени компиляцииТрадиционный Regex (динамические сценарии)
Поддержка отладкиОбычныйСгенерированный код можно просмотреть и отладить напрямую, что делает его более прозрачнымGeneratedRegex
Применимые сценарииРазовое использование, динамические шаблоны, устаревшие проекты .NETВысокочастотные вызовы, чувствительность к производительности, AOT-публикация, новые проекты .NETЗависит от контекста

Рекомендации по использованию

  • Если вы используете.NET 7+и шаблон регулярного выражения фиксирован,предпочтительнее использовать[GeneratedRegex]。
  • Если шаблон регулярного выражения нужно динамически строить во время выполнения (например, генерировать из пользовательского ввода), только традиционныйnew Regex(pattern)。
  • Если проект должен поддерживатьNative AOTпри публикации (например, режим AOT в .NET 8), обязательно используйте[GeneratedRegex]а неRegexOptions.Compiled。
  • Новичкам можно сначала использовать традиционный метод для изучения и практики. После понимания принципов регулярных выражений постепенно переходите к[GeneratedRegex]。

Пример: использование GeneratedRegex для проверки формата электронной почты

using System;
using System.Text.RegularExpressions;

partial class EmailValidator
{
   // Определить регулярное выражение для проверки электронной почты без учета регистра
   [GeneratedRegex(@"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", RegexOptions.IgnoreCase)]
   private static partial Regex EmailRegex();

   public static bool IsValidEmail(string email)
   {
      return EmailRegex().IsMatch(email);
   }

   static void Main(string[] args)
   {
      string[] emails = { "user@example.com", "bad-email", "hello@world.org", "missing@dot" };
      foreach (var email in emails)
      {
         Console.WriteLine($"{email}: {(IsValidEmail(email) ? "корректный" : "Некорректный")}");
      }
   }
}

Когда приведённый выше код компилируется и выполняется, он выдаёт следующий результат:

user@example.com: 有效
bad-email: 无效
hello@world.org: 有效
missing@dot: 无效
Другие расширения