正则表达式管道字符用作子组内的分隔符

Question

我有由管道字符分隔的字符串。这是一个可重复的序列：

<machinenr>|<controldone>|<nrofitems|<items>

无论您在哪里看到项目标签，您都会看到项目编号也由中间的竖线字符分隔。好吧，它不是一种智能格式，但我必须解决它，我想在 C# 中使用正则表达式。所以假设上面的格式让我们有一个真实的例子：

446408|0|2|111|6847|446408||0||

注意理论上管道之间不需要有值，内容也不受长度限制。项目 ID 可以是 111 或 877333，但也可以是混合字母数字 ID XB111。所以这里我们有两台没有物品的机器：

446408|0|0||447400||0||

这里我们有几台机器没有或有一些物品。请注意，管道字符也用于分隔项目，因此管道中有管道：

446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0||

这台机器有三个项目： 446408|0|3|99884|111|73732|

项目ID：

99884|111|73732

正则表达式应该是什么样的？我已尝试使用以下命名组（更易于阅读），但它不起作用：

^(?P<machinenr>.*?)\|
(?P<controldone>.*?)\|
(?P<nrofitems>.*?)\|
(?P<items>.*?)\|

这里是对@Atterson @sln 和 @ 的澄清。注意，物品的数量可以是0-n，数量没有限制。让我们举个例子，一个带有机器的长字符串及其项目：446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0||我期望正则表达式做的是将此字符串分解为三个匹配项/部分及其值，第一个匹配项是：446408|0|1|111|第二场比赛：446408|0|3|99884|111|73732|第三场比赛：446408|0|0||好的，以每个部分应该被分成的值为例，让我们使用第二个匹配/部分。它是一台nr 446408的机器，它没有被控制为0，它有3个项目，项目ID：99884|111|73732。在这些项目之后，一个新的序列：

<machinenr>|<controldone>|<nrofitems|<items>

可以关注。 @Sanxofon 请在此处检查您的正则表达式：[链接]https://regex101.com/r/kC3gH0/87，不幸的是，您会看到它不匹配。

Answer 1

这不能用正则表达式来解决，没有办法告诉正则表达式：“匹配.*?\| 与某个捕获组相同的次数......恰好包含一个数字。”不过，这是使用普通旧 C# 解决此问题的直接方法。

string items = "446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0|";
var fields = items.Split('|');
for (int i = 0; i < fields.Length;) {
    Console.WriteLine("machinenr:" + fields[i++]);
    Console.WriteLine("controldone:" + fields[i++]);
    int numSubItems = Int32.Parse(fields[i++]);
    Console.WriteLine("num subitems:" + numSubItems);
    if (numSubItems == 0) {
        i++;
        continue;
    }                

    for (int subItemIndex = 0; subItemIndex < numSubItems; subItemIndex++) {
        Console.WriteLine("\tItem:" + (subItemIndex + 1) + ": " + fields[i++]);
    }                
}

仅供参考，我修剪了尾随的“|”你原来的字符串有，所以

string items = "446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0|";

而不是

string items = "446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0||";

Answer 2

命名的捕获组在 C# 中是 (?<nam>...) 而不是 (?P<name>...)。此外，您表达了重复匹配的愿望（因此我将您的正则表达式包装在重复的 (?<grp>..) 中。

您需要弄清楚如何区分物品和机器。例如，如果您可以说所有机器编号都是 6 位数字，并且项目是 0-5 位数字，那么您可以这样做......您仍然需要拆分 items 集合。

^(?<grp>(?<machinenr>[^\|]{6})\|
(?<controldone>[^\|]*)\|
(?<nrofitems>[^\|]*)\|
(?<items>(?:[^\|]{0,5}\|){1,}))*$

示例 C# 实现：

class Program
{

    static void Main(string[] args)
    {
        string strRegex = 
@"^(?<grp>(?<machinenr>[^\|]{6})\|
(?<controldone>[^\|]*)\|
(?<nrofitems>[^\|]*)\|
(?<items>(?:[^\|]{0,5}\|){1,}))*$";
        Regex myRegex = new Regex(strRegex, RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);
        string strTargetString = @"446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0||";

        MatchCollection matches = myRegex.Matches(strTargetString);

        foreach (Match m in matches)
        {
            for (int idx = 0; idx < m.Groups["grp"].Captures.Count; idx++)
            {
                Console.WriteLine("Group:");
                Console.WriteLine($"\tmachinenr={m.Group["machinenr"].Captures[idx]}");
                Console.WriteLine($"\tcontroldone={m.Groups["controldone"].Captures[idx]}");
                Console.WriteLine($"\tnrofitems={m.Groups["nrofitems"].Captures[idx]}");
                Console.WriteLine($"\titems={m.Groups["items"].Captures[idx]}");
            }
        }
    }
}

---

使用 C# IEnumerable 算法

拆分字符串并解析后续数组似乎更容易。但是，如果您担心处理大字符串或不想使用String.Split()，您可以使用IEnumerable<T> 方法。这是一种方法...

class Program
{

    public class Entry
    {
        public string MachineNr { get; set; }
        public string ControlDone { get; set; }
        public int Count { get; set; }
        public List<string> Items { get; set; }

        private static IEnumerable<string> fields(string list)
        {
            int idx = 0;
            do
            {
                int ndx = list.IndexOf('|', idx);
                if (ndx == 1)
                    yield return list.Substring(idx);
                else
                    yield return list.Substring(idx, ndx - idx);                        

                idx = ++ndx;
            }
            while (idx > 0 && idx < list.Length-1) ;
        }

        public static IEnumerable<Entry> parseList(string list)
        {
            int idx =0;
            var fields = Entry.fields(list).GetEnumerator();
            while (fields.MoveNext())
            {
                var e = new Entry();
                e.MachineNr = fields.Current;
                if (fields.MoveNext())
                {
                    e.ControlDone = fields.Current;
                    if (fields.MoveNext())
                    {
                        int val = 0;
                        e.Count = int.TryParse(fields.Current, out val) ? val : 0;
                        e.Items = new List<string>();
                        for (int x=e.Count;x>0;x--)
                        {
                            if (fields.MoveNext())
                                e.Items.Add(fields.Current);
                        }
                    }
                }

                yield return e;
            }
        }
    }
    static void Main(string[] args)
    {
        string strTargetString = @"446408|0|1|111|446408|0|3|99884|111|73732|446408|0|0||";
        foreach (var entry in Entry.parseList(strTargetString))
        {
            Console.WriteLine(
$@"Group:
    Machine:        {entry.MachineNr}
    ControlDone:    {entry.ControlDone}
    Count:          {entry.Count}
    Items:          {string.Join(", ",entry.Items)}");
        }

    }
}