C# 从列表中筛选<；T>；列表的名称<；T>；

我的担心是基于我先前提出的问题，并得到了解决方案

起初我以为我得到了正确的回答，但现在看来我没有。我的数据如下：

如果我像这样过滤

var result=overdues.Where（a=>a.Accounts.Any（b=>b.AccountId.Equals（“JKB2”））

我得到的结果如下：


但我希望结果只包含等于JKB2的帐户，而不是包含JKB2的帐户。因此，我在这里强调的应该是结果，而不是其他结果：


从技术上讲，结果应该是这样的（我刚刚以JSON的形式编写了一个伪代码）：

我的LinqPad工作在这里：

public class OverdueModel
    {
        public string Slab { get; set; }
        public double Value { get; set; }
        public double Percentage { get; set; }
        public List<OverdueSlabAccounts> Accounts { get; set; }
    }

    public class OverdueSlabAccounts
    {
        public string AccountId { get; set; }
        public string AccountName { get; set; }
        public string SalesCode { get; set; }
        public string Value { get; set; }
    }


void Main(){
    List<OverdueModel> overdues = new List<OverdueModel>();
    List<OverdueSlabAccounts> accounts1 = new List<OverdueSlabAccounts>();
    List<OverdueSlabAccounts> accounts2 = new List<OverdueSlabAccounts>();
    List<OverdueSlabAccounts> accounts3 = new List<OverdueSlabAccounts>();

    //For T3
    accounts1.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB1",
            AccountName = "JKB1",
            SalesCode = "JKB",
            Value = "500"
        });

    accounts1.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB2",
            AccountName = "JKB2",
            SalesCode = "JKB",
            Value = "500"
        });

    overdues.Add(new OverdueModel()
    {
        Slab = "T3",
        Value = 1000,
        Percentage = 0,
        Accounts= accounts1
    });

    //For T4
    accounts2.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB1",
            AccountName = "JKB1",
            SalesCode = "JKB",
            Value = "1000"
        });

    overdues.Add(new OverdueModel()
    {
        Slab = "T4",
        Value = 1000,
        Percentage = 0,
        Accounts= accounts2
    });

    //For T5
    accounts3.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB1",
            AccountName = "JKB1",
            SalesCode = "JKB",
            Value = "1000"
        });

    accounts3.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB2",
            AccountName = "JKB2",
            SalesCode = "JKB",
            Value = "500"
        });

    accounts3.Add(new OverdueSlabAccounts()
        {
            AccountId = "JKB3",
            AccountName = "JKB3",
            SalesCode = "JKB",
            Value = "500"
        });

    overdues.Add(new OverdueModel()
    {
        Slab = "T5",
        Value = 2000,
        Percentage = 0,
        Accounts= accounts3
    });

    //Show the Current Data
    overdues.Dump();

    var result = overdues.Where(a=>a.Accounts.Any(b=>b.AccountId.Equals("JKB2")));

    result.Dump();


}

公共类模型
{
公共字符串Slab{get；set；}
公共双值{get；set；}
公共双百分比{get；set；}
公共列表帐户{get；set；}
}
公共类过多计数
{
公共字符串AccountId{get；set；}
公共字符串AccountName{get；set；}
公共字符串SalesCode{get；set；}
公共字符串值{get；set；}
}
void Main（）{
列表过量=新列表（）；
列表帐户1=新列表（）；
List accounts2=新列表（）；
List accounts3=新列表（）；
//T3
accounts1.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB1”，
AccountName=“JKB1”，
SalesCode=“JKB”，
Value=“500”
});
accounts1.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB2”，
AccountName=“JKB2”，
SalesCode=“JKB”，
Value=“500”
});
添加（新的OverdueModel（）
{
Slab=“T3”，
值=1000，
百分比=0，
账户=账户1
});
//对于T4
accounts2.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB1”，
AccountName=“JKB1”，
SalesCode=“JKB”，
Value=“1000”
});
添加（新的OverdueModel（）
{
Slab=“T4”，
值=1000，
百分比=0，
账户=账户2
});
//对于T5
accounts3.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB1”，
AccountName=“JKB1”，
SalesCode=“JKB”，
Value=“1000”
});
accounts3.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB2”，
AccountName=“JKB2”，
SalesCode=“JKB”，
Value=“500”
});
accounts3.Add（新的OverdueSlabAccounts（）
{
AccountId=“JKB3”，
AccountName=“JKB3”，
SalesCode=“JKB”，
Value=“500”
});
添加（新的OverdueModel（）
{
Slab=“T5”，
数值=2000，
百分比=0，
账户=账户3
});
//显示当前数据
Dump（）；
var result=overdues.Where（a=>a.Accounts.Any（b=>b.AccountId.Equals（“JKB2”））；
result.Dump（）；
}
我相信您正在寻找的是LINQ中的SelectMany操作符，它将集合序列展平

因此，请尝试下面的方法

var result = overdues.SelectMany(a=>a.Accounts).Where(a=>a.AccountId.Equals("JKB2"))

我相信您正在寻找的是LINQ中的SelectMany操作符，它将一系列集合展平

因此，请尝试下面的方法

var result = overdues.SelectMany(a=>a.Accounts).Where(a=>a.AccountId.Equals("JKB2"))

就返回具有记录的
OverdueModel
实例而言，过滤器是正确的；问题是您只需要内部
.Accounts
的过滤部分。如果我们假设不想更改所有对象，则需要创建一个到新模型的投影，该模型只包含那些过滤的帐户。也许是这样的：

var结果=从外部输入过量
其中outer.Accounts.Any（b=>b.AccountId==“JKB2”）
let filtered=outer.Accounts.FindAll（b=>b.AccountId==“JKB2”）
选择（记录：外部，科目：过滤）；

尽管有多种选择是可能的。例如，更平坦的模型是：

var结果=从外部输入过量
来自外部帐户。帐户
其中account.AccountId==“JKB2”
选择（记录：外部，科目：科目）；
过滤器在返回有记录的
OverdueModel
实例方面是正确的；问题是您只需要内部
.Accounts
的过滤部分。如果我们假设不想更改所有对象，则需要创建一个到新模型的投影，该模型只包含那些过滤的帐户。也许是这样的：

var结果=从外部输入过量
其中outer.Accounts.Any（b=>b.AccountId==“JKB2”）
let filtered=outer.Accounts.FindAll（b=>b.AccountId==“JKB2”）
选择（记录：外部，科目：过滤）；

尽管有多种选择是可能的。例如，更平坦的模型是：

var结果=从外部输入过量
来自外部帐户。帐户
其中account.AccountId==“JKB2”
选择（记录：外部，科目：科目）；
我认为OP仍然想要外部对象。嗨@Chris，谢谢你的回答。然而，你的回答只给出了答案；但是我需要与
JKB2
相关的过期平板，我想OP仍然想要外部对象。嗨@Chris，谢谢你的回答。然而，你的回答只给出了答案；但是我需要与
JKB2
相关的过期平板，因此您是否要忽略任何
超额
，如果他们有
JKB2
以外的帐户？或者您只是不想在结果中看到其他帐户（即筛选帐户列表和过量列表）？或者，看看克里斯的回答，你想看看空调吗