C# 根据子属性选择受限制的项目子集

我只是想知道是否有更好的方法来编写这段代码，基本上源对象包含一个带有布尔属性的混合项，而目标对象有两个列表，分别包含真/假项

我用Linq写的，效果很好，但感觉好像有更好的方法。有什么建议吗

    void Main()
    {
        var s = new ResponseObject()
        {
            Results = new List<GroupedObject>()
                    {
                        new GroupedObject()
                        {
                            Name = "List A",
                            List=new List<DetailObject>()
                            {
                                new DetailObject{ Name = "Allowed", AllowedAccess = true},
                                new DetailObject{ Name = "Restricted", AllowedAccess = false}
                            }
                        },
                        new GroupedObject()
                        {
                            Name = "List B",
                            List=new List<DetailObject>()
                            {
                                new DetailObject{ Name = "Allowed", AllowedAccess = true},
                                new DetailObject{ Name = "Restricted", AllowedAccess = false}
                            }
                        }
                    }
        };

        var d = new ResponseViewModel();
        d.AllowedResults = FilterObjectsByAccess(s.Results, true);
        d.RestrictedResults = FilterObjectsByAccess(s.Results, false);

        // Other stuff
    }

    public IEnumerable<GroupedObject> FilterObjectsByAccess(IEnumerable<GroupedObject> source, bool allowAccess)
    {
        return source.Where(i => i.List.Any(c => c.AllowedAccess == allowAccess))
                     .Select(i => new GroupedObject()
                     {
                         Name = i.Name,
                         List = i.List.Where(c => c.AllowedAccess == allowAccess)
                     });
    }

    public class ResponseObject
    {
        public IEnumerable<GroupedObject> Results { get; set; }
    }
    public class ResponseViewModel
    {
        public IEnumerable<GroupedObject> AllowedResults { get; set; }
        public IEnumerable<GroupedObject> RestrictedResults { get; set; }
    }
    public class GroupedObject
    {
        public string Name { get; set; }
        public IEnumerable<DetailObject> List { get; set; }
    }

    public class DetailObject
    {
        public string Name { get; set; }
        public bool AllowedAccess { get; set; }
    }

void Main（）
{
var s=新的响应对象（）
{
结果=新列表（）
{
新的GroupeObject（）
{
Name=“列表A”，
列表=新列表（）
{
新的DetailObject{Name=“Allowed”，AllowedAccess=true}，
新的DetailObject{Name=“Restricted”，AllowedAccess=false}
}
},
新的GroupeObject（）
{
Name=“列表B”，
列表=新列表（）
{
新的DetailObject{Name=“Allowed”，AllowedAccess=true}，
新的DetailObject{Name=“Restricted”，AllowedAccess=false}
}
}
}
};
var d=新的ResponseViewModel（）；
d、 AllowedResults=FilterObjectsByAccess（s.Results，true）；
d、 Results=FilterObjectsByAccess（s.Results，false）；
//其他东西
}
公共IEnumerable FilterObjectsByAccess（IEnumerable源，布尔允许访问）
{
返回source.Where（i=>i.List.Any（c=>c.AllowedAccess==allowAccess））
.Select（i=>newgroupedobject（）
{
Name=i.Name，
List=i.List.Where（c=>c.AllowedAccess==allowAccess）
});
}
公共类响应对象
{
公共IEnumerable结果{get；set；}
}
公共类响应模型
{
public IEnumerable AllowedResults{get；set；}
公共IEnumerable Results{get；set；}
}
公共类GroupeObject
{
公共字符串名称{get；set；}
公共IEnumerable列表{get；set；}
}
公共类详细对象
{
公共字符串名称{get；set；}
公共bool允许访问{get；set；}
}

一个值得进行基准测试的变化是：

public IEnumerable<GroupedObject> FilterObjectsByAccess(IEnumerable<GroupedObject> source, bool allowAccess)
{
    return source.Where(i => i.List.Any(c => c.AllowedAccess == allowAccess))
                 .Select(i => new GroupedObject()
                 {
                     Name = i.Name,
                     List = i.List.Where(c => c.AllowedAccess == allowAccess)
                 });
}

---

我建议您像这样使用

ToDictionary（）

：

var result = new[] {true, false}.ToDictionary(k => k,
            v =>
                s.Results.Where(w => w.List.Any(x => x.AllowedAccess == v))
                    .Select(c => new GroupedObject {Name = c.Name, List = c.List.Where(l => l.AllowedAccess == v)}));

 var allowedResults = result[true];
 var restrictedResults = result[false];

或者这个：

var result = s.Results
                .SelectMany(c => c.List, (b, c) => new {b.Name, DObj = c})
                .GroupBy(g => g.DObj.AllowedAccess)
                .ToDictionary(k=> k.Key,
                    c =>
                        new {
                            c.Key,
                            List =
                                c.GroupBy(cg => cg.Name)
                                    .Select(
                                        x => new GroupedObject {Name = x.Key, List = x.Select(l => l.DObj).ToList()})
                                    .ToList()
                        });

---

这两个答案中的任何一个对你有用吗？我将尝试一下，看看我得到了什么欢呼。很高兴看到我没有错过一个非常明显的技巧

var result = new[] {true, false}.ToDictionary(k => k,
            v =>
                s.Results.Where(w => w.List.Any(x => x.AllowedAccess == v))
                    .Select(c => new GroupedObject {Name = c.Name, List = c.List.Where(l => l.AllowedAccess == v)}));

 var allowedResults = result[true];
 var restrictedResults = result[false];

var result = s.Results
                .SelectMany(c => c.List, (b, c) => new {b.Name, DObj = c})
                .GroupBy(g => g.DObj.AllowedAccess)
                .ToDictionary(k=> k.Key,
                    c =>
                        new {
                            c.Key,
                            List =
                                c.GroupBy(cg => cg.Name)
                                    .Select(
                                        x => new GroupedObject {Name = x.Key, List = x.Select(l => l.DObj).ToList()})
                                    .ToList()
                        });