Entity Framework Core doesn't load Relational Object

Question

I'm new to the .NET Core framework. When I trying with Entity Framework Core, I couldn't get the relational object of entity.

This is my sample code:

public class TodoItemT
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public long Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
    
    public virtual List<SubItemT> SubItems { get; set; }
}

public class SubItemT
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public long Id { get; set; }
    [ForeignKey("TodoItemT")]
    public long TodoId { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
    
    public virtual TodoItemT TodoItemT { get; set; }
}

public class TodoContext : Microsoft.EntityFrameworkCore.DbContext
{
    public TodoContext(DbContextOptions<TodoContext> options) : base(options)
    {
    }

    public DbSet<TodoItemT> TodoItemTs { get; set; }
    public DbSet<SubItemT> SubItemTs { get; set; }
}

And I have this in Startup.cs:

services.AddDbContext<TodoContext>(opt => opt.UseInMemoryDatabase("TodoList"));

After I insert data to the database.

I try to get data from database with controller

// GET: api/Todo
[HttpGet]
public async Task<ActionResult<IEnumerable<TodoItemT>>> GetTodoItemTs()
{
    return await _context.TodoItemTs.ToListAsync();
}

But what I got is

[
  {
    "id": 1,
    "name": "string",
    "isComplete": true,
    "subItems": null
  }
]

I expected to get this instead:

[
  {
    "id": 1,
    "name": "task 1",
    "isComplete": true,
    "subItems": [
    {
        "id": 1,
        "name": "sub 1",
        "isComplete": true,
    }
    ]
  }
]

Did I do something wrong or having wrong configuration?

Thank you for the help.

None of the answer given so far hold water. It's not about lazy loading or Include. You can only get what you want by projecting to DTOs, otherwise subItems will always contain the back reference TodoItemT, which is not in the JSON you want. Using the entity classes themselves would cause reference loops in the JSON serializer. Also, Include doesn't work with in-memory database, which you shouldn't use for testing anyway. EF themselves advise against it. — Gert Arnold
– Gert Arnold, Commented Sep 10, 2021 at 7:12
Use builder.Services.AddControllers().AddJsonOptions(x => x.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles); And then Include. This will take care of the reference loops and you will get what you are looking for. — Mayur Ekbote
– Mayur Ekbote, Commented Sep 10, 2021 at 20:33

AndrewSilver · Accepted Answer · 2021-09-10 20:10:01Z

4

Lazy loading is one of breaking changes you need to keep in mind when moving from EF6 to EF.Core.
In EF6 it worked automatically by default with the value LazyLoadingEnabled set to true by default.
See this post Lazy and Eager Loading in Entity Framework for example.

But in EF.Core there is no such option anymore and you always need to add .Include explicitly, as it was already mentioned. Sure, this is a better and more reliable approach.

edited Sep 10, 2021 at 20:10

answered Sep 10, 2021 at 5:51

AndrewSilver

1,1983 gold badges16 silver badges25 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Felix · Accepted Answer · 2021-09-10 00:26:23Z

1

Entity Framework doesn't load related lists (otherwise, how does it know where to stop). You need to specify explicitly:

return await _context.TodoItemTs.Include("SubItems").ToListAsync();

There are various ways to accomplish that. Please refer to Loading Related Entities documentation

answered Sep 10, 2021 at 0:26

Felix

10.2k10 gold badges64 silver badges105 bronze badges

3 Comments

moussesj94 Over a year ago

Is it different when I use database first to create the entity models? Cause when I use that I don't have to add .Include("SubItems")

Felix Over a year ago

no, if you just have _context.TodoItemTs, then it is no different. But there are so many permutations - in many cases you would have shape it with some explicit fields from SubItems. In this case is is retrieved without Include()

Steve Py Over a year ago

@jamesaq12wsx If your Db-First example was originally done in EF6 as opposed to EF Core, EF6 would happily lazy-load related entities automatically. Even in that case you are better off disabling lazy loading and explicitly eager loading if you intend to serialize entities. Lazy loading to load dependencies of a single entity will generally be a little slower than eager loading... Lazy loading dependencies of a set of initial entities will be a LOT slower than eager loading. In both cases, projection is a better recommendation to learn about to optimize performance and avoid surprises.

Svyatoslav Danyliv · Accepted Answer · 2021-09-10 05:47:01Z

1

If EF would automatically load related items, you would literally load the whole database because it would not know where to stop.

Hence, you must manually decide which related items to load. Using the ".include" function to declare which items to include.

In this case, i.e.

_context.TodoItemTs.Include(x => x.SubItems).ToList();

You find this in the documentation properly explained at https://learn.microsoft.com/en-us/ef/core/querying/related-data/

edited Sep 10, 2021 at 5:47

Svyatoslav Danyliv

28.2k4 gold badges24 silver badges46 bronze badges

answered Sep 10, 2021 at 0:25

TomTom

62.4k11 gold badges95 silver badges152 bronze badges

4 Comments

AndrewSilver Over a year ago

this is not completely true, because old EF6 worked automatically with lazy loading without .Include. And there were no such issues as infinite loading usually

Gert Arnold Over a year ago

Surely there were issues with "infinite loading", i.e. reference loops, and the same will happen if OP enables lazy loading here or uses Include.

TomTom Over a year ago

Ah, it is not reference loops - if you automatically follow every reference, you load the whole database EVEN WITHOUT LOOPS as every item will somehow normally reference every other item.

Gert Arnold Over a year ago

No, it's a loop and a JSON serializer will choke in it unless it's configured to handle reference loops.

Jaroslav Daníček · Accepted Answer · 2021-09-10 00:33:40Z

0

Try to add foreign key attribute also on your navigation property matching your foreign key property name. Anyway I would go for fluent definition of relationships between the tables, this way I think you are missing a relationship.

answered Sep 10, 2021 at 0:33

Jaroslav Daníček

3774 silver badges22 bronze badges

Comments

boggy · Accepted Answer · 2025-09-17 08:03:35Z

0

Use lazy loading with proxies. See this: https://learn.microsoft.com/en-us/ef/core/querying/related-data/lazy .

You need to add the Microsoft.EntityFrameworkCore.Proxies package to your project and then you need to call:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder
        .UseLazyLoadingProxies()
        .UseSqlServer(myConnectionString);

Once you do that, the related objects will be retrieved as expected via proxies under the hood.

answered Sep 17 at 8:03

boggy

4,0674 gold badges40 silver badges63 bronze badges

Collectives™ on Stack Overflow

Entity Framework Core doesn't load Relational Object

5 Answers 5

Comments

3 Comments

4 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

3 Comments

4 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related