Ciao a tutti, scusate ma sono 2 giorni che non riesco a capire come lavora EF Core.
Supponiamo di avere 1 entità padre ed N entità figli (1 a molti) ed esplicitare le relazioni sul Dbcontext da entrambe le parti.
Supponiamo di realizzare i rispettivi DTO identici in modo da creare le mappe nel modo più veloce.
Ora se si esegue una semplice query utilizzando il metodo Include si ottiene un JSON infinito.
var query = context.Padre.Include(f => f.Figli).ToList();
Significa che il padre ha dei figli i quali hanno un padre e così via....
Sulla rete si trova la parziale soluzione di inserire la seguente riga nello startup.cs:

options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore

Onestamente mi sembra di nascondere il problema e non risolverlo.
Io sto cercando di capire se è possibile utilizzare l'Include includendo sempre e solo le proprietà del DTO
senza le eventuali relazioni in modo da conrollare sempre quali entità si vogliono estrarre.

Qualcuno è riuscito?

Ciao e grazie della risposta.
Le relazioni le ho configurate da entrambe le parti perché le uso entrambe. Sto sviluppando delle API Rest che a volte mi passano il padre e vogliono i figli, a volte vogliono la lista dei figli con il relativo padre.
Se io dovessi proiettare nel dto quello che serve, dovrei fare N dto per la stessa entità.
La soluzione che stavo cercando, ovviamente se possibile, era quella di considerare tutti gli include come include delle sole proprietà senza le rispettive relazioni. Questo metodo lo si usa già facendo le conversioni a mano con delle classi (classico modello: entità, dto, converter).
Usando l'automapper mi chiedevo se era possibile avere questa opzione, sarebbe molto interessante oltre che apprezzata. Ti gitro un link dove forse anche altri stanno avendo le stesse problematiche.
https://stackoverflow.com/questions/54422050/ef-core-reference-loop-when-using-include-and-theninclude
grazie comunque della tua collaborazione.

Ciao Moreno e grazie della risposta.
Si le relazioni nell'OnModelCreating sono state mappate da entrambe le parti (uno-a-molti e molti-a-uno), (HasOne e WithMany figlio, e HasMany WithOne nel padre) sbagliato?
La strada degli N dto non mi piace molto perché in questa webapi avrò moltissime tabelle,
e purtroppo se replico per ogni entità n dto ho paura che diventi ingestibile.
Sto valutando altre 2 strade. La prima è di abbandonare l'automapper e di gestire con una classe
la conversione tra i dto passando un parametro che mi determina il grado di conversione.
public EsempioDto DtoFromEntity(Tipologia entity, int conversionType) {
if(conversionType = 0)
// converto solo l'Id
if(conversionType = 1) {
// converto solo le proprietà
}
if(conversionType = 2) {
// converto le proprietà di navigazione
}
}
}

Altra strada è di usare l'automapper, ma di settare a runtime la mappa che mi serve escludendo alcune proprietà di navigazione (specialmente quelle Inverse).
var config = new MapperConfiguration(cfg => {
cfg.CreateMap<PadreEntity, PadreDto>();
cfg.CreateMap<Figlio, FiglioDto>()
.ForMember(m => m.Padre, o => o.Ignore());
});
IMapper iMapper = config.CreateMapper();
ris = iMapper.Map<IEnumerable<FiglioDto>>(RisultatoQuery);

Forse sono ancora all'inizio e ho bisogno di entrare nell'ordine di questi motori di persistenza,
ma non trovo logico che mi escano JSON dove i figli mi replicano il padre...
Mi basterebbe per ora escludere almeno le proprietà di navigazione "contrarie".

Grazie comunque a tutti per la collaborazione

---

Modificato da jjlotus il 30 settembre 2019 09:56 -

---

Modificato da jjlotus il 30 settembre 2019 09:57 -

---

Modificato da jjlotus il 30 settembre 2019 10:06 -

---

Modificato da jjlotus il 30 settembre 2019 10:07 -