Lazy Load is not working even I force .include

Question

I am trying to get a main table with 3 arrays of value, and it is not working at all. I have no idea how can I fix that, I am using the default get on controller:

public IEnumerable<SelfAssessment> GetSelfAssessment()
    {
        return _context.SelfAssessment;
    }

what I am trying to get on request:

    {
        "userEmail": "user@email.com",
        "createdAt": "2018-12-10T08:02:16.117",
        "update": false,
        "discomfort": [
        {
          "bodyPartId": 1,
          "intensityId": 1,
          "frequencyId": 1
        }
      ],
      "saanswers": [
        {
          "answerId": 1
        }
      ], 
      "sapostures": [
        {
          "postureAnswerId": 1,
          "postureId": 1,
        }
      ]
    }

And I am receiving this Json but with empty arrays as below:

   {
      "userEmail": "user@mail.com",
      "createdAt": "2018-12-10T08:02:16.117",
      "update": false,
      "discomfort": [],
      "saanswers": [],
      "sapostures": []
   }

This is my controller below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using ErgoSAFE_API.Models;

namespace ErgoSAFE_API.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class SelfAssessmentsController : ControllerBase
{
    private readonly ErgoSAFEContext _context;

    public SelfAssessmentsController(ErgoSAFEContext context)
    {
        _context = context;
    }

    // GET: api/SelfAssessments
    [HttpGet]
    public IEnumerable<SelfAssessment> GetSelfAssessment()
    {
        return _context.SelfAssessment;
    }

    // GET: api/SelfAssessments/5
    [HttpGet("{id}")]
    public async Task<IActionResult> GetSelfAssessment([FromRoute] int id)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        var selfAssessment = await _context.SelfAssessment.FindAsync(id);

        if (selfAssessment == null)
        {
            return NotFound();
        }

        return Ok(selfAssessment);
    }

    // PUT: api/SelfAssessments/5
    [HttpPut("{id}")]
    public async Task<IActionResult> PutSelfAssessment([FromRoute] int id, [FromBody] SelfAssessment selfAssessment)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        if (id != selfAssessment.SelfAssessmentId)
        {
            return BadRequest();
        }

        _context.Entry(selfAssessment).State = EntityState.Modified;

        try
        {
            await _context.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!SelfAssessmentExists(id))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return NoContent();
    }

    // POST: api/SelfAssessments
    [HttpPost]
    public async Task<IActionResult> PostSelfAssessment([FromBody] SelfAssessment selfAssessment)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        _context.SelfAssessment.Add(selfAssessment);
        await _context.SaveChangesAsync();

        return CreatedAtAction("GetSelfAssessment", new { id = selfAssessment.SelfAssessmentId }, selfAssessment);
    }

    // DELETE: api/SelfAssessments/5
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteSelfAssessment([FromRoute] int id)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        var selfAssessment = await _context.SelfAssessment.FindAsync(id);
        if (selfAssessment == null)
        {
            return NotFound();
        }

        _context.SelfAssessment.Remove(selfAssessment);
        await _context.SaveChangesAsync();

        return Ok(selfAssessment);
    }

    private bool SelfAssessmentExists(int id)
    {
        return _context.SelfAssessment.Any(e => e.SelfAssessmentId == id);
    }
}
}

.net core 2.1.403

Using VSCode, not Visual Studio

Edit 1:

        public IEnumerable<Object> Find (int id) {
        IQueryable<object> entryPoint = (from sa in _context.SelfAssessments
                          join a in _context.Answers on sa.SelfAssessmentId equals a.SelfAssessmentId
                          join q in _context.Questions on a.QuestionId equals q.QuestionId
                          where sa.SelfAssessmentId == id
                          select new {
                              SelfAssessmentID = sa.SelfAssessmentId,
                              Yearly = sa.Yearly,
                              Moved = sa.Moved,
                              CreatedAt = sa.CreatedAt,
                              Question = q.Description,
                              Value = a.Value
                          }).Take(10);
        List<object> result = entryPoint.ToList();

        return result;
    }

Edit 2:

I did some changes on my controller, when I debug the code, I can see that the value is coming, but there is no error when I try to return the result.

Controller:

[HttpGet]
    public IEnumerable<SelfAssessment> GetSelfAssessment()
    {
        var qry = from s in _context.SelfAssessment
                  select s;

        var results = qry.Include("Discomfort").ToList();
        results = qry.Include("Sapostures").ToList();
        results = qry.Include("Saanswers").ToList();

        return results;
    }

Swagger results:

Code
Undocumented

Details Error: OK

Responses

Code
200

Description Success

Answer 1

So if the problem is not complete data the solution should be easy. I think you have to eager load also nested properties.

If your model is:

    public class MainEntity
    {
        public int Id { get; set; }
        ICollection<MiddleEntity> MiddleEntities { get; set; }
        //Other properties...
    }

    public class MiddleEntity
    {
        public int Id { get; set; }

        public int MainEntityId { get; set; }
        public MainEntity MainEntity { get; set; }

        ICollection<InnerEntity> InnerEntities { get; set; }
        //Other properties...
    }

    public class InnerEntity
    {
        public int Id { get; set; }

        public int MiddleEntityId { get; set; }
        public MiddleEntity MiddleEntity { get; set; }
        //Other properties...
    }

The solution should be:

    [HttpGet("{Id}")]
    public ActionResult<IEnumerable<MainEntity>> GetMainEntities(int Id)
    {
        var result = _context.MainEtities
            .Include(x => x.MiddleEntities)
                .ThenInclude(y => y.InnerEntities)
            .ToList();

        return Ok(result);
    }