Add a custom collection interface with an `IsLoaded` property.

[haacked]

Problem

In a large application, it can be difficult to know if a navigation collection is loaded or not deep in the code (say you have method that gets passed an entity and you need to access a navigation collection property on the entity). Especially if multiple callers of the method pass an entity loaded in different ways.

We tried to solve this problem by making navigation collections that aren't always loaded non-nullable, and "optional" navigation collections nullable. That way if it's null, we would load it then:

if (entity.CollectionProperty is null) {
    await dbContext.Entry(entity).Collection(e => e.CollectionProperty).LoadAsync();
}

Or in some cases we would assert that it's not null (if we had expected the caller to Include that collection.

Debug.Assert(entity.CollectionProperty is not null);

However, as we learned, this leads to subtle bugs due to EF Core's automatic fixup feature. I wrote a blog post that demonstrates the issue. We can't rely on the nullability of a collection to know that it's loaded or not.

So the only viable solution is to always check the entry's IsLoaded property if we want to assert that it's loaded:

Debug.Assert(dbContext.Entry(entity).Collection(e => e.CollectionProperty).IsLoaded);

Or if we're fine with lazy loading, we can do this

// Ensure the collection is loaded. This already checks `IsLoaded`.
await dbContext.Entry(entity).Collection(e => e.CollectionProperty).LoadAsync();

Proposed Solution

Correct me if I'm wrong, but when EF evaluates a query and returns an entity, it knows at that time whether navigation properties are loaded or not. What I would like is to be able to apply an interface on a collection property and have EF populate the IsLoaded property of that interface. For example:

public interface IEntityCollection<T> : ICollection<T> {
    bool IsLoaded { get; }
}

Now suppose I have the following entity:

public class Blog {
   public IEntityCollection<Post> Posts { get; set; } = null!;
}

I could then run the following code with the following results:

var blog = await dbContext.Blog.FirstOrDefaultAsync(b => b.Id == 123);
Assert.False(blog.Posts.IsLoaded); // Passes

var blog2 = await dbContext.Blog.Include(b => b.Posts).FirstOrDefaultAsync(b => b.Id == 123);
Assert.True(blog.Posts.IsLoaded); // Passes

It might make sense to have IEntityList<T> too.

Thanks for your consideration.

[ajcvickers]

@haacked Interesting question! Here's an example of an approach that should work. It relies on EF Core automatically injecting the DbContext into the parent entity's constructor.

public class Blog
{
    public Blog()
    {
        Posts = new();
    }

    private Blog(DbContext context)
    {
        Posts = new(context, this, nameof(Posts));
    }

    public int Id { get; set; }
    public EntityCollection<Post> Posts { get; init; } 
}

public class Post
{
    public int Id { get; set; }
    public int? BlogId { get; set; }
    public Blog? Blog { get; set; }
}

public class EntityCollection<T> : List<T>
{
    private readonly DbContext? _context;
    private readonly object? _parent;
    private readonly string? _navigation;

    public EntityCollection()
    {
    }

    public EntityCollection(DbContext context, object parent, string navigation)
    {
        _context = context;
        _parent = parent;
        _navigation = navigation;
    }

    public bool IsLoaded
        => _context?.Entry(_parent!).Collection(_navigation!).IsLoaded ?? false;
}

public class SomeDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Your.ConnectionString)
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();

    public DbSet<Blog> Blogs => Set<Blog>();
}

public class Program
{
    public static void Main()
    {
        using (var context = new SomeDbContext())
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();

            context.Add(
                new Blog
                {
                    Posts = { new Post(), new Post(), new Post() }
                });
            context.SaveChanges();
        }

        using (var context = new SomeDbContext())
        {
            var blog = context.Blogs.Single();
            Console.WriteLine(blog.Posts.IsLoaded);
            context.Entry(blog).Collection(e => e.Posts).Load();
            Console.WriteLine(blog.Posts.IsLoaded);
        }
    }
}

[haacked]

@ajcvickers oh interesting! And if I wanted to expose this property as an interface, IEntityCollection<T>, is there a way to tell EF Core to use EntityCollection<T> when hydrating an IEntityCollection<T>.

[ajcvickers]

@haacked

First, I'm curious why you want to use an interface here? This is something that @roji has brought up in the past when we show entity types that use ICollection as their collection property type.

Second, in EF7 you could do this with an interceptor. For example:

public class Blog
{
    public int Id { get; set; }
    public IEntityCollection<Post> Posts { get; set; } = null!;
}

public class Post
{
    public int Id { get; set; }
    public int? BlogId { get; set; }
    public Blog? Blog { get; set; }
}

public interface IEntityCollection<T> : ICollection<T>
{
    bool IsLoaded { get; }
}

public class EntityCollection<T> : List<T>, IEntityCollection<T>
{
    private readonly DbContext? _context;
    private readonly object? _parent;
    private readonly string? _navigation;

    public EntityCollection()
    {
    }

    public EntityCollection(DbContext context, object parent, string navigation)
    {
        _context = context;
        _parent = parent;
        _navigation = navigation;
    }

    public bool IsLoaded
        => _context?.Entry(_parent!).Collection(_navigation!).IsLoaded ?? false;
}

public class SomeDbContext : DbContext
{
    private static readonly MaterializationInterceptor MaterializationInterceptor = new();
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .AddInterceptors(MaterializationInterceptor)
            .UseSqlServer(Your.ConnectionString)
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();

    public DbSet<Blog> Blogs => Set<Blog>();
}

public class Program
{
    public static void Main()
    {
        using (var context = new SomeDbContext())
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
        
            context.Add(
                new Blog
                {
                    Posts = new EntityCollection<Post> { new(), new(), new() }
                });
            context.SaveChanges();
        }
        
        using (var context = new SomeDbContext())
        {
            var blog = context.Blogs.Single();
            Console.WriteLine(blog.Posts.IsLoaded);
            context.Entry(blog).Collection(e => e.Posts).Load();
            Console.WriteLine(blog.Posts.IsLoaded);
        }
    }
}

public class MaterializationInterceptor : IMaterializationInterceptor
{
    public object CreatedInstance(MaterializationInterceptionData materializationData, object entity)
    {
        var context = materializationData.Context;
        foreach (var navigation in materializationData.EntityType.GetNavigations())
        {
            if (navigation.ClrType.IsGenericType
                && navigation.ClrType.GetGenericTypeDefinition() == typeof(IEntityCollection<>))
            {
                entity.GetType().GetProperty(navigation.Name)!.SetValue(
                    entity, Activator.CreateInstance(
                        typeof(EntityCollection<>).MakeGenericType(
                            navigation.TargetEntityType.ClrType), context, entity, navigation.Name));
            }
        }

        return entity;
    }
}

[haacked]

First, I'm curious why you want to use an interface here?

Old habits die hard. 😆

It occurs to me that in this specific case, I probably don't need an interface.

This is something that @roji has brought up in the past when we show entity types that use ICollection as their collection property type.

Yeah, for collection, I like that EF supports IList<T> and ICollection<T>. But for me, it's primarily for code style reasons. In writing a lot of tests, I like using array initializer syntax to populate a collection.

public class Blog {
   public IList<T> Posts { get; set; }
}

blog.Posts = new[] { new Post(), new Post() };

If Posts is a List<T>, I can't initialize it with an array. This mostly affects my unit tests to be honest.

However, it occurs to me that System.Array doesn't implement a custom IEntityCollection<T> interface so I don't get any real benefit from defining that entity property as an interface.

[ajcvickers]

@haacked In the first code example I used this:

            context.Add(
                new Blog
                {
                    Posts = { new Post(), new Post(), new Post() }
                });

Which, combined with a read-only collection property, is my favorite way of initializing.

In the second, I use this:

            context.Add(
                new Blog
                {
                    Posts = new EntityCollection<Post> { new(), new(), new() }
                });

Which is my preferred way of doing it when the collection property is null by default.

Both of these seem at least as good as using an array.

[haacked]

I added a LoadAsync to my copy of the EntityCollection<T>.

    /// <summary>
    /// Loads the collection from the database and returns the collection.
    /// </summary>
    /// <param name="cancellationToken">A cancellation token.</param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException">Thrown if this collection wasn't originally populated from EF.</exception>
    public async Task<EntityList<T>> EnsureLoadedAsync(CancellationToken cancellationToken = default)
    {
        if (_context is not null)
        {
            await _context.Entry(_parent!).Collection(_navigation!).LoadAsync(cancellationToken);
        }
        else
        {
            // Probably should throw here in production, but that would break a crap ton of tests.
            // In practice, we should never run into that situation anyways as we can trust EF Core
            // to inject the context.
        } 
        return this;
    }

That makes the code quite nice:

var posts = await blog.Posts.EnsureLoadedAsync();

[ajcvickers]

Nice!

[haacked]

It looks like the in memory provider doesn't do the context injection. I was trying to get these to work in some unit tests we have.

[ajcvickers]

@haacked It works in the sample app above. Make sure your entity instances are being created by EF Core, and not by new. Or, a service property can be used if you want to be able to create instances with new and then have the context injected when they are attached. See code below for an example.

Note that we recommend against using the in-memory provider for testing.

public class Blog
{
    private DbContext? _context;

    private DbContext? Context
    {
        get => _context;
        set
        {
            _context = value;
            Posts.InjectContext(value!, this, nameof(Posts));
        }
    }

    public int Id { get; set; }
    public EntityCollection<Post> Posts { get; } = new();
}

public class Post
{
    public int Id { get; set; }
    public int? BlogId { get; set; }
    public Blog? Blog { get; set; }
}

public class EntityCollection<T> : List<T>
{
    private DbContext? _context;
    private object? _parent;
    private string? _navigation;

    public void InjectContext(DbContext context, object parent, string navigation)
    {
        _context = context;
        _parent = parent;
        _navigation = navigation;
    }

    public bool IsLoaded
        => _context?.Entry(_parent!).Collection(_navigation!).IsLoaded ?? false;
}

public class SomeDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Your.ConnectionString)
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();

    public DbSet<Blog> Blogs => Set<Blog>();
}

public class Program
{
    public static void Main()
    {
        using (var context = new SomeDbContext())
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();

            var blog = new Blog
            {
                Posts = { new Post(), new Post(), new Post() }
            };
            
            context.Add(blog);
            
            context.SaveChanges();
        }

        using (var context = new SomeDbContext())
        {
            var blog = context.Blogs.Single();
            Console.WriteLine(blog.Posts.IsLoaded);
            context.Entry(blog).Collection(e => e.Posts).Load();
            Console.WriteLine(blog.Posts.IsLoaded);
        }
    }
}