如何仅使用数据库中的实体框架支架模型

Question

I have been working with .Net Core Entity Framework database first approach with the Scaffolding technique.

It generated me a couple Models/Classes from my Database Tables, but for now, I will just minimize the issue I am having to this two tables... a relation one to many on the both ChampionID column:

So, after scaffolding/mapping the models with EntityCore Tools it generated the following two classes (and several others that are not relevant):

Champion.cs:

public partial class Champion
{
    public Champion()
    {
        ChampionScreenshot = new HashSet<ChampionScreenshot>();
        ChampionUser = new HashSet<ChampionUser>();
        ChampionUserRate = new HashSet<ChampionUserRate>();
    }

    public int ChampionId { get; set; }
    public string Name { get; set; }
    public string Nickname { get; set; }
    public string Description { get; set; }
    public string ImagePath { get; set; }
    public byte AttackDamageScore { get; set; }
    public byte AbilityPowerScore { get; set; }
    public byte ResistanceScore { get; set; }
    public byte PlayingDifficult { get; set; }
    public int PrimaryClassId { get; set; }
    public int SecondaryClassId { get; set; }

    public ChampionClass PrimaryClass { get; set; }
    public ChampionClass SecondaryClass { get; set; }
    public ICollection<ChampionScreenshot> ChampionScreenshot { get; set; }
    public ICollection<ChampionUser> ChampionUser { get; set; }
    public ICollection<ChampionUserRate> ChampionUserRate { get; set; }
}

ChampionScreenshot.cs:

public partial class ChampionScreenshot
{
    public int ChampionScreenshotId { get; set; }
    public string ImagePath { get; set; }
    public int ChampionId { get; set; }

    public Champion Champion { get; set; }
}

My doubt is: what is the correct way to retrieve a Champion object with the ChampionScreenshot attribute filled?

For example, this is what I am doing in my Service layer:

    public async Task<Champion> GetChampion(int id)
    {
        Champion champion = await _context.Champion.FirstAsync(m => m.ChampionId == id);
        champion.ChampionScreenshot = _context.ChampionScreenshot.ToListAsync().Result.FindAll(m => m.ChampionId == champion.ChampionId);

        return champion;
    } 

So I am basically getting a specific Champion and then filling the ChampionScreenshot attribute (which is also a Class) separately, but the thing is that inside my ChampionScreenshot there is also a Champion class attribute which fully loads once again:

Which is obviously generating an error once it is exposed in the endpoint of the Restful Service:

[Produces("application/json")]
[Route("api/Champions")]
public class ChampionsController : Controller
{
    [HttpGet("{id}")]
    public async Task<IActionResult> GetChampion([FromRoute] int id)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        var champion = await _service.GetChampion(id);

        if (champion == null)
        {
            return NotFound();
        }
        return Ok(champion);
    }
    ...

Error:

Newtonsoft.Json.JsonSerializationException: Self referencing loop detected for property 'champion' with type 'ChampionsService.Models.Champion'. Path 'championScreenshot[0]'. 

So, I was thinking in just creating my custom model and fill it with the data extracted from my DbContext instead of returning the models already created but I really think that there should be a way to fully use only the mapped Models, I was wondering that...

Answer 1

Champion references itself:

Champion > multiple ChampionScreenshot > Champion (back to the original object)

That's easy to solve:

return Json(champion, new JsonSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore });

Or you could do it for the entire application:

services.AddMvc().AddJsonOptions(opts => 
{
    opts.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
});

And then just:

return Json(champion);

---

The following troubles me, though:

Champion champion = await _context.Champion.FirstAsync(m => m.ChampionId == id);
champion.ChampionScreenshot = _context.ChampionScreenshot.ToListAsync().Result.FindAll(m => m.ChampionId == champion.ChampionId);

You are saying "go to the database, download every single championscreenshot and find the ones I want through an in-memory search". That's not only horrible slow, it also wastes a lot of resources in your application and in the database. For including data, you use Include :

Champion champion = await _context.Champion
    .Include(x => x.ChampionScreenshot)
    .FirstAsync(x => x.ChampionId == id);

(this says "go to the database and bring me the champion but also include all the ChampionScreenshot that correspond, through an inner join).