65.9K
CodeProject 正在变化。 阅读更多。
Home

LINQ to Regex

Josef Pihrt
starIconstarIconstarIconstarIcon
emptyStarIcon
starIcon

4.93/5 (32投票s)

2015年8月12日

Apache

5分钟阅读

viewsIcon

33677

LINQ to Regex 库提供了对 .NET 正则表达式的语言集成访问。

引言

  • LINQ to Regex 库提供了对 .NET 正则表达式的语言集成访问。
  • 它允许您直接在代码中创建和使用正则表达式，并开发复杂的表达式，同时保持其可读性和可维护性。
  • 不需要了解正则表达式语法（但您应该熟悉基础知识）。
  • 该库通过 NuGet 分发。
  • 源代码可在 GitHub 上获取

命名空间

该库包含两个命名空间

Pihrtsoft.Text.RegularExpressions.Linq;
Pihrtsoft.Text.RegularExpressions.Linq.Extensions;

第一个命名空间是库的根命名空间。第二个命名空间包含带有扩展方法的静态类，这些方法扩展了现有的 .NET 类型。

Pattern 和 Patterns 类

Pattern 是最基础的库类型。它表示一个不可变的正则表达式模式。Pattern 类及其后代的实例可以通过 Patterns 静态类获取。Pattern 类还提供了实例方法，可以组合模式。以下模式将匹配一个数字字符。

Pattern pattern = Patterns.Digit();

正则表达式语法：\d

建议使用 using static（C# 6.0 或更高版本）引用 Patterns 类

using static Pihrtsoft.Text.RegularExpressions.Linq.Patterns;

或 Imports (Visual Basic)

Imports Pihrtsoft.Text.RegularExpressions.Linq.Patterns

这将允许您无需重复引用 Patterns 类即可创建模式。

Pattern pattern = Digit();

CharGrouping 和 Chars 类

CharGrouping 类型表示字符组的内容。CharGrouping 类及其后代的实例可以通过 Chars 静态类获取。CharGrouping 类还提供了实例方法，可以组合元素。

模式文本

Pattern 对象可以使用 ToString 方法转换为正则表达式文本。

public override string ToString()
public string ToString(PatternOptions options)
public string ToString(PatternSettings settings)

字符串参数

LINQ to Regex 总是将 string 参数中的每个字符解释为字面量，而不是元字符。以下模式将匹配反斜杠和点的组合。

Pattern pattern = @"\.";

正则表达式语法：\\\.

集合参数

实现至少非泛型 IEnumerable 接口的参数将以集合中任何一个元素必须匹配的方式解释。

此规则有一个例外，那就是 Patterns.Concat 静态方法。

Object 或 Object[] 参数

许多返回 Pattern 类实例的方法接受 object 类型的参数，通常命名为 content。这些方法可以处理以下类型（类型为 object）

  • 模式
  • CharGrouping
  • 字符串
  • char
  • object[]
  • IEnumerable

列表中的最后两项，Object[] 和 IEnumerable 可以包含零个或多个元素（模式），其中任何一个都必须匹配。

允许传递类型为 object 的内容的方法通常允许使用 params（Visual Basic 中的 ParamArray）关键字传递对象数组。此重载只是将对象数组转换为 object 并调用接受 object 作为参数的重载。

量词

Maybe 方法返回一个匹配前一个元素零次或一次的模式。

var pattern = Digit().Maybe();

或

var pattern = Maybe(Digit());

正则表达式语法：\d?

MaybeMany 方法返回一个匹配前一个元素零次或多次的模式。

var pattern = Digit().MaybeMany();

或

var pattern = MaybeMany(Digit());

正则表达式语法：\d*

OneMany 方法返回一个匹配前一个元素一次或多次的模式。

var pattern = Digit().OneMany();

或

var pattern = OneMany(Digit());

正则表达式语法：\d+

量词默认为“贪婪”，这意味着前一个元素匹配尽可能多的次数。如果您希望前一个元素匹配尽可能少的次数，请使用 Lazy 方法。以下模式将匹配任何字符零次或多次，但次数尽可能少。

var pattern = Any().MaybeMany().Lazy();

正则表达式语法：[\s\S]*?

以前的模式很常见，因此它被封装在 Crawl 方法中。

var pattern = Patterns.Crawl();

量词组

在正则表达式语法中，您只能在要量化的元素之后应用量词。在 LINQ to Regex 中，您可以定义一个量词组并将量化内容放入其中。

运算符

+ 运算符

+ 运算符将操作数连接成一个新模式。以下模式匹配一个空行。

var pattern = Patterns.BeginLine().Assert(Patterns.NewLine());

正则表达式语法：(?m:^)(?=(?:\r?\n))

使用 + 运算符可以达到相同的目的。

var pattern = Patterns.BeginLine() + Patterns.Assert(Patterns.NewLine());

使用 using static 语句，表达式更简洁。

var pattern = BeginLine() + Assert(NewLine());

- 运算符

- 运算符可用于创建字符减法。此运算符为 CharGroup、CharGrouping 和 CharPattern 类型定义。Except 方法用于创建字符减法。以下模式匹配除了回车和换行符之外的空白字符。

var pattern = Patterns.WhiteSpace().Except(Chars.CarriageReturn().Linefeed());

正则表达式语法：[\s-[\r\n]]

使用 - 运算符可以达到相同的目的。

var pattern = Patterns.WhiteSpace() - Chars.CarriageReturn().Linefeed();

以前的模式很常见，因此它被封装在 WhiteSpaceExceptNewLine 方法中。

var pattern = Patterns.WhiteSpaceExceptNewLine();

| 运算符

Any 方法表示一个组，其中必须匹配指定的模式中的任何一个。以下模式匹配以 a 或 b 开头的单词

var pattern = Any(
    WordBoundary() + "a" + WordChars(), 
    WordBoundary() + "b" + WordChars());

正则表达式语法：(?:\ba\w+|\bb\w+)

使用 | 运算符可以达到相同的目的

var pattern = (WordBoundary() + "a" + WordChars()) | (WordBoundary() + "b" + WordChars());

! 运算符

! 运算符用于创建与操作数含义相反的模式。以下模式表示没有前导回车的换行符，可用于将行尾规范化为 Windows 模式。

var pattern = Patterns.NotAssertBack(CarriageReturn()).Linefeed();

正则表达式语法：(?:(?<!\r)\n)

使用 ! 运算符可以达到相同的目的。

var pattern = !Patterns.AssertBack(CarriageReturn()) + Patterns.Linefeed();

使用 using static 语句，表达式更简洁。

var pattern = !AssertBack(CarriageReturn()) + Linefeed();

前缀“While”

“While”是 * 量词的别名。名称以“While”开头的方法返回匹配指定字符零次或多次的模式。

var pattern = WhileChar('a');

正则表达式语法：a*

var pattern = WhileDigit();

正则表达式语法：\d*

var pattern = WhileWhiteSpace();

正则表达式语法：\s*

var pattern = WhileWhiteSpaceExceptNewLine();

正则表达式语法：[\s-[\r\n]]*

var pattern = WhileWordChar();

正则表达式语法：\w*

前缀“WhileNot”

名称以“WhileNot”开头的方法返回匹配不是指定字符零次或多次的模式。

var pattern = WhileNotChar('a');

正则表达式语法：[^a]*

var pattern = WhileNotNewLineChar();

正则表达式语法：[^\r\n]*

前缀“Until”

名称以“Until”开头的方法返回匹配不是指定字符零次或多次并以指定字符终止的模式。

var pattern = UntilChar('a');

正则表达式语法：(?:[^a]*a)

var pattern = UntilNewLine();

正则表达式语法：(?:[^\n]*\n)

后缀“Native”

名称以“Native”结尾的方法返回根据提供的 RegexOptions 表现不同的模式。在以下两个模式中，点可以匹配除换行符之外的任何字符，如果应用 RegexOptions.Singleline 选项，则可以匹配任何字符。

var pattern = AnyNative();

正则表达式语法：.

var pattern = CrawlNative();

正则表达式语法：.*?

Concat 方法

静态方法 Patterns.Concat 连接指定集合的元素。

var pattern = Concat("a", "b", "c", "d");

正则表达式语法：abcd

Join 方法

静态方法 Patterns.Join 使用每个元素之间的指定分隔符连接指定集合的元素。它与 string.Join 方法非常相似。

var pattern = Join(WhiteSpaces(), "a", "b", "c", "d");

正则表达式语法：a\s+b\s+c\s+d

示例

在以下示例中，输出使用以下语法获得

Console.WriteLine(pattern.ToString(PatternOptions.FormatAndComment));

行首空白

var pattern = BeginLine().WhiteSpaceExceptNewLine().OneMany());

正则表达式语法

(?m:         # group options
    ^        # beginning of input or line
)            # group end
[\s-[\r\n]]+ # character group one or more times

重复的单词

var pattern = 
    Group(Word())
        .NotWordChars()
        .GroupReference(1)
        .WordBoundary();

正则表达式语法

(           # numbered group
    (?:     # noncapturing group
        \b  # word boundary
        \w+ # word character one or more times
        \b  # word boundary
    )       # group end
)           # group end
\W+         # non-word character one or more times
\1          # group reference
\b          # word boundary

C# 逐字字符串字面量

string q = "\"";

var pattern = "@" + q + WhileNotChar(q) + MaybeMany(q + q + WhileNotChar(q)) + q;

正则表达式语法

@"        # text
[^"]*     # negative character group zero or more times
(?:       # noncapturing group
    ""    # text
    [^"]* # negative character group zero or more times
)*        # group zero or more times
"         # quote mark

按任意顺序排列的单词序列

var pattern = 
    WordBoundary()
        .CountFrom(3,
            Any(values.Select(f => Group(Patterns.Text(f))))
            .WordBoundary()
            .NotWordChar().MaybeMany().Lazy())
        .GroupReference(1)
        .GroupReference(2)
        .GroupReference(3);

正则表达式语法

\b                # word boundary
(?:               # noncapturing group
    (?:           # noncapturing group
        (         # numbered group
            one   # text
        )         # group end
    |             # or
        (         # numbered group
            two   # text
        )         # group end
    |             # or
        (         # numbered group
            three # text
        )         # group end
    )             # group end
    \b            # word boundary
    \W*?          # non-word character zero or more times but as few times as possible
){3,}             # group at least n times
\1                # group reference
\2                # group reference
\3                # group reference

XML CDATA 值

var pattern = 
    "<![CDATA["
        + WhileNotChar(']')
        + MaybeMany(
            ']'
            + NotAssert("]>")
            + WhileNotChar(']'))
        + "]]>";

正则表达式语法

!         # text
\[         # left square bracket
CDATA      # text
\[         # left square bracket
[^\]]*     # negative character group zero or more times
(?:        # noncapturing group
    ]      # right square bracket
    (?!    # negative lookahead assertion
        ]> # text
    )      # group end
    [^\]]* # negative character group zero or more times
)*         # group zero or more times
]]>        # text

分布式

该库通过 NuGet 分发。

源代码

源代码可在 GitHub 上获取

.NET 正则表达式的桌面 IDE

如果您正在寻找 .NET 正则表达式的桌面 IDE，请尝试 Regexator。

© . All rights reserved.