C# 如何使用正则表达式将字符串“{key.value}}}”拆分为两个字符串“key”和“value”？ 我的问题:

下面是一个类似的列表：

var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}} ".Split(',');

我希望得到一个

字典

数据，如：

var results = new Dictionary<string, IEnumerable<string>>()
{
    {"data1",new[]{"id","value"}},  
    {"data2",new[]{"name","value"}},
};

我可以使用正则表达式获取匹配数据，但我不知道如何获取键

data1

和值

id

应匹配一组

*

任何字符，后跟点

\.

和另一组任何字符

*

然后，您可以获得正则表达式匹配的列表，并按第一组对它们进行分组，如

var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}} ".Split(',');
var regex = new Regex("{{(.*)\\.(.*)}}");
var matches = list.SelectMany(_ => regex.Matches(_));

var groupList = matches.Select(_ => new { data = _.Groups[1].Value, value = _.Groups[2].Value });

var groups = groupList.GroupBy(_ => _.data);

foreach (var g in groups)
    Console.WriteLine("group {0} {1}", g.Key, string.Join(",", g.Select(_ => _.value)));

---

如果要检索部分捕获，则需要使用捕获组，例如：

var regex = new Regex(@"{{(\w+)\.(\w+)}}");

请注意，我将正则表达式更改为仅捕获“word”字符，您必须将

更改为

\.

，因为点字符在正则表达式中具有特殊含义（它匹配任何字符）。我进一步使用字符串的

@

说明符来启用“逐字模式”，否则所有反斜杠都必须是双反斜杠（

\

）

然后，您可以从返回的

匹配对象中检索捕获的值，例如：

foreach (var e in list)
{
    var match = regex.Match(e);
    if (match.Success)
    {
         Console.WriteLine($"{match.Groups[1]} {match.Groups[2]}");
    }
}

没有正则表达式。请尝试以下操作：

            string list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}} ";
            Dictionary<string, string> dict = list.Trim().Split(new char[] { '{', '}', ',' }, StringSplitOptions.RemoveEmptyEntries)
                .Select((x, i) => new { val = x, index = i })
                .GroupBy(x => x.index / 2)
                .ToDictionary(x => x.FirstOrDefault().val, y => y.LastOrDefault().val);

string list=“{{data1.id}，{{{data1.value}，{{{data2.name}，{{{data2.value}}”；
Dictionary dict=list.Trim（）.Split（新字符[]{{{''，'}'，'，'}，StringSplitOptions.RemoveEmptyEntries）
.Select（（x，i）=>new{val=x，index=i}）
.GroupBy（x=>x.index/2）
.ToDictionary（x=>x.FirstOrDefault（）.val，y=>y.LastOrDefault（）.val）；
您可以使用以下代码

 var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}} ".Split(',');
        var results = new Dictionary<string, IEnumerable<string>>()
        {
            {"data1",new[]{"id","value"}},
            {"data2",new[]{"name","value"}},
        };

        var regex = new Regex(@"{{(\w+)\.(\w+)}}");

        foreach (var e in list)
        {
            var match = regex.Matches(e);
            Console.WriteLine($"{match[0].Groups[1]} {match[0].Groups[2]}");
        }

var list=“{{data1.id}，{{data1.value}，{{{data2.name}，{{{data2.value}}”。拆分（'，'）；
var results=newdictionary（）
{
{“data1”，新[]{“id”，“value”}，
{“data2”，新的[]{“name”，“value”}，
};
var regex=new regex（@“{（\w+）\（\w+}”）；
foreach（列表中的变量e）
{
var match=regex.Matches（e）；
Console.WriteLine（$“{match[0]。组[1]}{match[0]。组[2]}”）；
}
您可以使用正则表达式进行拆分，并使用Linq处理结果。比如说,

var result = list.Select(x=> Regex.Match(x,@"{{(?<Key>\w+)\.(?<Value>\w+)}}"))
    .Select(m=>new {Key = m.Groups["Key"].Value,Value=m.Groups["Value"].Value})
    .GroupBy(x=>x.Key)
    .Select(x=> new KeyValuePair<string,IEnumerable<string>>(x.Key,x.Select(c=>c.Value)));

var result=list.Select（x=>Regex.Match（x，@“{{（？\w+）\（？\w+}”））
.Select（m=>new{Key=m.Groups[“Key”].Value，Value=m.Groups[“Value”].Value}）
.GroupBy（x=>x.Key）
.Select（x=>newkeyvaluepair（x.Key，x.Select（c=>c.Value））；

输出

您可以尝试解决您的问题，而无需
Regex

var list=“{{data1.id}，{{data1.value}，{{{data2.name}，{{{data2.value}}.Trim（）.Split（'，'）；
var dict=新字典（）；
foreach（列表中的变量项）
{
var contents=item.Trim（'{'，'}'）.Split（'.'）；
如果（contents.Length！=2）
继续；
if（dict.ContainsKey（目录[0]））
{
var values=dict[contents[0]].ToList（）；
增加（内容[1]）；
dict[contents[0]]=值；
}
其他的
{
dict.Add（contents[0]，new List（）{contents[1]}）；
}
}

最后一个大括号后面还有一个空格，在解析之前调用
Trim（）
，不使用正则表达式

你可以试试下面的解决方案

使用“
”和“
迭代每个元素并修剪
{
和
}
再次通过
，获取数据和值

//Step - 1
var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}}".Split(',');

foreach(var element in list)
{ 
    //Step 2
    var input = element.Trim('{', '}').Split('.');
    //Step 3
    Console.WriteLine($"Data: {input[0]}, Value {input[1]}");
    //You can perform dictionary operations here
}


您可以尝试：

var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}}"
            .Split(',')
            .Select(x => x.Trim(new char[] { '{', '}' }));
var groupBy = list.Select(x => x.Split('.'))
                  .GroupBy(x => x[0])
                  .ToDictionary(y=> y.Key, y.Key[0] );

谢谢，但是我在解析“{（.*\.（.*}}”）时遇到了错误。

实际上，您可以在不使用regext的情况下拆分数据。这太棒了！

//Step - 1
var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}}".Split(',');

foreach(var element in list)
{ 
    //Step 2
    var input = element.Trim('{', '}').Split('.');
    //Step 3
    Console.WriteLine($"Data: {input[0]}, Value {input[1]}");
    //You can perform dictionary operations here
}

var list = "{{data1.id}},{{data1.value}},{{data2.name}},{{data2.value}}"
            .Split(',')
            .Select(x => x.Trim(new char[] { '{', '}' }));
var groupBy = list.Select(x => x.Split('.'))
                  .GroupBy(x => x[0])
                  .ToDictionary(y=> y.Key, y.Key[0] );