[MVC 5 / EF6] Navigational property is ineens NULL bij Edit

[NickThissen]

Ik zit te worstelen met MVC 5 in combinatie met Entity Framework 6.

Ik heb een database met Leagues en LeagueMembers (gebruikers die lid zijn van een League). Dit zijn de models:

C#:

    public class League : BaseModel
    {
        [Required]
        public string LeagueName { get; set; }

        public virtual ICollection<LeagueMember> Members { get; set; }
    }

    public class LeagueMember : BaseModel
    {
        [Required]
        public virtual ApplicationUser User { get; set; }
        [Required]
        public string UserId { get; set; }

        [Required]
        public virtual League League { get; set; }
        [Required]
        public int LeagueId { get; set; }

        [Required]
        public bool IsOwner { get; set; }

        [Required]
        public int AdminLevel { get; set; }
    }

Er kunnen meerdere gebruikers zijn die allemaal hun eigen Leagues aanmaken (en daar Owner van zijn).

Bij het wijzigen van een League (met een Edit action) moet er gevalideerd worden dat de huidige gebruiker genoeg rechten heeft om die League te wijzigen. Dit gebeurt twee keer: (1) eerst in de GET request naar de Edit pagina, en daarna nog eens in de POST request van de Edit pagina.


Het probleem is dat de check in (1) goed gaat, en in (2) niet, omdat de 'Members' navigational property dan ineens null is geworden. In de GET request is de Members property niet null en bevat hij de juiste members, maar zodra ik op de Edit knop klik op de edit pagina (en dus naar de POST request spring) is hij null en gaat de validatie dus elke keer mis (er zijn geen members dus de huidige gebruiker kan nooit genoeg rechten hebben).


Dit zijn de twee Edit methods in de controller. Ik heb in beide een Debug.Assert toegevoegd die controlleert of de Members property null is. In de eerste method (GET) is dat niet zo (klopt dus), in de tweede is hij wel null...

C#:

        // GET: /League/Edit/5
        [Authorize]
        public ActionResult Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            League league = Database.Leagues.Find(id);
            if (league == null)
            {
                return HttpNotFound();
            }

            // TEST: ------------------------------
            Debug.Assert(league.Members != null);                
            // Resultaat: league.Members is hier NIET null - ok!
            // ------------------------------------

            // Authenticate - check if user is league admin
            var user = UserManager.FindById(User.Identity.GetUserId());
            if (!user.IsLeagueAdmin(league, AdminLevels.EditLeague))
            {
                return new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
            }

            return View(league);
        }

        // POST: /League/Edit/5
        [HttpPost]
        [ValidateAntiForgeryToken]
        [Authorize]
        public ActionResult Edit([Bind(Include="Id,LeagueName,Description,Website,AccessType,Password,CreatedTime,UpdatedTime")] League league)
        {
            if (ModelState.IsValid)
            {
                // TEST: ------------------------------
                Debug.Assert(league.Members != null);
                // Resultaat: league.Members is hier NULL! - Fout!
                // ------------------------------------

                // Authenticate - check if user is league admin
                var user = UserManager.FindById(User.Identity.GetUserId());
                if (!user.IsLeagueAdmin(league, AdminLevels.EditLeague))
                {
                    return new HttpStatusCodeResult(HttpStatusCode.Unauthorized);
                }

                Database.Entry(league).State = EntityState.Modified;
                Database.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(league);
        }

Ik snap niet waar dit door komt. Heeft het met lazy loading te maken? En zo ja, waarom gaat het dan wel goed in de GET maar niet in de POST?

[Verwijderd]

In de GET-method doe je eerst een Find op de database waardoor die relatie van Members wordt geladen en daarna test je of deze niet null is. Maar in de POST-method doe je het andersom. Dan is het wel logisch dat ie null is. Tenzij je hem in je form opneemt en meegeeft in de model-binding, maar dat is nu het geval. Dus als je die findbyid() en assert() omdraait in je POST-action zou hij wel gevuld moeten zijn met members...

[NickThissen]

In de POST method krijg ik de League al als argument mee gestuurd, ik haal hem dus niet zelf uit de database.

De FindById doe ik op de UserManager om de huidige user te vinden, dat heeft niks met de League te maken.

Moet ik handmatig de members op gaan halen mbv het League ID? Dit zou toch wel automatisch door EF moeten kunnen?

[Phyxion]

Ik neem aan dat Members niet meegestuurd wordt met de post? Dan is het logisch namelijk. Bestaat het id al wel van de league bij de post method? Zo ja, gebruik de attach method op de entity, dan zal je members wel gevuld zijn. Alhoewel ik niet helemaal begrijp wat je uberhaupt aan het doen bent in de post method. Je roept SaveChanges aan maar doet vervolgens helemaal niks met de entity?

[NickThissen]

De entity is al veranderd "league" heeft namelijk de waarden die ik in het edit form invul. Nu ik er over nadenk is het ook logisch inderdaad dat Members null is omdat die niet in de post meekomt, maar hoe kan ik er dan voor zorgen dat EF die toch even (liefst automatisch) laadt? Want het ID is inderdaad al bekend.

Dit werkt niet:

C#:

Database.Leagues.Attach(league);

Dit werkt wel, maar is wel erg 'handmatig':

C#:

league.Members = Database.LeagueMembers.Where(m => m.LeagueId == league.Id).ToList();

[Verwijderd]

NickThissen schreef op zondag 06 april 2014 @ 17:13:
Dit werkt wel, maar is wel erg 'handmatig':

C#:

league.Members = Database.LeagueMembers.Where(m => m.LeagueId == league.Id).ToList();

Voer die query uit in de constructor van je model League. Komt hij altijd mee met het model.

C#:

public League(){
this.Members = Database.LeagueMembers.Where(m => m.LeagueId == league.Id).ToList();
}

[NickThissen]

Maar 9 van de 10 keer is het niet nodig en wordt hij automatisch al geladen, dan ga ik dus dubbelop laden?

Daarnaast heb ik in de constructor geen toegang tot het Database object natuurlijk.

[ Voor 29% gewijzigd door NickThissen op 06-04-2014 17:20 ]

[Haan]

Wat is het probleem dat league.Members null is in de Edit post method? Want je doet er toch niets mee? Zoals gezegd is het logisch dat deze property leeg is, er wordt namelijk een League object gecreëerd met de waardes de in de POST worden meegegeven en daar zitten geen members in. Als je die toch nodig hebt, zal je het object weer even op moeten vragen.

[NickThissen]

Ik heb ze nodig om te kunnen kijken of de gebruiker wel lid is van de league en genoeg admin rechten heeft.
In de IsLeagueAdmin method.

Het werkt op deze manier inderdaad, maar het lijkt aardig 'handmatig' terwijl ik had verwacht dat EF dit wel voor me zou kunnen afhandelen (met die Attach bijv, maar dat lijkt niks te doen)?

[ Voor 51% gewijzigd door NickThissen op 06-04-2014 21:53 ]

[Haan]

Zelfs als Attach had gewerkt, had je toch zelf een method aangeroepen, dus ik zie niet hoe dat minder 'handmatig' is dan de Find method gebruiken

[GotG]

je gaat sowieso iets handmatigs moeten doen

wat je ook kan doen is deze lijn wat vroeger zetten

C#:

Database.Entry(league).State = EntityState.Modified; 

en dan manueel de "related entities inladen door middel van:

C#:

Database.Entry(league).Collection(l => l.Members).Load();

dit zou er voor moeten zorgen dat de members ingeladen worden
waarna je dan je checks zou kunnen doen.

[Sebazzz]

Of je doet iets in deze trant (pseudocode):
• Get from database
• TryUpdateModel(entity)

Klaar