从列表中过滤<T>名单<T>

Question

My Concern is based on the same question I had asked earlier and got the resolution.

I initially thought I am getting the correct response, but to see I am not. My Data is like this:

and If I filtered like this

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

I am getting the result like this:

But I want the result only to have Accounts equalling to JKB2 not Accounts that have JKB2. Hence what I have highlighted down here should be in the result and not others:

Technically, the result should be like this ( I just wrote a pseudocode in the form of JSON):

    [
    {
    Slab: T3,
    Value: 500,
    Percentage: 0
    Accounts: {
    AccountId:JKB2,
    AccountName:JKB2,
    SalesCode:JKB,
    Value:500
    }
    },
{
    Slab: T5,
    Value: 500,
    Percentage: 0
    Accounts: {
    AccountId:JKB2,
    AccountName:JKB2,
    SalesCode:JKB,
    Value:500
    }
    }
    ]

My LinqPad working is here:

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();


}

Answer 1

The filter is correct in terms of it is returning the OverdueModel instances that have a record; the problem is that you want just the filtered part of the interior .Accounts . If we assume that we don't want to change all of the objects, you're going to need to create a projection to a new model that contains just those filtered accounts. Perhaps something like:

var results = from outer in overdues
                where outer.Accounts.Any(b => b.AccountId == "JKB2")
                let filtered = outer.Accounts.FindAll(b => b.AccountId == "JKB2")
                select (Record: outer, Accounts: filtered);

although a wide range of alternatives are possible. For example, a flatter model would be:

var results = from outer in overdues
                from account in outer.Accounts
                where account.AccountId == "JKB2"
                select (Record: outer, Account: account);

Answer 2

I believe what you're looking for is the SelectMany operator in LINQ, which flattens a sequence of collections.

So try the below

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