C# Regexp查找并替换为找到的值

我有英国邮政编码数据，我想按字母顺序排序，当我这样做时，结果如下

N10-XX
N1-XX
N2-XX
N3-XX
N4-XX
N5-XX

N1-XX
N2-XX
N3-XX
N4-XX
N5-XX
N10-XX

我想要的是：

N10-XX
N1-XX
N2-XX
N3-XX
N4-XX
N5-XX

N1-XX
N2-XX
N3-XX
N4-XX
N5-XX
N10-XX

基本上，如果数字是1位数，我需要在数字的开头加0。就像N1应该是N01那样，regexp模式是什么

---

非常感谢。

如果你决心使用正则表达式，那么这应该可以做到

var text = @"N10-XX
N1-XX
N2-XX
N3-XX
N4-XX
N5-XX";

text = Regex.Replace(text, @"^N(\d)-", "N0$1-", RegexOptions.Multiline);

也就是说，您显然将更改原始数据，因此我不确定这是否适用

如果要按数字排序，但保留原始数据，则可能需要执行以下操作

text.Split('\n')
    .Select(o => new { Original = o, Normal = Regex.Replace(o, @"^N(\d)-", "N0$1-", RegexOptions.Compiled)})
    .OrderBy(o => o.Normal)
    .Select(o => o.Original)

---

如果你想用正则表达式，那么这个就可以了

var text = @"N10-XX
N1-XX
N2-XX
N3-XX
N4-XX
N5-XX";

text = Regex.Replace(text, @"^N(\d)-", "N0$1-", RegexOptions.Multiline);

也就是说，您显然将更改原始数据，因此我不确定这是否适用

如果要按数字排序，但保留原始数据，则可能需要执行以下操作

text.Split('\n')
    .Select(o => new { Original = o, Normal = Regex.Replace(o, @"^N(\d)-", "N0$1-", RegexOptions.Compiled)})
    .OrderBy(o => o.Normal)
    .Select(o => o.Original)

---

从示例中，我不确定邮政编码中的哪些数字需要排序。下面是一些有效的英国邮政编码的正则表达式示例。如果您使用上面的方法将其合并，您应该能够做到。

从示例中，我不确定邮政编码中的哪些数字需要排序。下面是一些有效的英国邮政编码的正则表达式示例。如果您使用上面的方法合并它，您应该能够做到这一点。

这里有一个按自然（？）顺序返回原始字符串的排序函数

List<string> list1 = new List<string>{ "N10-XX","N1-XX","N2-XX","N3-XX","N4-XX","N5-XX" };
List<string> list2 = new List<string>() { "File (5).txt", "File (1).txt", "File (10).txt", "File (100).txt", "File (2).txt" };   

var sortedList1 = MySort(list1).ToArray();
var sortedList2 = MySort(list2).ToArray();


public static IEnumerable<string> MySort(IEnumerable<string> list)
{
    int maxLen = list.Select(s => s.Length).Max();
    Func<string, char> PaddingChar = s => char.IsDigit(s[0]) ? ' ' : char.MaxValue;

    return 
        list.Select(s =>
                new
                {
                    OrgStr = s,
                    SortStr = Regex.Replace(s, @"(\d+)|(\D+)", m => m.Value.PadLeft(maxLen, PaddingChar(m.Value)))
                })
            .OrderBy(x => x.SortStr)
            .Select(x => x.OrgStr);
}

List list1=新列表{“N10-XX”、“N1-XX”、“N2-XX”、“N3-XX”、“N4-XX”、“N5-XX”}；
List list2=new List（）{“文件（5.txt）”、“文件（1.txt）”、“文件（10.txt）”、“文件（100.txt）”、“文件（2.txt）”；
var sortedList1=MySort（list1.ToArray（）；
var sortedList2=MySort（list2）.ToArray（）；
公共静态IEnumerable MySort（IEnumerable列表）
{
int maxLen=list.Select（s=>s.Length.Max（）；
Func PaddingChar=s=>char.IsDigit（s[0]）？“”：char.MaxValue；
返回
列表。选择（s=>
新的
{
OrgStr=s，
SortStr=Regex.Replace（s，@“（\d+）|（\d+），m=>m.Value.PadLeft（maxLen，PaddingChar（m.Value）））
})
.OrderBy（x=>x.SortStr）
.选择（x=>x.OrgStr）；
}

这里有一个排序函数，它以自然（？）顺序返回原始字符串

List<string> list1 = new List<string>{ "N10-XX","N1-XX","N2-XX","N3-XX","N4-XX","N5-XX" };
List<string> list2 = new List<string>() { "File (5).txt", "File (1).txt", "File (10).txt", "File (100).txt", "File (2).txt" };   

var sortedList1 = MySort(list1).ToArray();
var sortedList2 = MySort(list2).ToArray();


public static IEnumerable<string> MySort(IEnumerable<string> list)
{
    int maxLen = list.Select(s => s.Length).Max();
    Func<string, char> PaddingChar = s => char.IsDigit(s[0]) ? ' ' : char.MaxValue;

    return 
        list.Select(s =>
                new
                {
                    OrgStr = s,
                    SortStr = Regex.Replace(s, @"(\d+)|(\D+)", m => m.Value.PadLeft(maxLen, PaddingChar(m.Value)))
                })
            .OrderBy(x => x.SortStr)
            .Select(x => x.OrgStr);
}

List list1=新列表{“N10-XX”、“N1-XX”、“N2-XX”、“N3-XX”、“N4-XX”、“N5-XX”}；
List list2=new List（）{“文件（5.txt）”、“文件（1.txt）”、“文件（10.txt）”、“文件（100.txt）”、“文件（2.txt）”；
var sortedList1=MySort（list1.ToArray（）；
var sortedList2=MySort（list2）.ToArray（）；
公共静态IEnumerable MySort（IEnumerable列表）
{
int maxLen=list.Select（s=>s.Length.Max（）；
Func PaddingChar=s=>char.IsDigit（s[0]）？“”：char.MaxValue；
返回
列表。选择（s=>
新的
{
OrgStr=s，
SortStr=Regex.Replace（s，@“（\d+）|（\d+），m=>m.Value.PadLeft（maxLen，PaddingChar（m.Value）））
})
.OrderBy（x=>x.SortStr）
.选择（x=>x.OrgStr）；
}