C# 正则表达式以确保字符串中的；05123:12315“；，第一个数字比第二个小？

我必须有格式为x:y的字符串，其中x和y必须是五位数字（零填充），而x通常不能用正则表达式*执行此操作。您可以使用正则表达式匹配模式并提取数字，然后比较代码中的数字

例如，要匹配这种格式（不比较数字），并获得您可以使用的数字：

^(\d{5}):(\d{5})\z

---

*)在这种情况下，您可能会这样做（因为数字总是5位数字，加上零填充，但这并不好。

您通常不能用正则表达式*这样做。您可以使用正则表达式匹配模式并提取数字，然后比较代码中的数字

例如，要匹配这种格式（不比较数字），并获得您可以使用的数字：

^(\d{5}):(\d{5})\z

*)在这种情况下，您可能会这样做（因为数字总是5位数字，加上零填充，但这并不好）

x

---

x你应该这样做：

bool IsCorrect(string s)
{
    string[] split = s.split(':');
    int number1, number2;
    if (split.Length == 2 && split[0].Length == 5 && split[1].Length == 5)
    {
        if (int.TryParse(split[0], out number1) && int.TryParse(split[1], out number2) && number1 <= number2)
        {
            return true;
        }
    }
    return false;
}

bool IsCorrect（字符串s）
{
字符串[]split=s.split（“：”）；
整数1，整数2；
如果（split.Length==2&&split[0]。Length==5&&split[1]。Length==5）
{
如果（int.TryParse（split[0]，out number1）&&int.TryParse（split[1]，out number2）&&number1您应该这样做：

bool IsCorrect(string s)
{
    string[] split = s.split(':');
    int number1, number2;
    if (split.Length == 2 && split[0].Length == 5 && split[1].Length == 5)
    {
        if (int.TryParse(split[0], out number1) && int.TryParse(split[1], out number2) && number1 <= number2)
        {
            return true;
        }
    }
    return false;
}

bool IsCorrect（字符串s）
{
字符串[]split=s.split（“：”）；
整数1，整数2；
如果（split.Length==2&&split[0]。Length==5&&split[1]。Length==5）
{
如果（int.TryParse（split[0]，out number1）&&int.TryParse（split[1]，out number2）&&number1让我给你一个很好的例子，说明为什么不应该尝试这样做。这是一个（几乎）做同样工作的正则表达式


原始文件：


除了3位数字。对于4位数字，生成这些数字的程序会失败，出现
OutOfMemoryException
。启用
gcAllowVeryLargeObjects
。它一直持续到5GB，直到崩溃。你不希望你的大多数应用程序都是正则表达式，对吗

这不是正则表达式的工作。
让我给你一个很好的例子，说明为什么你不应该尝试这样做。这是一个（几乎）做同样工作的正则表达式


原始文件：


除了3位数字。对于4位数字，生成这些数字的程序会失败，出现
OutOfMemoryException
。启用
gcAllowVeryLargeObjects
。它一直持续到5GB，直到崩溃。你不希望你的大多数应用程序都是正则表达式，对吗

这不是正则表达式的工作。
这是一个两步过程，因为正则表达式是一个文本解析器而不是分析器。但是，尽管如此，正则表达式非常适合验证我们是否有5:5数字模式，并且这个正则表达式模式将确定我们是否有那个形状因子\d\d\d\d:\d\d\d\d\d\d。如果没有找到那个形状因子，那么匹配失败，整个验证失败。如果它有效，我们可以使用regex/linq解析出数字，然后检查有效性

此代码将位于执行检查的方法中

var data = "00515:02151";
var pattern = @"
^               # starting from the beginning of the string...
(?=[\d:]{11})   # Is there is a string that is at least 11 characters long with only numbers and a ;, fail if not
(?=\d{5}:\d{5}) # Does it fall into our pattern? If not fail the match
((?<Values>[^:]+)(?::?)){2}  
";

// IgnorePatternWhitespace only allows us to comment the pattern, it does not affect the regex parsing
var result = Regex.Matches(data, pattern, RegexOptions.IgnorePatternWhitespace)
                  .OfType<Match>()
                  .Select (mt =>  mt.Groups["Values"].Captures
                                                .OfType<Capture>()
                                                .Select (cp => int.Parse(cp.Value)))
                  .FirstOrDefault();

// Two values at this point 515, 2151

bool valid = ((result != null) && (result.First () < result.Last ()));

Console.WriteLine (valid); // True

var data=“00515:02151”；
变量模式=@“
^#从字符串的开头开始。。。
（？=[\d:{11}）#是否存在长度至少为11个字符且只有数字和a；，如果没有，则失败
（？=\d{5}:\d{5}）#这符合我们的模式吗？如果不是，比赛就失败了
((?[^:]+)(?::?)){2}  
";
//IgnorePatternWhitespace只允许我们对模式进行注释，它不影响正则表达式解析
var result=Regex.Matches（数据、模式、RegexOptions.IgnorePatternWhitespace）
第（）类
.选择（mt=>mt.Groups[“值”]）。捕获
第（）类
.Select（cp=>int.Parse（cp.Value）））
.FirstOrDefault（）；
//此时有两个值5152151
bool valid=（（result！=null）和&（result.First（）
这是一个两步过程，因为regex是一个文本解析器而不是分析器。但是，尽管如此，regex非常适合验证我们是否有5:5的数字模式，并且这个regex模式将确定我们是否有正确的形状因子\d\d\d\d:\d\d\d\d\d\d。如果没有找到该形状因子，则匹配失败，整个验证将失败如果有效，我们可以使用regex/linq解析出这些数字，然后检查其有效性

此代码将位于执行检查的方法中

var data = "00515:02151";
var pattern = @"
^               # starting from the beginning of the string...
(?=[\d:]{11})   # Is there is a string that is at least 11 characters long with only numbers and a ;, fail if not
(?=\d{5}:\d{5}) # Does it fall into our pattern? If not fail the match
((?<Values>[^:]+)(?::?)){2}  
";

// IgnorePatternWhitespace only allows us to comment the pattern, it does not affect the regex parsing
var result = Regex.Matches(data, pattern, RegexOptions.IgnorePatternWhitespace)
                  .OfType<Match>()
                  .Select (mt =>  mt.Groups["Values"].Captures
                                                .OfType<Capture>()
                                                .Select (cp => int.Parse(cp.Value)))
                  .FirstOrDefault();

// Two values at this point 515, 2151

bool valid = ((result != null) && (result.First () < result.Last ()));

Console.WriteLine (valid); // True

var data=“00515:02151”；
变量模式=@“
^#从字符串的开头开始。。。
（？=[\d:{11}）#是否存在长度至少为11个字符且只有数字和a；，如果没有，则失败
（？=\d{5}:\d{5}）#这符合我们的模式吗？如果不是，比赛就失败了
((?[^:]+)(?::?)){2}  
";
//IgnorePatternWhitespace只允许我们对模式进行注释，它不影响正则表达式解析
var result=Regex.Matches（数据、模式、RegexOptions.IgnorePatternWhitespace）
第（）类
.选择（mt=>mt.Groups[“值”]）。捕获
第（）类
.Select（cp=>int.Parse（cp.Value）））
.FirstOrDefault（）；
//此时有两个值5152151
bool valid=（（result！=null）和&（result.First（）
您想要识别的语言是有限的，因此最简单的方法就是列出所有以“or”分隔的情况。您想要的regexp是：

(00000:[00000|00001| ... 99999])|  ...  |(99998:[99998|99999])|(99999:99999)

这个regexp将有几十亿个字符长，并且需要相当长的时间来执行，但这正是您所要求的：一个与所述语言匹配的正则表达式

显然这是不切实际的。现在清楚为什么正则表达式是这个工作的错误工具了吗？使用正则表达式匹配5位数字-冒号-5位数字，然后一旦你知道了，就分开