C# 如何解析这个？

我需要解析出具有以下结构的字符串

x:{a，b，c，}，y:{d，e，f}等

所有条目都是数字，所以看起来像这样

411:{1,2,3}，241:{4,1,2}等

---

忘记提及：{}之间逗号分隔的条目数没有上限，但必须至少有一个条目

我需要得到唯一的列表 前面的数字：，在上述情况下 411241

---

这可以用正则表达式实现吗？如何实现？

我认为这可能是可行的，伪代码

foreach match in Regex.Matches(yourInputString, "[0-9]{3}:\{[0-9,]\},")
    firstNumber = match.Value.Substring(0, 3)
    numbers() = match.Value.Substring(4, match.Value.Length - 5).Split(",")
next

---

我想这可能行得通，伪代码

foreach match in Regex.Matches(yourInputString, "[0-9]{3}:\{[0-9,]\},")
    firstNumber = match.Value.Substring(0, 3)
    numbers() = match.Value.Substring(4, match.Value.Length - 5).Split(",")
next

---

你为什么要用正则表达式做这个？我的意思是，您正在查询字符串中的id，并且给定了一个id，希望检索它的值。我只是将字符串分解，创建一个映射结构，该结构以id作为键，以数字集合作为值。

为什么要使用正则表达式执行此操作？我的意思是，您正在查询字符串中的id，并且给定了一个id，希望检索它的值。我只需将字符串拆分，创建一个以id为键、以数字集合为值的映射结构。

Regex:

(?<1>[\d]+):{(?<2>\d+),(?<3>\d+),(?<4>\d+)}

将生成以下匹配/组集合：

Match 0
Group 0: 411:{1,2,3}
Group 1: 411
Group 2: 1
Group 3: 2
Group 4: 3

Match 1
Group 0: 241:{4,1,2}
Group 1: 241
Group 2: 4
Group 3: 1
Group 4: 2

Match 2
Group 0: 314:{5,6,7}
Group 1: 314
Group 2: 5
Group 3: 6
Group 4: 7

您可以使用以下代码：

string expression = "(?<1>[\d]*):{(?<2>\d),(?<3>\d),(?<4>\d)}";
string input = "411:{1,2,3},241:{4,1,2},314:{5,6,7}";

Regex re = new Regex(expression, RegexOptions.IgnoreCase);

MatchCollection matches = re.Matches(input);

for (int i = 0; i < matches.Count; i++)
{
Match m = matches[i];
// for i==0
// m.groups[0] == 411:{1,2,3}
// m.groups[1] == 411
// m.groups[2] == 1
// m.groups[3] == 2
// m.groups[4] == 4
}

正则表达式：

将生成以下匹配/组集合：

Match 0
Group 0: 411:{1,2,3}
Group 1: 411
Group 2: 1
Group 3: 2
Group 4: 3

Match 1
Group 0: 241:{4,1,2}
Group 1: 241
Group 2: 4
Group 3: 1
Group 4: 2

Match 2
Group 0: 314:{5,6,7}
Group 1: 314
Group 2: 5
Group 3: 6
Group 4: 7

您可以使用以下代码：

string expression = "(?<1>[\d]*):{(?<2>\d),(?<3>\d),(?<4>\d)}";
string input = "411:{1,2,3},241:{4,1,2},314:{5,6,7}";

Regex re = new Regex(expression, RegexOptions.IgnoreCase);

MatchCollection matches = re.Matches(input);

for (int i = 0; i < matches.Count; i++)
{
Match m = matches[i];
// for i==0
// m.groups[0] == 411:{1,2,3}
// m.groups[1] == 411
// m.groups[2] == 1
// m.groups[3] == 2
// m.groups[4] == 4
}

---

第一个是可以通过以下正则表达式实现的：

\d*(?=:)

---

第一个是可以通过以下正则表达式实现的：

\d*(?=:)

---

如果我们考虑x:{a，b，c}一个元素，下面将给出一个匹配列表，其中有两个命名的GRUPs：外部和内部。外部是x，内部是a，b，c

(?<outer>\d+):\{(?<inner>\d+(,\d+)*)\}

（？\d+）：\{（？\d+（，\d+*）\}

更新 下面是一个代码示例：

        String input = "411:{1,2,3},241:{4,1,2},45:{1},34:{1,34,234}";
        String expr = @"(?<outer>\d+):\{(?<inner>\d+(,\d+)*)\}";

        MatchCollection matches = Regex.Matches(input, expr);

        foreach (Match match in matches)
        {
            Console.WriteLine("Outer: {0} Inner: {1}", match.Groups["outer"].Value, match.Groups["inner"]);
        }

String input=“411:{1,2,3}，241:{4,1,2}，45:{1}，34:{1,34234}”；
字符串expr=@“（？\d+）：\{（？\d+（，\d+*）\}”；
MatchCollection matches=Regex.matches（输入，表达式）；
foreach（匹配中的匹配）
{
WriteLine（“外部：{0}内部：{1}”，match.Groups[“外部”].Value，match.Groups[“内部”]）；
}
< /代码> 如果我们考虑x:{a，b，c}一个元素，下面将给出一个匹配列表，其中有两个命名的GRUPs：外部和内部。外部是x，内部是a，b，c

(?<outer>\d+):\{(?<inner>\d+(,\d+)*)\}

（？\d+）：\{（？\d+（，\d+*）\}

更新
下面是一个代码示例：

        String input = "411:{1,2,3},241:{4,1,2},45:{1},34:{1,34,234}";
        String expr = @"(?<outer>\d+):\{(?<inner>\d+(,\d+)*)\}";

        MatchCollection matches = Regex.Matches(input, expr);

        foreach (Match match in matches)
        {
            Console.WriteLine("Outer: {0} Inner: {1}", match.Groups["outer"].Value, match.Groups["inner"]);
        }

String input=“411:{1,2,3}，241:{4,1,2}，45:{1}，34:{1,34234}”；
字符串expr=@“（？\d+）：\{（？\d+（，\d+*）\}”；
MatchCollection matches=Regex.matches（输入，表达式）；
foreach（匹配中的匹配）
{
WriteLine（“外部：{0}内部：{1}”，match.Groups[“外部”].Value，match.Groups[“内部”]）；
}
此字符串具有json格式。因此，您可以使用来解析它
此字符串具有json格式。因此您可以使用来解析它
您正在使用JSON吗？如果是这样，您可能希望查看MSDN上的JavaScriptSerializer类

您正在使用JSON吗？如果是这样，您可能希望查看MSDN上的JavaScriptSerializer类

这里有一个没有RegEx的替代方案，可以运行得更快

这将返回一个
字典

public Dictionary<double, List<double>> Example()
        {
            String[] aSeparators = {"{", "},", ",", "}"};
            String data = "411:{1,2,3},843:{6,5,4,3,2,1},241:{4,1,2}";
            String[] bases = data.Split(aSeparators, StringSplitOptions.RemoveEmptyEntries);
            Dictionary<double, List<double>> aDict = null;

            double aHeadValue = 0;
            List<Double> aList = null;
            foreach (var value in bases)
            {
                if (value.EndsWith(":"))
                {
                    if (aDict == null)
                        aDict = new Dictionary<double, List<double>>();
                    else
                        aDict.Add(aHeadValue, aList);
                    aHeadValue = Double.Parse(value.TrimEnd(':'));
                    aList = new List<Double>();
                }
                else
                {
                    aList.Add(Double.Parse(value));
                }
            }
            aDict.Add(aHeadValue, aList);
            return aDict;
        }

公共字典示例（）
{
字符串[]aSeparators={{{，“}，”，“，”，“}”；
String data=“411:{1,2,3}，843:{6,5,4,3,2,1}，241:{4,1,2}”；
String[]base=data.Split（分隔符、StringSplitOptions.RemoveEmptyEntries）；
字典aDict=null；
双aHeadValue=0；
列表列表=空；
foreach（以基数表示的var值）
{
if（值.EndsWith（“：”）
{
if（aDict==null）
aDict=新字典（）；
其他的
aDict.Add（aHeadValue，aList）；
aHeadValue=Double.Parse（value.TrimEnd（“：”）；
aList=新列表（）；
}
其他的
{
aList.Add（Double.Parse（value））；
}
}
aDict.Add（aHeadValue，aList）；
回传平硐；
}
这里有一个没有RegEx的替代方案，可以运行得更快

这将返回一个
字典

public Dictionary<double, List<double>> Example()
        {
            String[] aSeparators = {"{", "},", ",", "}"};
            String data = "411:{1,2,3},843:{6,5,4,3,2,1},241:{4,1,2}";
            String[] bases = data.Split(aSeparators, StringSplitOptions.RemoveEmptyEntries);
            Dictionary<double, List<double>> aDict = null;

            double aHeadValue = 0;
            List<Double> aList = null;
            foreach (var value in bases)
            {
                if (value.EndsWith(":"))
                {
                    if (aDict == null)
                        aDict = new Dictionary<double, List<double>>();
                    else
                        aDict.Add(aHeadValue, aList);
                    aHeadValue = Double.Parse(value.TrimEnd(':'));
                    aList = new List<Double>();
                }
                else
                {
                    aList.Add(Double.Parse(value));
                }
            }
            aDict.Add(aHeadValue, aList);
            return aDict;
        }

公共字典示例（）
{
字符串[]aSeparators={{{，“}，”，“，”，“}”；
String data=“411:{1,2,3}，843:{6,5,4,3,2,1}，241:{4,1,2}”；
String[]base=data.Split（分隔符、StringSplitOptions.RemoveEmptyEntries）；
字典aDict=null；
双aHeadValue=0；
列表列表=空；
foreach（以基数表示的var值）
{
if（值.EndsWith（“：”）
{
if（aDict==null）
aDict=新字典（）；
其他的
aDict.Add（aHeadValue，aList）；
aHeadValue=Double.Parse（value.TrimEnd（“：”）；
aList=新列表（）；
}
其他的
{
aList.Add（Double.Parse（value））；
}
}
aDict.Add（aHeadValue，aList）；
回传平硐；
}
忘了提及：{}之间逗号分隔的条目数没有上限，但必须至少有一个条目。它必须是C#吗？因为这是一个sed管理单元。建议：我在我们的管理站点上构建了一个页面来测试正则表达式，它由一个表单组成，其中包含表达式字段、示例输入、替换文本和匹配列表。表单提交执行匹配或替换，并输出结果。这使得测试正则表达式非常简单，无需生成测试应用程序。免费，需要注册。很棒的工具。忘了提一下：{}之间逗号分隔的条目数没有上限，但必须至少有一个条目。它必须是C#吗？因为这是一个快照