Entity Framework Code First Lazy Loading

This is wrong

"virtual" keyword is used for not loading the entities unless you
explicit this (using an "Include" statement)

Lazy Loading means that entities will be automatically loaded when you first access collection or navigation property, and that will happen transparently, as though they were always loaded with parent object.

Using "include" is loading on demand, when you specify properties you want to query.

Existence of virtual keyword is related only to lazy loading. virtual keyword allows entity framework runtime create dynamic proxies for your entity classes and their properties, and by that support lazy loading. Without virtual, lazy loading will not be supported, and you get null on collection properties.

Fact is that you can use "include" in any case, but without lazy loading it is the only way to access collection and navigation properties.

EF Code First Lazy loading Not Working

I realized that the problem was that the Merchant class did not meet requirements for proxy generation. Specifically, I needed to add a protected parameterless constructor. I only had a private one.

C# - Entity Framework Code first, lazy loading not working

In your Estudos entity, can you add ForeignKey attribute to Programas and Projetos properties.

[ForeignKey("idProgramas")]
public virtual Programas Programas { get; set; }

[ForeignKey("idProjetos")]
public virtual Projetos Projetos { get; set; }

And when querying Estudos include Programas and Projetos.

db.Estudos
  .Include(x => x.Programas)
  .Include(x => x.Projetos)
  .ToList();

In Entity Framework, why isn't lazy loading working for a one-to-zero-or-one navigation property?

I figured this one out. The entity classes must be declared as public and the properties public virtual for lazy loading to work. I.e.

public class Person
{
  public int PersonId { get; set; }
  public virtual Address Address { get; set; }
}

public class Address
{
  public int PersonId { get; set; }
  public virtual Person Person { get; set; }
}

Entity Framework Code First not lazy loading after save

Your problem is that when you use new Person() it will just create a POCO object which doesn't know how to get the it's Gender property. So to make the lazy loading work you need proxies.

You can create your person as a proxy with DbSet.Create():

var person = context.People.Create();
person.Name = "Bob";
person.GenderId = 1;

context.People.Add(person);
context.SaveChanges();

Entity Framework Core is lazy loading when transforming

As you noticed, currently there are two problems with EF Core projection queries containing collection projections - (1) they cause execution of N queries per collection and (2) they are executed lazily.

Problem (2) is weird, because ironically EF Core does not support lazy loading related entity data, while this behavior effectively implements it for projections. At least you can force immediate execution by using ToList() or similar, as you already found.

Problem (1) is unresolvable at this time. It's tracked by Query: optimize queries projecting correlated collections, so that they don't result in N+1 database queries #9282 and according to the Roadmap (Reduce n + 1 queries item) will eventually be fixed (improved) in the next EF Core 2.1 release.

The only workaround I can think of is (with the cost of higher data transfer and memory usage) to use eager loading and do the projection afterwards (in the context of LINQ to Entities):

var reports = dbContext.Reports
    .Include(r => r.Tags) // <-- eager load
    .AsEnumerable() // <-- force the execution of the LINQ to Entities query
    .Select(r => new ReportDto
    {
        Id = r.Id,
        Title = r.Title,
        Tags = r.Tags.Select(rt => rt.TagId)
    })
    .ToList();