Eager load entity framework

Question

Итак, I was having a problem, и для его исправления я создал Entity для таблицы TeamColour. Это позволило мне создать мои методы создания/обновления следующим образом:

[HttpPost] 
[Route("")] 
/// <summary> 
/// Create a team 
/// </summary> 
/// <param name="model">The team model</param> 
/// <returns>Nothing</returns> 
public async Task<IHttpActionResult> Create(TeamBindingViewModel model) 
{ 

    // If our model is invalid, return the errors 
    if (!ModelState.IsValid) 
     return BadRequest(ModelState); 

    // Create our new model 
    var team = new Team() 
    { 
     Name = model.Name, 
     Sport = model.Sport 
    }; 

    // Create a new transaction incase anything fails, it will rollback the changes 
    using (var transaction = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) 
    { 
     // Otherwise, create a new team 
     this.service.Create(team); 

     // Save the database changes 
     await this.unitOfWork.SaveChangesAsync(); 

     // For each colour, insert into our lookup table 
     foreach (var colour in model.Colours) 
      this.teamColourService.Create(new TeamColour { ColourId = colour.Id, TeamId = team.Id }); 

     try 
     { 

      // Save the database changes 
      await this.unitOfWork.SaveChangesAsync(); 
     } 
     catch(Exception ex) 
     { 

     } 

     // If everything is done correctly, call the complete method 
     transaction.Complete(); 
    } 

    // Return Ok 
    return Ok(model); 
} 

[HttpPut] 
[Route("")] 
/// <summary> 
/// Update a team 
/// </summary> 
/// <param name="model">The team model</param> 
/// <returns>Nothing</returns> 
public async Task<IHttpActionResult> Update(TeamBindingViewModel model) 
{ 

    // If our model is invalid, return the errors 
    if (!ModelState.IsValid) 
     return BadRequest(ModelState); 

    // Get our current team 
    var team = await this.service.GetAsync(model.Id, "Colours"); 

    // Make changes to our team 
    team.Name = model.Name; 
    team.Sport = model.Sport; 

    // Update the team 
    this.service.Update(team); 

    // For each colour that has to be removed, remove from our team colours 
    foreach (var colour in team.Colours.ToList()) 
     if (!model.Colours.Any(c => c.Id == colour.Id)) 
      this.teamColourService.Remove(new TeamColour { ColourId = colour.Id, TeamId = model.Id }); 

    // For each colour that has to be added, add to our team colours 
    foreach (var colour in model.Colours) 
     if (!team.Colours.Any(c => c.Id == colour.Id)) 
      this.teamColourService.Create(new TeamColour { ColourId = colour.Id, TeamId = model.Id }); 

    // Save the database changes 
    await this.unitOfWork.SaveChangesAsync(); 

    // Return Ok 
    return Ok(model); 
} 

Что решает мою проблему в моем первоначальном вопросе. Проблема, с которой я столкнулся сейчас, заключается в том, что с момента создания сущностей для моей таблицы поиска, когда я использую активную загрузку, ничто не отбрасывается для цветов. Например, вот мой метод прибудет:

[HttpGet] 
[Route("")] 
/// <summary> 
/// Gets a team by the id 
/// </summary> 
/// <param name="id">The id of the team</param> 
/// <returns>A team</returns>  
public async Task<IHttpActionResult> Get(int id) 
{ 
    return Ok(await this.service.GetAsync(id, "Colours", "Players", "Kits")); 
} 

Как вы можете видеть, это пытается получить команду, а также отходил цвета, плеер и комплекты. Если мы посмотрим на классе команды, мы увидим, дети определены:

public class Team 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public string Sport { get; set; } 

    public IList<Colour> Colours { get; set; } 
    public IList<Kit> Kits { get; set; } 
    public IList<Player> Players { get; set; } 
} 

Прежде чем я создал таблицу Уточняющей как реальный объект, Цвета будут отстранились, но они вставляли новые записи в Colors и TeamColours, а не только таблицу TeamColours. Как я уже сказал, создание таблицы TeamColours в качестве объекта исправлено, но, похоже, сломал нетерпеливую загрузку. Мой контекст базы данных выглядит следующим образом:

public class DatabaseContext : DbContext 
{ 

    // Define our tables 
    public DbSet<User> Users { get; set; } 
    public DbSet<Role> Roles { get; set; } 

    public DbSet<Design> Designs { get; set; } 
    public DbSet<Colour> Colours { get; set; } 
    public DbSet<Kit> Kits { get; set; } 
    public DbSet<Team> Teams { get; set; } 
    public DbSet<Player> Players { get; set; } 

    public DbSet<TeamColour> TeamColours { get; set; } 

    /// <summary> 
    /// static constructor (only gets called once) 
    /// </summary> 
    static DatabaseContext() 
    { 

     // Create the database and insert our records 
     //Database.SetInitializer<DatabaseContext>(new DatabaseInitializer()); 
    } 

    /// <summary> 
    /// Default constructor 
    /// </summary> 
    public DatabaseContext() 
     : base("DefaultConnection") 
    { 

     // Disable Lazy Loading 
     base.Configuration.LazyLoadingEnabled = false; 

     // Write our SQL to the debug window 
     this.Database.Log = s => Debug.WriteLine(s); 
    } 

    /// <summary> 
    /// Overrides the inherited OnModelCreated method. 
    /// </summary> 
    /// <param name="modelBuilder">The DbModelBuilder</param> 
    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 

     // Remove Cascading Delete 
     modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>(); 

     // Map the UserRoles table 
     modelBuilder.Entity<User>() 
      .HasMany(m => m.Roles) 
      .WithMany() 
      .Map(m => 
      { 
       m.MapLeftKey("UserId"); 
       m.MapRightKey("RoleId"); 
       m.ToTable("UserRoles"); 
      }); 

     // Map the KitColours table 
     modelBuilder.Entity<Kit>() 
      .HasMany(m => m.Colours) 
      .WithMany() 
      .Map(m => 
      { 
       m.MapLeftKey("KitId"); 
       m.MapRightKey("ColourId"); 
       m.ToTable("KitColours"); 
      }); 

     //// Map the TeamColours table 
     //modelBuilder.Entity<Team>() 
     // .HasMany(m => m.Colours) 
     // .WithMany() 
     // .Map(m => 
     // { 
     //  m.MapLeftKey("TeamId"); 
     //  m.MapRightKey("ColourId"); 
     //  m.ToTable("TeamColours"); 
     // }); 

     // Create our relationships 
     modelBuilder.Entity<Kit>().HasRequired(m => m.Team).WithMany(m => m.Kits).Map(m => { m.MapKey("TeamId"); }); 
     modelBuilder.Entity<Kit>().HasRequired(m => m.Design).WithMany().Map(m => { m.MapKey("DesignId"); }); 
     modelBuilder.Entity<Player>().HasRequired(m => m.Team).WithMany(m => m.Players).Map(m => { m.MapKey("TeamId"); }); 

     // Add our keys to the lookup tables 
     modelBuilder.Entity<TeamColour>().HasKey(model => new { model.TeamId, model.ColourId }); 
    } 
} 

Итак, мои вопросы в том, как я могу получить мой жадная загрузка снова работать?

Answer 1

Так что да, я это исправил, изменив виртуальной собственности на это:

public class Team 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public string Sport { get; set; } 

    public IList<TeamColour> Colours { get; set; } 
    public IList<Kit> Kits { get; set; } 
    public IList<Player> Players { get; set; } 
} 

Я был заинтересован только в colourId во всяком случае, так это работает отлично.