Collection include for the in-memory provider

Part of #16963

src/EFCore.InMemory/Extensions/InMemoryServiceCollectionExtensions.cs

@@ -68,8 +68,7 @@ public static IServiceCollection AddEntityFrameworkInMemoryDatabase([NotNull] th
                         .TryAddSingleton<IInMemorySingletonOptions, InMemorySingletonOptions>()
                         .TryAddSingleton<IInMemoryStoreCache, InMemoryStoreCache>()
                         .TryAddSingleton<IInMemoryTableFactory, InMemoryTableFactory>()
-                        .TryAddScoped<IInMemoryDatabase, InMemoryDatabase>()
-                        .TryAddScoped<IInMemoryMaterializerFactory, InMemoryMaterializerFactory>());
+                        .TryAddScoped<IInMemoryDatabase, InMemoryDatabase>());
 
             builder.TryAddCoreServices();
 

src/EFCore.InMemory/Query/Internal/CustomShaperCompilingExpressionVisitor.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -28,6 +27,10 @@ private static readonly MethodInfo _includeReferenceMethodInfo
                 = typeof(CustomShaperCompilingExpressionVisitor).GetTypeInfo()
                     .GetDeclaredMethod(nameof(IncludeReference));
 
+            private static readonly MethodInfo _includeCollectionMethodInfo
+                = typeof(CustomShaperCompilingExpressionVisitor).GetTypeInfo()
+                    .GetDeclaredMethod(nameof(IncludeCollection));
+
             private static void IncludeReference<TEntity, TIncludingEntity, TIncludedEntity>(
                 QueryContext queryContext,
                 TEntity entity,
@@ -36,7 +39,9 @@ private static void IncludeReference<TEntity, TIncludingEntity, TIncludedEntity>
                 INavigation inverseNavigation,
                 Action<TIncludingEntity, TIncludedEntity> fixup,
                 bool trackingQuery)
-                where TIncludingEntity : TEntity
+                where TIncludingEntity : class, TEntity
+                where TEntity : class
+                where TIncludedEntity : class
             {
                 if (entity is TIncludingEntity includingEntity)
                 {
@@ -64,6 +69,48 @@ private static void IncludeReference<TEntity, TIncludingEntity, TIncludedEntity>
                 }
             }
 
+            private static void IncludeCollection<TEntity, TIncludingEntity, TIncludedEntity>(
+                QueryContext queryContext,
+                TEntity entity,
+                IEnumerable<TIncludedEntity> relatedEntities,
+                INavigation navigation,
+                INavigation inverseNavigation,
+                Action<TIncludingEntity, TIncludedEntity> fixup,
+                bool trackingQuery)
+                where TIncludingEntity : class, TEntity
+                where TEntity : class
+                where TIncludedEntity : class
+            {
+                if (entity is TIncludingEntity includingEntity)
+                {
+                    var collectionAccessor = navigation.GetCollectionAccessor();
+                    collectionAccessor.GetOrCreate(includingEntity, forMaterialization: true);
+
+                    if (trackingQuery)
+                    {
+                        foreach (var relatedEntity in relatedEntities)
+                        {
+                            collectionAccessor.Add(includingEntity, relatedEntity, forMaterialization: true);
+                        }
+
+                        queryContext.StateManager.TryGetEntry(includingEntity).SetIsLoaded(navigation);
+                    }
+                    else
+                    {
+                        foreach (var relatedEntity in relatedEntities)
+                        {
+                            fixup(includingEntity, relatedEntity);
+                            if (inverseNavigation != null)
+                            {
+                                SetIsLoadedNoTracking(relatedEntity, inverseNavigation);
+                            }
+                        }
+
+                        SetIsLoadedNoTracking(includingEntity, navigation);
+                    }
+                }
+            }
+
             private static void SetIsLoadedNoTracking(object entity, INavigation navigation)
                 => ((ILazyLoader)(navigation
                             .DeclaringEntityType
@@ -76,10 +123,6 @@ protected override Expression VisitExtension(Expression extensionExpression)
             {
                 if (extensionExpression is IncludeExpression includeExpression)
                 {
-                    Debug.Assert(
-                        !includeExpression.Navigation.IsCollection(),
-                        "Only reference include should be present in tree");
-
                     var entityClrType = includeExpression.EntityExpression.Type;
                     var includingClrType = includeExpression.Navigation.DeclaringEntityType.ClrType;
                     var inverseNavigation = includeExpression.Navigation.FindInverse();
@@ -90,6 +133,22 @@ protected override Expression VisitExtension(Expression extensionExpression)
                         includingClrType = entityClrType;
                     }
 
+                    if (includeExpression.Navigation.IsCollection())
+                    {
+                        return Expression.Call(
+                            _includeCollectionMethodInfo.MakeGenericMethod(entityClrType, includingClrType, relatedEntityClrType),
+                            QueryCompilationContext.QueryContextParameter,
+                            // We don't need to visit entityExpression since it is supposed to be a parameterExpression only
+                            includeExpression.EntityExpression,
+                            includeExpression.NavigationExpression,
+                            Expression.Constant(includeExpression.Navigation),
+                            Expression.Constant(inverseNavigation, typeof(INavigation)),
+                            Expression.Constant(
+                                GenerateFixup(
+                                    includingClrType, relatedEntityClrType, includeExpression.Navigation, inverseNavigation).Compile()),
+                            Expression.Constant(_tracking));
+                    }
+
                     return Expression.Call(
                         _includeReferenceMethodInfo.MakeGenericMethod(entityClrType, includingClrType, relatedEntityClrType),
                         QueryCompilationContext.QueryContextParameter,

src/EFCore.InMemory/Query/Internal/InMemoryProjectionBindingExpressionVisitor.cs

@@ -83,11 +83,14 @@ public override Expression Visit(Expression expression)
                             return expression;
 
                         case MaterializeCollectionNavigationExpression materializeCollectionNavigationExpression:
-                            //return _selectExpression.AddCollectionProjection(
-                            //    _queryableMethodTranslatingExpressionVisitor.TranslateSubquery(
-                            //    materializeCollectionNavigationExpression.Subquery),
-                            //    materializeCollectionNavigationExpression.Navigation, null);
-                            throw new NotImplementedException();
+
+                            var translated = _queryableMethodTranslatingExpressionVisitor.TranslateSubquery(
+                                materializeCollectionNavigationExpression.Subquery);
+
+                            return new ProjectionBindingExpression(
+                                _queryExpression,
+                                _queryExpression.AddToProjection(translated),
+                                typeof(IEnumerable<>).MakeGenericType(materializeCollectionNavigationExpression.Navigation.GetTargetType().ClrType));
 
                         case MethodCallExpression methodCallExpression:
                         {

src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs

@@ -7,7 +7,6 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
-using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Microsoft.EntityFrameworkCore.Query;

src/EFCore/Internal/ConcurrencyDetector.cs

@@ -4,9 +4,7 @@
 using System;
 using System.Diagnostics;
 using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore.Diagnostics;
-using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.EntityFrameworkCore.Internal
@@ -29,6 +27,8 @@ public class ConcurrencyDetector : IConcurrencyDetector
     {
         private readonly IDisposable _disposer;
         private int _inCriticalSection;
+        private static readonly AsyncLocal<bool> _threadHasLock = new AsyncLocal<bool>();
+        private int _refCount;
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -48,17 +48,29 @@ public virtual IDisposable EnterCriticalSection()
         {
             if (Interlocked.CompareExchange(ref _inCriticalSection, 1, 0) == 1)
             {
-                throw new InvalidOperationException(CoreStrings.ConcurrentMethodInvocation);
+                if (!_threadHasLock.Value)
+                {
+                    throw new InvalidOperationException(CoreStrings.ConcurrentMethodInvocation);
+                }
+            }
+            else
+            {
+                _threadHasLock.Value = true;
             }
 
+            _refCount++;
             return _disposer;
         }
 
         private void ExitCriticalSection()
         {
             Debug.Assert(_inCriticalSection == 1, "Expected to be in a critical section");
 
-            _inCriticalSection = 0;
+            if (--_refCount == 0)
+            {
+                _threadHasLock.Value = false;
+                _inCriticalSection = 0;
+            }
         }
 
         private readonly struct Disposer : IDisposable

test/EFCore.InMemory.FunctionalTests/InMemoryComplianceTest.cs

@@ -15,7 +15,6 @@ public class InMemoryComplianceTest : ComplianceTestBase
             typeof(FunkyDataQueryTestBase<>),
             typeof(OptimisticConcurrencyTestBase<>),
             typeof(StoreGeneratedTestBase<>),
-            typeof(LoadTestBase<>),                        // issue #16963
             typeof(MusicStoreTestBase<>),                  // issue #16963
             typeof(ConferencePlannerTestBase<>),           // issue #16963
             typeof(GraphUpdatesTestBase<>),                // issue #16963