DbContext - Extension which get by id locally first

What I'm trying to do is, load data from local first and if that's not the case, then query the database instead. The whole idea is that I have several IDomainEventPre which are ran before the SaveChangesAsync call. So querying the database for these records doesn't make sense, because they exist locally, but SaveChangesAsync is yet to be called.

That would be a simple extension method if I didn't want to include related data, i.e.

public virtual async Task<T> GetByIdLocallyFirst(Guid id)
{
	var entity = _dbSet.Local.FirstOrDefault(x => x.Id == id);
	if (entity == null)
	{
		entity = await _dbSet.FindAsync(id);
	}

	return entity;
}

but in my case, I do want to include the related data.

Snippet

Here is my attempt:

var offer = await _dbContext.Offers.GetByIdLocallyFirstAsync(_dbContext, notification.OfferId, q => q
	.Include(x => x.Commodity)
	.Include(x => x.ContractType)
	.Include(x => x.Customer)
	.Include(x => x.Employee)
	.Include(x => x.DeliveryLocation)
	.Include(x => x.Location), cancellationToken);

However, unsuccessfully as I'm failing to load the related data if it's pulled off local.

public static class QueryExtensions
{
	public static async Task<TEntity> GetByIdLocallyFirstAsync<TEntity>(this DbSet<TEntity> dbSet, Guid id, Func<IQueryable<TEntity>, IQueryable<TEntity>> includeFunc = null, CancellationToken cancellationToken = default)
		where TEntity : class
	{
		Func<object, Guid> getId = x =>
		{
			var property = x.GetType().GetProperty("Id");
			if (property == null)
				throw new InvalidOperationException($"The entity type {typeof(TEntity)} does not have an 'Id' property of type Guid.");
	
			var value = property.GetValue(x);
			if (value == null)
				throw new InvalidOperationException($"The 'Id' property on the entity type {typeof(TEntity)} is null.");
	
			return (Guid)value;
		};
		
		// First, look in the local cache
		var entity = dbSet.Local.FirstOrDefault(x => getId(x) == id);
	
		// If entity is found in the local cache, manually include related data if needed
		if (entity != null)
		{
			// TODO: How do we include related data?
            // I assume we do FirstOrDefaultAsync for each one of the tables that we specified in Include? But how do we do that?
			return entity;
		}
	
		// If not found in the local cache, query the database
		if (includeFunc != null)
		{
			var query = includeFunc(dbSet);
			entity = await query.FirstOrDefaultAsync(e => getId(e) == id, cancellationToken);
		}
		else
		{
			entity = await dbSet.FindAsync(new object[] { id }, cancellationToken);
		}
	
		return entity;
	}
}

Lastly, ideally I would like this to be invoked as following:

var offer = await _dbContext.Offers
	.Include(x => x.Commodity)
	.Include(x => x.ContractType)
	.Include(x => x.Customer)
	.Include(x => x.Employee)
	.Include(x => x.DeliveryLocation)
	.Include(x => x.Location)
	.GetByIdLocallyFirstAsync(notification.OfferId, cancellationToken);

First of all you can change the first implementation of GetByIdLocallyFirst to just FindAsync because it already does what is needed:

> Finds an entity with the given primary key values. If an entity with the given primary key values is being tracked by the context, then it is returned immediately without making a request to the database.

Then you can try using the Explicit Loading of Related Data via EntityEntry though it can become cumbersome quite quickly. The non-generic version looks like:

using (var context = new BloggingContext())
{
    var blog = context.Blogs
        .Single(b => b.BlogId == 1);

    context.Entry(blog)
        .Collection(b => b.Posts)
        .Load();

    context.Entry(blog)
        .Reference(b => b.Owner)
        .Load();
}

From CollectionEntry.Load docs:

> Loads the entities referenced by this navigation property, unless IsLoaded is already set to true.

From ReferenceEntry.Load docs:

> Loads the entity or entities referenced by this navigation property, unless IsLoaded is already set to true.

The Load method in both cases comes from base class - NavigationEntry.

Though personally I would not bother in most cases. The cost of potentially hitting database multiple times in case nothing was loaded can be a major consideration.

Also if this is a potentially heavy impacting scenario for you - you should consider just switching to the Lazy Loading of Related Data.