C# 简单正则表达式 - 32 个字符，仅包含 0-9 和 af (GUID)

Question

如何在 C# 中使用正则表达式进行测试：

• 字符串长度恰好为 32
• 字符串仅包含 0-9 的数字和 af 的小写字母

Answer 1

怎么样：

Regex regex = new Regex("^[0-9a-f]{32}$");
if (regex.IsMatch(text))
...

Answer 2

在 .Net 4.0 中，有一个 Guid 结构，它具有 TryParse 静态函数。
http://msdn.microsoft.com/en-us/library/system .guid.aspx

Answer 3

如果您不打算使用正则表达式来实现此目的，那么这非常干净：

Func<char, bool> charValid = c => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
bool isValid = text.Length == 32 && text.All(charValid);

Answer 4

好的，这里有一个答案向您展示如何确定该字符串的长度是否为 32 个字符，并且每个字符要么是数字，要么是小写“a”到小写“f”，并使用正则表达式，另一个答案向您展示了如何使用一个简单的 Func 来扫描字符串中的字符。它们都是很好的答案，并且在技术上是正确的，但是在您的问题标题中，您明确指出了“GUID”，这打开了新的蠕虫罐头。

GUID 可以采用多种不同的字符串表示形式，您可能会遇到其中任何一种。您需要处理所有这些吗？您是否需要容纳以大括号（“{”和“}”）或圆括号开头和结尾的字符串？破折号（'-'）呢？ 根据 MSDN，创建一个新的 GUID，并

string s = ...;
Guid g = new Guid(s);

允许使用以下字符串形式

32 个连续数字：
dddddddddddddddddddddddddddddddd

-或-

8、4、4、4 和 12 位数字组
组之间用连字符。这
可以选择包含整个 GUID
在匹配的大括号或圆括号中：
dddddddd-dddd-dddd-dddd-dddddddddddd

-或-

{dddddddd-dddd-dddd-dddd-dddddddddddd}

-或-

(dddddddd-dddd-dddd-dddd-dddddddddddd)

-或-

8、4 和 4 位数字组，以及
八组 2 位数字的子集，
每个组以“0x”为前缀或
“0X”，并用逗号分隔。这
整个 GUID 及其子集是
用匹配的大括号括起来：{0xdddddddd, 0xdddd, 0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}

您需要处理所有这些情况吗？另外，请考虑使用正则表达式是否真的是最好的选择。正如一些人已经评论的那样，正则表达式可能会让一些开发人员感到困惑，而且意图并不总是明确的。最重要的是，在某些情况下，正则表达式可能会慢。

我对三种不同的方法进行了快速性能测试，以确定字符串是否实际上是 GUID 的字符串表示形式：

1. 正则表达式
2. 检查字符串中的所有字符
3. 使用给定字符串创建新的 Guid 实例（如果可以创建 Guid，那么该字符串是有效的字符串表示形式）

这是代码：

[测试]

public void Test_IsRegex_Performance()
{
    Action withRegexMatch = () =>
    {
        Regex regex = new Regex("^[0-9a-f]{32}$");
        Guid g = new Guid();
        string s = g.ToString();
        regex.IsMatch(s);
    };

    Action withCharCheck = () =>
    {
        Guid g = new Guid();
        string s = g.ToString();

        Func<char, bool> charValid = c => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f');
        bool isValid = s.Length == 32 && s.All(charValid);
    };

    Action withNewGuid = () =>
    {
        Guid g = new Guid();
        string s = g.ToString();
        try
        {
            Guid g2 = new Guid(s);
            // if no exception is thrown, this is a valid string 
            // representation
        }
        catch
        {
            // if an exception was thrown, this is an invalid
            // string representation
        }
    };

    const int times = 100000;

    Console.WriteLine("Regex: {0}", TimedTask(withRegexMatch, times));
    Console.WriteLine("Checking chars: {0}", TimedTask(withCharCheck, times));
    Console.WriteLine("New Guid: {0}", TimedTask(withNewGuid, times));
    Assert.Fail();
}

private static TimeSpan TimedTask(Action action, int times)
{
    Stopwatch timer = new Stopwatch();
    timer.Start();
    for (int i = 0; i < times; i++)
    {
        action();
    }
    timer.Stop();
    return timer.Elapsed;
}

在我的机器上进行一百万次迭代的结果：

Regex: 00:00:10.1786901
Checking chars: 00:00:00.2504520
New Guid: 00:00:01.3129005

因此，正则表达式解决方案很慢。问问自己是否真的需要一个正则表达式。请注意，您可能可以通过仅声明一次正则表达式并重用它来获得一些额外的性能，但我认为这种情况下的要点是，通过查看您正在做什么，您可能会取得更好的成功尝试完成，而不是如何。

希望有帮助。