C# LINQ匿名对象由于其保护级别而不可访问

我有LINQ逻辑，它将正则表达式解析的数据收集到动态创建的字典中。我面临的问题是访问字典中的数据（

Info

）

Regex
.匹配（文本、图案、，
RegexOptions.IgnorePatternWhitespace | RegexOptions.ExplicitCapture）
第（）类
.选择（mt=>new
{
Info=mt.Groups[“ADKey”]。捕获
第（）类
.Select（cp=>cp.Value）
.Zip（mt.Groups[“ADValue”].Captures.OfType（）.Select（cp=>cp.Value），
（k，v）=>new{key=k，value=v}）
.ToDictionary（cp=>cp.key，cp=>cp.value），
节点=mt.Groups[“Key”]。捕获
第（）类
.Select（cp=>cp.Value）
.Zip（mt.Groups[“Value”].Captures.OfType（）.Select（cp=>cp.Value），
（k，v）=>new{key=k，value=v}）
.ToDictionary（cp=>cp.key，cp=>cp.value），
});
List myInfo=新列表（）；
myInfo=Info.Keys.ToList（）；

---

当我试图访问字典（info）时，在转换为列表时，我得到一个错误，即“info”由于其保护级别而无法访问。如何修复此问题？

您当前正在创建一个匿名类型列表，其中包含一个属性

Info

，即

字典
。您似乎没有在变量中捕获结果。然后尝试访问
Info
，就好像它是
RegEx
查询之外的单个对象一样。这两个
Info
引用了不同的东西

我给您的第一个建议是如下更改代码：

IEnumerable<Dictionary<string, string>> query =
    Regex
        .Matches(
            text,
            pattern,
            RegexOptions.IgnorePatternWhitespace
                | RegexOptions.ExplicitCapture) 
        .OfType<Match>()
        .Select(mt => mt.Groups["Key"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value)
                .Zip(
                    mt.Groups["Value"].Captures
                        .OfType<Capture>()
                        .Select(cp => cp.Value),
                    (k, v) => new
                    {
                        key = k,
                        value = v
                    })
                .ToDictionary(cp => cp.key, cp => cp.value));

Match match = Regex.Match(text, pattern,
    RegexOptions.IgnorePatternWhitespace
        | RegexOptions.ExplicitCapture);

Dictionary<string, string> result =
    match
        .Groups["Key"]
        .Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(
            match.Groups["Value"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value),
            (k, v) => new
            {
                key = k,
                value = v
            })
        .ToDictionary(cp => cp.key, cp => cp.value);

IEnumerable查询=
正则表达式
.火柴(
文本，
图案
RegexOptions.IgnorePatternWhitespace
|RegexOptions.ExplicitCapture）
第（）类
.选择（mt=>mt.Groups[“Key”]）。捕获
第（）类
.Select（cp=>cp.Value）
Zip先生(
mt.Groups[“值”]捕获
第（）类
.选择（cp=>cp.Value），
（k，v）=>新的
{
key=k，
值=v
})
.ToDictionary（cp=>cp.key，cp=>cp.value））；

现在，我不相信您想要一个
IEnumerable
，因为在接下来的两行中，您似乎希望直接从结果中提取关键点

看起来您可能需要以下内容：

Dictionary<string, string> query =
    Regex
        .Matches(text, pattern,
            RegexOptions.IgnorePatternWhitespace
                | RegexOptions.ExplicitCapture) 
        .OfType<Match>()
        .SelectMany(mt => mt.Groups["Key"].Captures
            .OfType<Capture>()
            .Select(cp => cp.Value)
            .Zip(
                mt.Groups["Value"].Captures
                    .OfType<Capture>()
                    .Select(cp => cp.Value),
                (k, v) => new
                {
                    key = k,
                    value = v
                }))
        .ToDictionary(cp => cp.key, cp => cp.value);

Match match =
    Regex.Match(text, pattern,
        RegexOptions.IgnorePatternWhitespace
            | RegexOptions.ExplicitCapture);

var result = new
{
    Info = match.Groups["ADKey"].Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(match.Groups["ADValue"].Captures.OfType<Capture>().Select(cp => cp.Value),
            (k, v) => new { key = k, value = v })
        .ToDictionary(cp => cp.key, cp => cp.value),
    Nodes = match.Groups["Key"].Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(match.Groups["Value"].Captures.OfType<Capture>().Select(cp => cp.Value),
            (k, v) => new { key = k, value = v })
        .ToDictionary(cp => cp.key, cp => cp.value),
};

List<string> myInfo = result.Info.Keys.ToList();

字典查询=
正则表达式
.匹配（文本、图案、，
RegexOptions.IgnorePatternWhitespace
|RegexOptions.ExplicitCapture）
第（）类
.SelectMany（mt=>mt.Groups[“Key”]）。捕获
第（）类
.Select（cp=>cp.Value）
Zip先生(
mt.Groups[“值”]捕获
第（）类
.选择（cp=>cp.Value），
（k，v）=>新的
{
key=k，
值=v
}))
.ToDictionary（cp=>cp.key，cp=>cp.value）；

但我怀疑这会有钥匙碰撞

我想你可能想要这样的东西：

IEnumerable<Dictionary<string, string>> query =
    Regex
        .Matches(
            text,
            pattern,
            RegexOptions.IgnorePatternWhitespace
                | RegexOptions.ExplicitCapture) 
        .OfType<Match>()
        .Select(mt => mt.Groups["Key"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value)
                .Zip(
                    mt.Groups["Value"].Captures
                        .OfType<Capture>()
                        .Select(cp => cp.Value),
                    (k, v) => new
                    {
                        key = k,
                        value = v
                    })
                .ToDictionary(cp => cp.key, cp => cp.value));

Match match = Regex.Match(text, pattern,
    RegexOptions.IgnorePatternWhitespace
        | RegexOptions.ExplicitCapture);

Dictionary<string, string> result =
    match
        .Groups["Key"]
        .Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(
            match.Groups["Value"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value),
            (k, v) => new
            {
                key = k,
                value = v
            })
        .ToDictionary(cp => cp.key, cp => cp.value);

Match Match=Regex.Match（文本、模式、，
RegexOptions.IgnorePatternWhitespace
|RegexOptions.ExplicitCapture）；
字典结果=
比赛
.组[“键”]
.捕获
第（）类
.Select（cp=>cp.Value）
Zip先生(
match.Groups[“Value”]。捕获
第（）类
.选择（cp=>cp.Value），
（k，v）=>新的
{
key=k，
值=v
})
.ToDictionary（cp=>cp.key，cp=>cp.value）；

然后你可以这样做：

    List<string> myInfo = result.Keys.ToList();

List myInfo=result.Keys.ToList（）；


鉴于您的最新问题，我认为您可能希望：

Dictionary<string, string> query =
    Regex
        .Matches(text, pattern,
            RegexOptions.IgnorePatternWhitespace
                | RegexOptions.ExplicitCapture) 
        .OfType<Match>()
        .SelectMany(mt => mt.Groups["Key"].Captures
            .OfType<Capture>()
            .Select(cp => cp.Value)
            .Zip(
                mt.Groups["Value"].Captures
                    .OfType<Capture>()
                    .Select(cp => cp.Value),
                (k, v) => new
                {
                    key = k,
                    value = v
                }))
        .ToDictionary(cp => cp.key, cp => cp.value);

Match match =
    Regex.Match(text, pattern,
        RegexOptions.IgnorePatternWhitespace
            | RegexOptions.ExplicitCapture);

var result = new
{
    Info = match.Groups["ADKey"].Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(match.Groups["ADValue"].Captures.OfType<Capture>().Select(cp => cp.Value),
            (k, v) => new { key = k, value = v })
        .ToDictionary(cp => cp.key, cp => cp.value),
    Nodes = match.Groups["Key"].Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(match.Groups["Value"].Captures.OfType<Capture>().Select(cp => cp.Value),
            (k, v) => new { key = k, value = v })
        .ToDictionary(cp => cp.key, cp => cp.value),
};

List<string> myInfo = result.Info.Keys.ToList();

匹配=
Regex.Match（文本、模式、，
RegexOptions.IgnorePatternWhitespace
|RegexOptions.ExplicitCapture）；
var结果=新
{
Info=match.Groups[“ADKey”]。捕获
第（）类
.Select（cp=>cp.Value）
.Zip（match.Groups[“ADValue”].Captures.OfType（）.Select（cp=>cp.Value），
（k，v）=>new{key=k，value=v}）
.ToDictionary（cp=>cp.key，cp=>cp.value），
节点=匹配。组[“键”]。捕获
第（）类
.Select（cp=>cp.Value）
.Zip（match.Groups[“Value”].Captures.OfType（）.Select（cp=>cp.Value），
（k，v）=>new{key=k，value=v}）
.ToDictionary（cp=>cp.key，cp=>cp.value），
};
List myInfo=result.Info.Keys.ToList（）；
您当前正在创建一个匿名类型列表，其中有一个属性，
Info
，即
字典
。您似乎没有在变量中捕获结果。然后尝试访问
Info
，就好像它是
RegEx
查询之外的单个对象一样。这两个
Info
引用了不同的东西

我给您的第一个建议是如下更改代码：

IEnumerable<Dictionary<string, string>> query =
    Regex
        .Matches(
            text,
            pattern,
            RegexOptions.IgnorePatternWhitespace
                | RegexOptions.ExplicitCapture) 
        .OfType<Match>()
        .Select(mt => mt.Groups["Key"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value)
                .Zip(
                    mt.Groups["Value"].Captures
                        .OfType<Capture>()
                        .Select(cp => cp.Value),
                    (k, v) => new
                    {
                        key = k,
                        value = v
                    })
                .ToDictionary(cp => cp.key, cp => cp.value));

Match match = Regex.Match(text, pattern,
    RegexOptions.IgnorePatternWhitespace
        | RegexOptions.ExplicitCapture);

Dictionary<string, string> result =
    match
        .Groups["Key"]
        .Captures
        .OfType<Capture>()
        .Select(cp => cp.Value)
        .Zip(
            match.Groups["Value"].Captures
                .OfType<Capture>()
                .Select(cp => cp.Value),
            (k, v) => new
            {
                key = k,
                value = v
            })
        .ToDictionary(cp => cp.key, cp => cp.value);

IEnumerable查询=
正则表达式
.火柴(
文本，
图案
RegexOptions.IgnorePatternWhitespace
|RegexOptions.ExplicitCapture）
第（）类
.选择（mt=>mt.Groups[“Key”]）。捕获
第（）类
.Select（cp=>cp.Value）
Zip先生(
mt.Groups[“值”]捕获
第（）类
.选择（cp=>cp.Value），
（k，v）=>新的
{
key=k，
值=v
})
.ToDictionary（cp=>cp.key，cp=>cp.value））；

现在，我不相信您想要一个
IEnumerable
，因为在接下来的两行中，您似乎