Source generators (генераторы исходного кода) — это часть платформы Roslyn, которая появилась в .NET 5. Они позволяют анализировать существующий код и создавать новые файлы с исходным кодом, которые в свою очередь могут добавляться в процесс компиляции.
В .NET 7 появилась новая функиональность для регулярных выражений, которая позволяет генерировать исходный код для проверки регулярного выражения во время компиляции с помощью специального source generator. Генерация исходного кода во время компиляции, а не во время выполнения, имеет несколько преимуществ:
Ускоряется первый вызов regex — потому что для него не нужно анализировать регулярное выражение и генерировать код для его выполнения в рантайме.
Во время компиляции можно потратить больше времени на оптимизацию кода регулярного выражения, поэтому код максимально оптимизирован. Сейчас (в .NET 7 Preview 3) при использовании regex source generator результирующий код совпадает с тем, который генерируется для регулярных выражений с флагом
RegexOptions.Compiled, но в будущем это поведение может измениться.Для платформ, которые не позволяют генерировать код в рантайме, таких как iOS, можно добиться максимальной производительности регулярных выражений.
Исходный код становится более читаемым в сравнении с использованием
Regex.IsMatch(value, pattern)потому что метод проверки выражения будет иметь осмысленное понятное имя.Сгенерированный код содержит комментарии, которые описывают, чему соответствует регулярное выражение. Это поможет понять и лучше разобраться, что делает regex, даже если вы не знаете какую-то часть синтаксиса регулярных выражений.
В случае self-contained application, когда .net runtime и библиотеки упаковываются в результирующее приложение, упаковка получится более компактной потому что не будет содержать кода для парсинга регулярных выражений и генерации кода для них.
Можно дебажить код при необходимости!
Можно узнать о хороших приемах оптимизации, читая сгенерированный код (но об этом будет в самом конце статьи).
Для генерации кода все параметры регулярного выражения (regex pattern, опции и таймаут) должны быть константными.
public static bool IsLowercase(string value)
{
// ✔️ pattern задан константой
// => Регулярное выражение может быть преобразовано в использование source generator
var lowercaseLettersRegex = new Regex("[a-z]+");
return lowercaseLettersRegex.IsMatch("abc");
}
public static bool IsLowercase(string value)
{
// ✔️ pattern, опции и таймаут заданы константой
// => Регулярное выражение может быть преобразовано в использование source generator
return Regex.IsMatch(value, "[a-z]+", RegexOptions.CultureInvariant, TimeSpan.FromSeconds(1));
}
public static bool Match(string value, string pattern)
{
// ❌ pattern неизвестен на этапе компиляции и задается параметром
// => Невозможно использовать source generator
return Regex.IsMatch(value, pattern);
}Чтобы конвертировать регулярное выражение в применение source generator вам нужно создать вместо него partial-метод, помеченный атрибутом [RegexGenerator]. Тип, в котором используется регулярное выражение тоже нужно будет пометить как partial:
// Source Generator сгенерирует код метода во время компиляции
[RegexGenerator("^[a-z]+$", RegexOptions.CultureInvariant, matchTimeoutMilliseconds: 1000)]
private static partial Regex LowercaseLettersRegex();
public static bool IsLowercase(string value)
{
return LowercaseLettersRegex().IsMatch(value);
}Сгенерированный код можно посмотреть в partial-классе через Solution explorer или перейти к нему командой "Go to definition":
Автоматическое преобразование Regex в Source Generator
NuGet-пакет Meziantou.Analyzer содержит анализатор для поиска регулярных выражений, которые могут быть преобразованы в Source Generator, и позволяет легко конвертировать существующие Regex в partail-метод с аннотацией [RegexGenerator]. Достаточно добавить пакет в проект:
dotnet add package Meziantou.AnalyzerПравило MA0110 сообщит о всех регулярных выражениях, для которых можно сгенерировать код на этапе компиляции. Анализатор предоставляет действие для преобразования кода (code fix) из Regex в генератор.
Статус поддержки
Использовать regex source generator и Meziantou.Analyzer можно с .NET 7 (начиная с Preview 1) и C# 11.
Rider частично поддерживает C# 11 с версии 2022.1 EAP — код при компиляции генерируется, к нему можно перейти через Go to definition, но сгенерированный файл не отображается в дереве решений.
Visual Studio 17.2 Preview 1 и более поздние версии поддерживают .NET 7 и C# 11.
Ложка дёгтя — пример сгенерированного кода
По описанию regex source generator из исходной статьи — это отличная фича не только для производительности и уменьшения размера self-contained application, но и для упрощения чтения и дебага сложных регулярных выражений. На сколько же лаконичным получается сгенерированный код? Давайте посмотрим на примере поиска номера телефона в строке:
[RegexGenerator(@"(\+7|7|8)?[\s\-]?\(?[489][0-9]{2}\)?[\s\-]?[0-9]{3}[\s\-]?[0-9]{2}[\s\-]?[0-9]{2}"]
private partial Regex RussianPhoneNumberRegex();
public string? FindPhoneNumber(string text)
{
var match = RussianPhoneNumberRegex().Match(text);
return match.Success ? match.Value : null;
}В результате генерируется файл для проверки регулярного выражения, который можно попытаться изучить самостоятельно и оценить читаемость и внутреннее устройство кода:
362 строки сгенерированного кода регулярного выражения
// <auto-generated/>
#nullable enable
#pragma warning disable CS0162 // Unreachable code
#pragma warning disable CS0164 // Unreferenced label
#pragma warning disable CS0219 // Variable assigned but never used
namespace RegexGeneratorExample
{
partial class RegexContainer
{
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "7.0.6.17504")]
private partial global::System.Text.RegularExpressions.Regex RussianPhoneNumberRegex() => global::System.Text.RegularExpressions.Generated.__2b701bf8.RussianPhoneNumberRegex_0.Instance;
}
}
namespace System.Text.RegularExpressions.Generated
{
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;
using System.Threading;
[GeneratedCodeAttribute("System.Text.RegularExpressions.Generator", "7.0.6.17504")]
[EditorBrowsable(EditorBrowsableState.Never)]
internal static class __2b701bf8
{
/// <summary>Custom <see cref="Regex"/>-derived type for the RussianPhoneNumberRegex method.</summary>
internal sealed class RussianPhoneNumberRegex_0 : Regex
{
/// <summary>Cached, thread-safe singleton instance.</summary>
internal static readonly RussianPhoneNumberRegex_0 Instance = new();
/// <summary>Initializes the instance.</summary>
private RussianPhoneNumberRegex_0()
{
base.pattern = "(\\+7|7|8)?[\\s\\-]?\\(?[489][0-9]{2}\\)?[\\s\\-]?[0-9]{3}[\\s\\-]?[0-9]{2}[\\s\\-]?[0-9]{2}";
base.roptions = RegexOptions.CultureInvariant;
base.internalMatchTimeout = TimeSpan.FromMilliseconds(1000);
base.factory = new RunnerFactory();
base.capsize = 2;
}
/// <summary>Provides a factory for creating <see cref="RegexRunner"/> instances to be used by methods on <see cref="Regex"/>.</summary>
private sealed class RunnerFactory : RegexRunnerFactory
{
/// <summary>Creates an instance of a <see cref="RegexRunner"/> used by methods on <see cref="Regex"/>.</summary>
protected override RegexRunner CreateInstance() => new Runner();
/// <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
private sealed class Runner : RegexRunner
{
// Description:
// ○ Optional (greedy).
// ○ 1st capture group.
// ○ Match with 2 alternative expressions.
// ○ Match the string "+7".
// ○ Match a character in the set [78].
// ○ Match a character in the set [-\s] atomically, optionally.
// ○ Match '(' atomically, optionally.
// ○ Match a character in the set [489].
// ○ Match '0' through '9' exactly 2 times.
// ○ Match ')' atomically, optionally.
// ○ Match a character in the set [-\s] atomically, optionally.
// ○ Match '0' through '9' exactly 3 times.
// ○ Match a character in the set [-\s] atomically, optionally.
// ○ Match '0' through '9' exactly 2 times.
// ○ Match a character in the set [-\s] atomically, optionally.
// ○ Match '0' through '9' exactly 2 times.
/// <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
protected override void Scan(ReadOnlySpan<char> inputSpan)
{
// Search until we can't find a valid starting position, we find a match, or we reach the end of the input.
while (TryFindNextPossibleStartingPosition(inputSpan))
{
base.CheckTimeout();
if (TryMatchAtCurrentPosition(inputSpan) || base.runtextpos == inputSpan.Length)
{
return;
}
base.runtextpos++;
}
}
/// <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if a possible match was found; false if no more matches are possible.</returns>
private bool TryFindNextPossibleStartingPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
char ch;
// Validate that enough room remains in the input to match.
// Any possible match is at least 10 characters.
if (pos <= inputSpan.Length - 10)
{
// The pattern begins with a character in the set [(+-47-9\s].
// Find the next occurrence. If it can't be found, there's no match.
ReadOnlySpan<char> span = inputSpan.Slice(pos);
for (int i = 0; i < span.Length; i++)
{
if (((ch = span[i]) < 128 ? ("㸀\0⤁ΐ\0\0\0\0"[ch >> 4] & (1 << (ch & 0xF))) != 0 : RegexRunner.CharInClass((char)ch, "\0\n\u0001()+,-.457:d")))
{
base.runtextpos = pos + i;
return true;
}
}
}
// No match found.
base.runtextpos = inputSpan.Length;
return false;
}
/// <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
/// <param name="inputSpan">The text being scanned by the regular expression.</param>
/// <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
private bool TryMatchAtCurrentPosition(ReadOnlySpan<char> inputSpan)
{
int pos = base.runtextpos;
int matchStart = pos;
int loopTimeoutCounter = 0;
char ch;
int loop_iteration = 0, loop_starting_pos = 0;
int stackpos = 0;
ReadOnlySpan<char> slice = inputSpan.Slice(pos);
// Optional (greedy).
//{
loop_iteration = 0;
loop_starting_pos = pos;
LoopBody:
if (++loopTimeoutCounter == 2048)
{
loopTimeoutCounter = 0;
base.CheckTimeout();
}
Utilities.StackPush3(ref base.runstack!, ref stackpos, base.Crawlpos(), loop_starting_pos, pos);
loop_starting_pos = pos;
loop_iteration++;
// 1st capture group.
//{
int capture_starting_pos = pos;
// Match with 2 alternative expressions.
//{
if (slice.IsEmpty)
{
goto LoopIterationNoMatch;
}
switch (slice[0])
{
case '+':
// Match '7'.
if ((uint)slice.Length < 2 || slice[1] != '7')
{
goto LoopIterationNoMatch;
}
pos += 2;
slice = inputSpan.Slice(pos);
break;
case '7' or '8':
pos++;
slice = inputSpan.Slice(pos);
break;
default:
goto LoopIterationNoMatch;
}
//}
base.Capture(1, capture_starting_pos, pos);
//}
if (pos != loop_starting_pos && loop_iteration == 0)
{
goto LoopBody;
}
goto LoopEnd;
LoopIterationNoMatch:
loop_iteration--;
if (loop_iteration < 0)
{
UncaptureUntil(0);
return false; // The input didn't match.
}
Utilities.StackPop2(base.runstack, ref stackpos, out pos, out loop_starting_pos);
UncaptureUntil(base.runstack![--stackpos]);
slice = inputSpan.Slice(pos);
LoopEnd:;
//}
// Match a character in the set [-\s] atomically, optionally.
{
if (!slice.IsEmpty && ((ch = slice[0]) < 128 ? ("㸀\0 \0\0\0\0\0"[ch >> 4] & (1 << (ch & 0xF))) != 0 : RegexRunner.CharInClass((char)ch, "\0\u0002\u0001-.d")))
{
slice = slice.Slice(1);
pos++;
}
}
// Match '(' atomically, optionally.
{
if (!slice.IsEmpty && slice[0] == '(')
{
slice = slice.Slice(1);
pos++;
}
}
if ((uint)slice.Length < 3 ||
(((ch = slice[0]) != '4') & (ch != '8') & (ch != '9')) || // Match a character in the set [489].
(((uint)slice[1]) - '0' > (uint)('9' - '0')) || // Match '0' through '9' exactly 2 times.
(((uint)slice[2]) - '0' > (uint)('9' - '0')))
{
goto LoopIterationNoMatch;
}
// Match ')' atomically, optionally.
{
if ((uint)slice.Length > (uint)3 && slice[3] == ')')
{
slice = slice.Slice(1);
pos++;
}
}
// Match a character in the set [-\s] atomically, optionally.
{
if ((uint)slice.Length > (uint)3 && ((ch = slice[3]) < 128 ? ("㸀\0 \0\0\0\0\0"[ch >> 4] & (1 << (ch & 0xF))) != 0 : RegexRunner.CharInClass((char)ch, "\0\u0002\u0001-.d")))
{
slice = slice.Slice(1);
pos++;
}
}
// Match '0' through '9' exactly 3 times.
{
if ((uint)slice.Length < 6 ||
(((uint)slice[3]) - '0' > (uint)('9' - '0')) ||
(((uint)slice[4]) - '0' > (uint)('9' - '0')) ||
(((uint)slice[5]) - '0' > (uint)('9' - '0')))
{
goto LoopIterationNoMatch;
}
}
// Match a character in the set [-\s] atomically, optionally.
{
if ((uint)slice.Length > (uint)6 && ((ch = slice[6]) < 128 ? ("㸀\0 \0\0\0\0\0"[ch >> 4] & (1 << (ch & 0xF))) != 0 : RegexRunner.CharInClass((char)ch, "\0\u0002\u0001-.d")))
{
slice = slice.Slice(1);
pos++;
}
}
// Match '0' through '9' exactly 2 times.
{
if ((uint)slice.Length < 8 ||
(((uint)slice[6]) - '0' > (uint)('9' - '0')) ||
(((uint)slice[7]) - '0' > (uint)('9' - '0')))
{
goto LoopIterationNoMatch;
}
}
// Match a character in the set [-\s] atomically, optionally.
{
if ((uint)slice.Length > (uint)8 && ((ch = slice[8]) < 128 ? ("㸀\0 \0\0\0\0\0"[ch >> 4] & (1 << (ch & 0xF))) != 0 : RegexRunner.CharInClass((char)ch, "\0\u0002\u0001-.d")))
{
slice = slice.Slice(1);
pos++;
}
}
// Match '0' through '9' exactly 2 times.
{
if ((uint)slice.Length < 10 ||
(((uint)slice[8]) - '0' > (uint)('9' - '0')) ||
(((uint)slice[9]) - '0' > (uint)('9' - '0')))
{
goto LoopIterationNoMatch;
}
}
// The input matched.
pos += 10;
base.runtextpos = pos;
base.Capture(0, matchStart, pos);
return true;
// <summary>Undo captures until it reaches the specified capture position.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void UncaptureUntil(int capturePosition)
{
while (base.Crawlpos() > capturePosition)
{
base.Uncapture();
}
}
}
}
}
}
private static class Utilities
{
// <summary>Pushes 3 values onto the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void StackPush3(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
// If there's space available for all 3 values, store them.
int[] s = stack;
int p = pos;
if ((uint)(p + 2) < (uint)s.Length)
{
s[p] = arg0;
s[p + 1] = arg1;
s[p + 2] = arg2;
pos += 3;
return;
}
// Otherwise, resize the stack to make room and try again.
WithResize(ref stack, ref pos, arg0, arg1, arg2);
// <summary>Resize the backtracking stack array and push 3 values onto the stack.</summary>
[MethodImpl(MethodImplOptions.NoInlining)]
static void WithResize(ref int[] stack, ref int pos, int arg0, int arg1, int arg2)
{
Array.Resize(ref stack, (pos + 2) * 2);
StackPush3(ref stack, ref pos, arg0, arg1, arg2);
}
}
// <summary>Pops 2 values from the backtracking stack.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void StackPop2(int[] stack, ref int pos, out int arg0, out int arg1)
{
arg0 = stack[--pos];
arg1 = stack[--pos];
}
}
}
}
