Casting using an Explicit Static Operator breaks Include Statements

[Pieeer1]

This is pretty easily reproduceable, but frustrating in the same:
Relationship Example:

public class Forum
{
    private Forum() { }
    public Forum(double differentId) { DifferentId = differentId; }
    public Forum(Blog blog) { DifferentId = (double)blog.Id; Posts = blog.Posts; }
    public double DifferentId { get; set; }
    public ICollection<Post> Posts { get; set; } = null!;
}
public class Blog
{
    private Blog() { }
    public Blog(int id) { Id = id; }
    public int Id { get; set; }
    public static explicit operator Forum(Blog blog) { return new Forum(blog); }
    public ICollection<Post> Posts { get; set; } = null!;
}
public class Post
{ 
    public int Id { get; set; }
    public virtual Blog Blog { get; set; } = null!;
    public int BlogId { get; set; }
}

Bug Example:

        _blogRepository.GetAll().Include(x => x.Posts).ToList(); // returns the posts
        _blogRepository.GetAll().Include(x => x.Posts).Select(x => new Forum(x)); // returns the posts
        _blogRepository.GetAll().Include(x => x.Posts).Cast<Forum>(); // does not return the posts

There are no exceptions thrown in this case

EF Core version: 7.0.4
Database provider: (e.g. Microsoft.EntityFrameworkCore.SqlServer)
Target framework: (e.g. .NET 7.0)
Operating system: Windows 10
IDE: (e.g. Visual Studio 2022 17.4)

[roji]

@Pieeer1 what behavior are you expecting given that Post doesn't extend Forum? Cast<Forum> wouldn't return posts when used against a regular, in-memory collection (enumerable) - we generally try to approximate that behavior.

If you're expecting an exception, then EF doesn't raise exceptions in many cases where the equivalent in-memory code would (e.g. when accessing a property on a null instance). This is because it's usually impractical to get the database to trigger an exception, and we wouldn't want to bring extra data to the client just in order to trigger an exception.

[Pieeer1]

@roji I was expecting the same behavior at the include level. If I use include I expect the queryable to contain the included elements, and therefore should be able to get cast correctly.

[roji]

I may have misread your code above - the problem isn't that Post doesn't extend Form, it's that Blog doesn't.

But regardless, I still don't understand what you're trying to do. Presumably, _blogRepository.GetAll() returns all Blogs; what does it mean to do Cast<Forum> over that, given that Blogs cannot be cast into Posts? That is, the Include here is irrelevant: I'd expect _blogRepository.GetAll().Cast<Forum>(); to also return nothing at all, is that not the case?

[Pieeer1]

The snippet I have provided may have been a bad example as I was not fully sharing my domain object names on my side, I guess the main issue is the loading of the included entities in the stack.

The Cast does work, but the Posts never get loaded into the actual stack when the extended functionality is Cast<>

I feel like I am explaining this poorly so I put together a different example with a DTO model:

IE:

    public class Blog // domain object
    {
        private Blog() { }
        public Blog(int id) { Id = id; }
        public int Id { get; set; }
        public string Name {get;set;}
        public static explicit operator BlogDTO(Blog blog) { return new BlogDTO(blog); }
        public ICollection<Post> Posts { get; set; } = null!;
    }
    public class Post // domain object
    {
        public int Id { get; set; }
        public virtual Blog Blog { get; set; } = null!;
        public string Name {get;set;} = null!;
        public int BlogId { get; set; }
    }
    public class BlogDTO // not a domain object
    { 
        public BlogDTO(Blog blog)
        {
            Id = blog.Id;
            Posts = blog.Posts.ToList();
        }
        public int Id { get; set; }
        public List<Post> Posts = new List<Post>();
    }

The Data:

This is the output of the casted list AFTER calling Get all, and get all with include. As you can see here, the posts are included every time.

If you switch the position around, this is no longer the same behaviour:

I would expect the behavior to be consistent through both of the situations, or am I misunderstanding this call?

[roji]

@Pieeer1 can you please try to submit a minimal, runnable code sample? It's a bit difficult to piece together everything from the above screenshots and fragments. Just a small console program with your model and a query that doesn't behave as you're expecting it to.

[Pieeer1]

@roji Of Course, Here you go.

Here is the SQL to create the equivalent database:

CREATE DATABASE ExampleDB
USE ExampleDB

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Blogs](
	[Id] [int] IDENTITY(1,1) NOT NULL,
	[Name] [nvarchar](max) NOT NULL,
 CONSTRAINT [PK_Blogs] PRIMARY KEY CLUSTERED 
(
	[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Posts](
	[Id] [int] IDENTITY(1,1) NOT NULL,
	[Name] [nvarchar](max) NOT NULL,
	[BlogId] [int] NOT NULL,
 CONSTRAINT [PK_Posts] PRIMARY KEY CLUSTERED 
(
	[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
CREATE NONCLUSTERED INDEX [IX_Posts_BlogId] ON [dbo].[Posts]
(
	[BlogId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Posts]  WITH CHECK ADD  CONSTRAINT [FK_Posts_Blogs_BlogId] FOREIGN KEY([BlogId])
REFERENCES [dbo].[Blogs] ([Id])
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[Posts] CHECK CONSTRAINT [FK_Posts_Blogs_BlogId]
GO


INSERT INTO Blogs(Name) values ('Example Blog')
INSERT INTO Posts(Name, BlogId) values ('Example Post', 1)

And the single .net7.0 Console App:

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using Microsoft.EntityFrameworkCore.Migrations;
using Newtonsoft.Json;
namespace EfCoreBug
{
    public class Program
    {
        public static void Main()
        {
            var optionsBuilder = new DbContextOptionsBuilder<Context>();
            optionsBuilder.EnableSensitiveDataLogging();
            optionsBuilder.UseSqlServer(
                "Server=(localdb)\\mssqllocaldb;Database=ExampleDB",
                x => x.MigrationsHistoryTable(
                    HistoryRepository.DefaultTableName,
                    "dbo"));
            IContext context = new Context(optionsBuilder.Options);

            ExampleOfBug(context);
            ExampleOfInconsistentBehavior(context);

        }
        private static void ExampleOfBug(IContext context)
        {
            IBlogRepository repository = new BlogRepository(context);

            var castedList = repository.GetAll().Include(x => x.Posts).Cast<BlogDTO>().ToList();
            var normalList = repository.GetAll().ToList();
            var includedList = repository.GetAll().Include(x => x.Posts).ToList();

            Console.WriteLine($"Casted List: {JsonConvert.SerializeObject(castedList, new JsonSerializerSettings()
            { 
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
            Console.WriteLine($"Normal List: {JsonConvert.SerializeObject(normalList, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
            Console.WriteLine($"Included List: {JsonConvert.SerializeObject(includedList, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
        }
        private static void ExampleOfInconsistentBehavior(IContext context)
        {
            IBlogRepository repository = new BlogRepository(context);

            var normalList = repository.GetAll().ToList();
            var includedList = repository.GetAll().Include(x => x.Posts).ToList();
            var castedList = repository.GetAll().Include(x => x.Posts).Cast<BlogDTO>().ToList();

            Console.WriteLine($"Casted List: {JsonConvert.SerializeObject(castedList, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
            Console.WriteLine($"Normal List: {JsonConvert.SerializeObject(normalList, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
            Console.WriteLine($"Included List: {JsonConvert.SerializeObject(includedList, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            })}"); // Console is just for visualization, please use stack trace to show as well
        }
    }

    public abstract class Repository<T> : IRepository<T> where T : class
    {
        private readonly IContext _context;

        public Repository(IContext context)
        {
            _context = context;
        }
        public IQueryable<T> GetAll()
        {
            return _context.Set<T>();
        }
    }
    public interface IRepository<T> where T : class
    {
        IQueryable<T> GetAll();

    }
    public partial class Context : DbContext, IContext
    {
        public Context(DbContextOptions<Context> options) : base(options)
        {
        }
        public ChangeTracker GetChangeTracker()
        {
            return ChangeTracker;
        }

        public virtual DbSet<Blog> Blogs { get; set; } = null!;
        public virtual DbSet<Post> Posts { get; set; } = null!;
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Blog>(entity =>
            {
                entity.ToTable("Blogs", "dbo");

                entity.HasKey(e => e.Id);
            });
            modelBuilder.Entity<Post>(entity =>
            {
                entity.ToTable("Posts", "dbo");

                entity.HasKey(e => e.Id);
            });
        }
        partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
    }
    public interface IContext
    {
        public DbSet<T> Set<T>() where T : class;
    }
    public class Blog
    {
        private Blog() { }
        public Blog(string name) { Name = name; }
        public int Id { get; set; }
        public string Name { get; set; } = null!;

        public static explicit operator BlogDTO(Blog blog) { return new BlogDTO(blog); }
        public ICollection<Post> Posts { get; set; } = null!;
    }
    public class Post
    {
        public int Id { get; set; }
        public string Name { get; set; } = null!;
        public virtual Blog Blog { get; set; } = null!;
        public int BlogId { get; set; }
    }
    public class BlogDTO
    {

        public BlogDTO(Blog blog)
        {
            Id = blog.Id;
            Posts = blog?.Posts?.ToList() ?? new List<Post>();
        }
        public int Id { get; set; }
        public List<Post> Posts = new List<Post>();
    }
    public class BlogRepository : Repository<Blog>, IBlogRepository
    {
        public BlogRepository(IContext containerAndVesselContext) : base(containerAndVesselContext) { }

    }
    public interface IBlogRepository : IRepository<Blog>
    {

    }
}

CSProj for reference:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net7.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.4" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.4">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.4" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.4">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>

</Project>

[ajcvickers]

@Pieeer1 The Cast method doesn't even work like this when using LINQ-to-Objects:

var blogs = new List<Blog> { new("One") };
var dtos = blogs.Cast<BlogDTO>().ToList();

Unhandled exception. System.InvalidCastException: Unable to cast object of type 'EfCoreBug.Blog' to type 'EfCoreBug.BlogDTO'.
   at System.Linq.Enumerable.CastIterator[TResult](IEnumerable source)+MoveNext()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at EfCoreBug.Program.Main() in C:\local\code\AllTogetherNow\Daily\Daily.cs:line 22

[ajcvickers]

Note from triage: this is not something we are going to support.