[C#] Cercare elementi in una collezione in base a valori di una collezione figlia

[afrappe]

ho bisogno di filtrare elementi di una List<T> sulla base di valri presenti in una collezione figlia della mi lista

List<Aziende> AllTree = LoadAziende()

allTree = allTree.FindAll(x => x.Risorse.ToList().FindAll(r => r.Matricola == "xxx"));

la classe "Aziende" ha una collezione figlia di tipo Icollection<Risorse>

ho bisogno di tirare fuori solo quelle aziende "Aziende" che hanno una "risorsa" figlia che contenga un determinato valore - matricola="xxx"


ottengo questo errore : Cannot implicit convert System.collection.generic.list<Risorsa> to bool

[raffaeu]

Se vuoi ottenere tutte le aziende che contengano almeno una matricola con quel codice:

TuaLista.Where(x => x.Risorse.Any(r => r.Matricola == "XYZ"))

Se invece vuoi ottenere le aziende dove tutte le risorse al suo interno hanno la matricola con codice:

TuaLista.Where(x => x.Risorse.All(r => r.Matricola == "XYZ"))

[afrappe]

ok perfetto, cosi funziona alla grande, thanks

se invece volessi filtrare le collezione figlia con solo i children che soddisfano il criterio

r=>r.Risorse.matricola = "xxx"

cioe se la collezione completa è:

Azienda
    |
     -------->risorsa(matricola=5555)
    |
     -------->risorsa(matricola=6666)
    |
     -------->risorsa(matricola=xxxx)



io vorrei ottenere

Azienda
    |
     -------->risorsa(matricola=xxxx)

[raffaeu]

Beh in quel caso dovrai usare un Where nel padre ed un Contains nel figlio, qualcosa tipo questo:

TuaList.Where(x => x.Risorse.Where(r => r.Matricola == "ABC"))

Se ti piace giocare con Linq ti consiglio questo indirizzo: ASP.NET e LinQ

[afrappe]

cosi mi ritorna l'errore iniziale : Cannot implicit convert System.collection.generic.list<Risorsa> to bool

anche giustamente aggiungio io perche la where interna ritorna una IEnumerable<Risorsa> mente la condizione da passare alla where (esterna) deve soddisfare un criterio vero/falso[r.Matricola == "xxx"]

[raffaeu]

Allora puoi giocare con Any All Some ...

[rsdpzed]

quella postata prima cosi dovrebbe andare:

TuaList.Where(x => x.Risorse.Where(r => r.Matricola == "ABC").Count() > 0)

[afrappe]

Originariamente inviato da rsdpzed
quella postata prima cosi dovrebbe andare:

TuaList.Where(x => x.Risorse.Where(r => r.Matricola == "ABC").Count() > 0)

anche a me sembra la cosa piu sensata ma cosi non filtra la collezione figlia, prima di questa where la collezione "Risorse" ha 2 elementi (di cui una ha una matricola "ABC"),
dopo la chiamata La collezione "Risorse" ha sempre 2 elementi

mi viene da piangere c'e' qualche altra info che puo essere utile alla causa?

[raffaeu]

Allora credo il tuo problema sia diverso da quel che chiedi.
Con la sintassi Where, come in SQL, tu gli dici "Dammi parent e child dove child = ..." ma non ti filtra i children, per fare cio' devi fare qualcosa del genere:

var x = TuaLista.Where(g=>g.Risorse.Select(a=>a.Matricola == "ABC"));

[rsdpzed]

ho riletto meglio il post, effettivamente il problema è un po' piu complesso

per mio personale esercizio ho cercato di risolvere la questione utilizzando solo linq, spero nel modo piu giusto:

Il risultato finale è:
A1
--ABC
A3
--ABC
--ABC

esclude sia A2 che i singoli ordini in A1 che non siano ABC.

ti ho messo qualche commento alla query linq

            List<Azienda> aziende = new List<Azienda>
            {
                new Azienda
                { 
                    ID = "A1",
                    Ordini = new List<Ordine>
                    {
                        new Ordine { ID = "ABC" },
                        new Ordine { ID = "NO" }
                    }
                },
                new Azienda
                { 
                    ID = "A2",
                    Ordini = new List<Ordine>
                    {
                        new Ordine { ID = "NO" },
                        new Ordine { ID = "NO" }
                    }
                },
                new Azienda
                { 
                    ID = "A3",
                    Ordini = new List<Ordine>
                    {
                        new Ordine { ID = "ABC" },
                        new Ordine { ID = "ABC" }
                    }
                }
            };

            var query = aziende
                .SelectMany(a => a.Ordini.Where(o => o.ID == "ABC") //esclude le aziende che non hanno nemmeno un ordine ABC
                    .Select(o => new { az = a, or = o })) //seleziono in una nuova classe anonima per tenere traccia dell'azienda
                .GroupBy(g => g.az) //raggruppo per azienda
                .Select(s => new Azienda //ora riporto la collection di tipo IGrouping in una di tipo List<Azienda>
                { 
                    ID = s.Key.ID, 
                    Ordini = s.Key.Ordini
                    .Where(o => o.ID == "ABC") // Ora per ogni azienda escludo anche gli ordini
                    .ToList()
                })
                .ToList();

EDIT
queste sono le due classi:

public class Ordine
        {
            public string ID { get; set; }
        }
        public class Azienda
        {
            public string ID { get; set; }
            public List<Ordine> Ordini { get; set; }

            public Azienda()
            {
                Ordini = new List<Ordine>();
            }
        }