Posso eseguire una sottoquery in SELECT di LINQ su Entità da compilare Elenco nel modello?

entity-framework-core linq

Domanda

È possibile avere una sottoquery nella parte .Select di una query LINQ to Entities per riempire una List<string> all'interno del mio modello di visualizzazione? Ho trovato la sottoquery Usa Linq To Entities all'interno della clausola Select per recuperare un valore di campo, ma quando provo a farlo viene visualizzato l'errore:

NotImplementedException: Microsoft.Data.Entity.Query.ResultOperators.Internal.QueryAnnotationResultOperator

E 'possibile farlo con Entity Framework 7 e ASP.Net 5 MVC 6?

var model = _DbContext.ReleaseVersions
                        .OrderByDescending(rv => rv.DateReleased)
                        .Select(rv => new ReleaseNotesVM()
                        {
                            ID = rv.ID,
                            CurrentVersion = string.Concat(rv.Major, '.', rv.Minor, '.', rv.Patch),
                            ReleaseNotes = _DbContext.ReleaseNotes
                                                    .Where(rn => rn.ReleaseVersionID == rv.ID)
                                                    .Include(rn => rn.ReleaseVersion)
                                                    .Select(rn => rn.Note)
                                                    .ToList()
                        }).FirstOrDefault();

ViewModel riempito:

var model = _DbContext.ReleaseVersions
                        .OrderByDescending(rv => rv.DateReleased)
                        .Select(rv => new ReleaseNotesVM()
                        {
                            ID = rv.ID,
                            CurrentVersion = string.Concat(rv.Major, '.', rv.Minor, '.', rv.Patch),
                            ReleaseNotes = _DbContext.ReleaseNotes
                                                    .Where(rn => rn.ReleaseVersionID == rv.ID)
                                                    .Include(rn => rn.ReleaseVersion)
                                                    .Select(rn => rn.Note)
                                                    .ToList()
                        }).FirstOrDefault();

DataModel:

var model = _DbContext.ReleaseVersions
                        .OrderByDescending(rv => rv.DateReleased)
                        .Select(rv => new ReleaseNotesVM()
                        {
                            ID = rv.ID,
                            CurrentVersion = string.Concat(rv.Major, '.', rv.Minor, '.', rv.Patch),
                            ReleaseNotes = _DbContext.ReleaseNotes
                                                    .Where(rn => rn.ReleaseVersionID == rv.ID)
                                                    .Include(rn => rn.ReleaseVersion)
                                                    .Select(rn => rn.Note)
                                                    .ToList()
                        }).FirstOrDefault();

Risposta accettata

Se suppongo correttamente, devi avere una relazione uno-a-molti tra ReleaseVersions e ReleaseNotes , il che significa che ci dovrebbe essere una proprietà di navigazione nella classe ReleaseVersion fa riferimento alla raccolta di ReleaseNotes di ReleaseNotes , consentendoti di riscrivere il tuo codice in questo modo:

var model = _DbContext.ReleaseVersions
                    .Include(rv => rv.ReleaseNotes)
                    .OrderByDescending(rv => rv.DateReleased)
                    .Select(rv => new ReleaseNotesVM
                    {
                        ID = rv.ID,
                        CurrentVersion = string.Concat(rv.Major, '.', rv.Minor, '.', rv.Patch),
                        ReleaseNotes = rv.ReleaseNotes.Select(rn => rn.Note).ToList()
                    }).FirstOrDefault();

Aggiornare

Utilizzare List<string> ReleaseNotes anziché ICollection<string> in ReleaseNotesVM .




Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché