The expression 'y.Cases' is invalid inside an 'Include' operation

Question

I have one-to-many relationship database. DbSet Companies being "One" and DbSet Cases being "many". Here's my context and model classes:

Database Context

class CaseContext : DbContext
{
    public DbSet<ParticipantCompany> Companies{ get; set; }
    public DbSet<ParticipantPerson> Persons { get; set; }
    public DbSet<LegalCase> Cases { get; set; }
    protected override void OnConfiguring(DbContextOptionsBuilder options)
        => options.UseSqlite("Data Source=Clients.db");
}

ParticipantCompany class inherits from Participant Class.

public class ParticipantCompany : Participant
{
    public ParticipantCompany():this(false, "","","","") { }
    public ParticipantCompany (bool isclient) : this(isclient, "","","","") { }
    public ParticipantCompany(bool isclient, string name, string address, string inncompany, string ogrn) : base(isclient, SubjectType.Company)
    {
        Name = name;
        Address = address;
        InnCompany = inncompany;
        Ogrn = ogrn;
    }
    public string InnCompany { get; set; }
    public string Ogrn { get; set; }
}

public abstract class Participant
{
    public Participant(bool isclient, SubjectType Type,  string name, string address) 
    { 
        SubjType = Type;
        IsClient = isclient;
        Name = name;
        Address = address;
    }

    public Participant(bool isclient, SubjectType Type ) : this(isclient, Type, "","")
    {

    }
    public int Id { get; set; }
    public  SubjectType SubjType { get; private set; }
    public bool IsClient { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }

    public List<LegalCase> Cases = new List<LegalCase>();

}

LegalCase class represents "Many" in relationships

public class LegalCase
{
    public LegalCase() : this("", CaseType.ArbGeneral){} 
    public LegalCase(string casefabula, CaseType casetype) 
    {
        CaseFabula = casefabula;
        CaseType = casetype;
    }
    public int Id { get; set; }
    public string CaseFabula { get; set; }
    public CaseType CaseType { get; set; }
    //public ICaseParticipant Client { get; set; }
    public int? CompanyId { get; set; }
    public   ParticipantCompany Company { get; set; }
    public int? PersonId { get; set; }
    public  ParticipantPerson Person { get; set; }
}

Now here's the Query:

        using(var db = new CaseContext())
        {
            var QClients = db.Companies
                .Where(x => x.IsClient == true)
                //Exception: The expression 'y.Cases' is
                // invalid inside an 'Include' operation,
                // since it does not represent a property
                // access: 't => t.MyProperty'. etc
                .Include(y => y.Cases)
                .ToList();
        }

I tried to explicitly cast y to ParticipantCompany since it's what the prompt of the exection seems to suggest:

To target navigations declared on derived types, use casting ('t => ((Derived)t).MyProperty') or the 'as' operator ('t => (t as Derived).MyProperty')

But it generates the same exception:

         using(var db = new CaseContext())
        {
            var QClients = db.Companies
                .Where(x => x.IsClient == true)
                 //Same exception
                .Include(y => (y as ParticipantCompany).Cases)
                .ToList();
        }   

Answer 1

Change Cases from being field to property as the exception suggests:

public List<LegalCase> Cases { get; set; } = new List<LegalCase>();

From the docs :

Each entity type in your model has a set of properties, which EF Core will read and write from the database. If you're using a relational database, entity properties map to table columns.

By convention, all public properties with a getter and a setter will be included in the model.