public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var entityType = new EntityType(typeof(object), new Model(new ConventionSet()), ConfigurationSource.Convention);
var property = new Property("A", typeof(int), null, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention);
var queryModel = new QueryModel(new MainFromClause("A", typeof(object), Expression.Constant("A")), new SelectClause(Expression.Constant("A")));
var includeResultOperator = new IncludeResultOperator(new[] { "Foo" }, Expression.Constant("A"));
var options = new DbContextOptionsBuilder().UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(QueryModel), () => queryModel },
{ typeof(string), () => "Fake" },
{ typeof(IExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyCollection <IPropertyBase>), () => new[] { property } },
{ typeof(IncludeResultOperator), () => includeResultOperator },
{ typeof(IReadOnlyList <System.Exception>), () => new[] { new Exception() } }
};
InMemoryTestHelpers.Instance.TestEventLogging(typeof(CoreEventId), typeof(CoreLoggerExtensions), fakeFactories);
}
public void Every_eventId_has_a_logger_method_and_logs_when_level_enabled()
{
var propertyInfo = typeof(DateTime).GetTypeInfo().GetDeclaredProperty(nameof(DateTime.Now));
var entityType = new EntityType(typeof(object), new Model(new ConventionSet()), ConfigurationSource.Convention);
var property = new Property(
"A", typeof(int), propertyInfo, null, entityType, ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherEntityType = new EntityType(typeof(object), entityType.Model, ConfigurationSource.Convention);
var otherProperty = otherEntityType.AddProperty("A", typeof(int), ConfigurationSource.Convention, ConfigurationSource.Convention);
var otherKey = otherEntityType.AddKey(otherProperty, ConfigurationSource.Convention);
var foreignKey = new ForeignKey(new[] { property }, otherKey, entityType, otherEntityType, ConfigurationSource.Convention);
var navigation = new Navigation("N", propertyInfo, null, foreignKey);
var queryModel = new QueryModel(
new MainFromClause("A", typeof(object), Expression.Constant("A")), new SelectClause(Expression.Constant("A")));
var includeResultOperator = new IncludeResultOperator(new[] { "Foo" }, Expression.Constant("A"));
var options = new DbContextOptionsBuilder()
.UseInternalServiceProvider(InMemoryFixture.DefaultServiceProvider)
.UseInMemoryDatabase("D").Options;
var fakeFactories = new Dictionary <Type, Func <object> >
{
{ typeof(Type), () => typeof(object) },
{ typeof(DbContext), () => new DbContext(options) },
{ typeof(DbContextOptions), () => options },
{ typeof(QueryModel), () => queryModel },
{ typeof(string), () => "Fake" },
{ typeof(IExpressionPrinter), () => new ExpressionPrinter() },
{ typeof(Expression), () => Expression.Constant("A") },
{ typeof(IEntityType), () => entityType },
{ typeof(IKey), () => new Key(new[] { property }, ConfigurationSource.Convention) },
{ typeof(IPropertyBase), () => property },
{ typeof(IServiceProvider), () => new FakeServiceProvider() },
{ typeof(ICollection <IServiceProvider>), () => new List <IServiceProvider>() },
{ typeof(IReadOnlyList <IPropertyBase>), () => new[] { property } },
{ typeof(IEnumerable <Tuple <MemberInfo, Type> >), () => new[] { new Tuple <MemberInfo, Type>(propertyInfo, typeof(object)) } },
{ typeof(MemberInfo), () => propertyInfo },
{ typeof(IncludeResultOperator), () => includeResultOperator },
{ typeof(IReadOnlyList <Exception>), () => new[] { new Exception() } },
{ typeof(IProperty), () => property },
{ typeof(INavigation), () => navigation },
{ typeof(IForeignKey), () => foreignKey },
{ typeof(InternalEntityEntry), () => new FakeInternalEntityEntry(entityType) },
{ typeof(ISet <object>), () => new HashSet <object>() },
{
typeof(IList <IDictionary <string, string> >),
() => new List <IDictionary <string, string> > {
new Dictionary <string, string> {
{ "A", "B" }
}
}
},
{ typeof(IDictionary <string, string>), () => new Dictionary <string, string>() }
};
TestEventLogging(
typeof(CoreEventId),
typeof(CoreLoggerExtensions),
typeof(LoggingDefinitions),
fakeFactories);
}
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition"> The event definition. </param>
/// <param name="messageGenerator"> A delegate that generates a log message for this event. </param>
/// <param name="includeResultOperator"> The <see cref="IncludeResultOperator"/>. </param>
public IncludeEventData(
[NotNull] EventDefinitionBase eventDefinition,
[NotNull] Func <EventDefinitionBase, EventData, string> messageGenerator,
[NotNull] IncludeResultOperator includeResultOperator)
: base(eventDefinition, messageGenerator)
{
IncludeResultOperator = includeResultOperator;
}
public IncludeSpecification(
IncludeResultOperator includeResultOperator,
QuerySourceReferenceExpression querySourceReferenceExpression,
INavigation[] navigationPath)
{
IncludeResultOperator = includeResultOperator;
QuerySourceReferenceExpression = querySourceReferenceExpression;
NavigationPath = navigationPath;
}
private bool TryPopulateIncludeLoadTree(
IncludeResultOperator includeResultOperator,
IncludeLoadTree includeLoadTree,
bool shouldThrow)
{
if (includeResultOperator.NavigationPaths != null)
{
foreach (var navigationPath in includeResultOperator.NavigationPaths)
{
includeLoadTree.AddLoadPath(navigationPath);
}
return(true);
}
IEntityType entityType = null;
if (includeResultOperator.PathFromQuerySource is QuerySourceReferenceExpression qsre)
{
entityType = _queryCompilationContext.FindEntityType(qsre.ReferencedQuerySource);
}
if (entityType == null)
{
entityType = _queryCompilationContext.Model.FindEntityType(includeResultOperator.PathFromQuerySource.Type);
if (entityType == null)
{
var pathFromSource = MemberAccessBindingExpressionVisitor.GetPropertyPath(
includeResultOperator.PathFromQuerySource, _queryCompilationContext, out qsre);
if (pathFromSource.Count > 0 &&
pathFromSource[pathFromSource.Count - 1] is INavigation navigation)
{
entityType = navigation.GetTargetType();
}
}
}
if (entityType == null)
{
if (shouldThrow)
{
throw new InvalidOperationException(
CoreStrings.IncludeNotSpecifiedDirectlyOnEntityType(
includeResultOperator.ToString(),
includeResultOperator.NavigationPropertyPaths.FirstOrDefault()));
}
return(false);
}
return(WalkNavigations(entityType, includeResultOperator.NavigationPropertyPaths, includeLoadTree, shouldThrow));
}
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext)
{
var navigationPropertyPath
= Source.Resolve(
_navigationPropertyPathLambda.Parameters[0],
_navigationPropertyPathLambda.Body,
clauseGenerationContext);
var includeResultOperator = new IncludeResultOperator(navigationPropertyPath);
clauseGenerationContext.AddContextInfo(this, includeResultOperator);
return includeResultOperator;
}
private static Action <TInclude> GetJoinListCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
var included = (IList <TInclude>)(queryProperty).GetValue(query);
if (included == null)
{
queryProperty.SetValue(query, new List <TInclude>());
included = (IList <TInclude>)queryProperty.GetValue(query);
}
return(included.Fill);
}
protected static PropertyInfo GetPropertyInfo(PropertyInfo property, IncludeResultOperator @operator)
{
var target = Expression.Parameter(property.DeclaringType, "target");
var method = property.GetGetMethod();
var callGetMethod = Expression.Call(target, method);
var lambda = Expression.Lambda <Func <IncludeResultOperator, LambdaExpression> >(callGetMethod, target);
var compiledLambda = ExpressionCompiler.Compile <Func <IncludeResultOperator, LambdaExpression> >(lambda);
var callback = compiledLambda.Invoke(@operator);
var mi = (PropertyInfo)((MemberExpression)callback.Body).Member;
return(mi);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext)
{
var prm = Expression.Parameter(typeof(object));
var pathFromQuerySource = Resolve(prm, prm, clauseGenerationContext);
if (!(_navigationPropertyPathLambda.Body is MemberExpression))
{
throw new InvalidOperationException(CoreStrings.InvalidPropertyExpression(_navigationPropertyPathLambda));
}
var includeResultOperator = new IncludeResultOperator(
_navigationPropertyPathLambda.GetComplexPropertyAccess("?not sure what goes here?").Select(p => p.Name),
pathFromQuerySource);
clauseGenerationContext.AddContextInfo(this, includeResultOperator);
return(includeResultOperator);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext)
{
var navigationPropertyPath
= Source.Resolve(
_navigationPropertyPathLambda.Parameters[0],
_navigationPropertyPathLambda.Body,
clauseGenerationContext) as MemberExpression;
if (navigationPropertyPath == null)
{
throw new InvalidOperationException(
CoreStrings.InvalidComplexPropertyExpression(_navigationPropertyPathLambda));
}
var includeResultOperator = new IncludeResultOperator(navigationPropertyPath);
clauseGenerationContext.AddContextInfo(this, includeResultOperator);
return includeResultOperator;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static void IncludeIgnoredWarning(
[NotNull] this IDiagnosticsLogger <DbLoggerCategory.Query> diagnostics,
[NotNull] IncludeResultOperator includeResultOperator)
{
var definition = CoreStrings.LogIgnoredInclude;
definition.Log(
diagnostics,
includeResultOperator.DisplayString());
if (diagnostics.DiagnosticSource.IsEnabled(definition.EventId.Name))
{
diagnostics.DiagnosticSource.Write(
definition.EventId.Name,
new IncludeEventData(
definition,
IncludeIgnoredWarning,
includeResultOperator));
}
}
private Action <TInclude> GetJoinDictionaryCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
var storage = _storage.StorageFor(typeof(TInclude));
var dictionary = (IDictionary <TKey, TInclude>)(queryProperty).GetValue(query);
if (dictionary == null)
{
queryProperty.SetValue(query, new Dictionary <TKey, TInclude>());
dictionary = (IDictionary <TKey, TInclude>)queryProperty.GetValue(query);
}
return(x => {
var id = storage.Identity(x).As <TKey>();
if (!dictionary.ContainsKey(id))
{
dictionary.Add(id, x);
}
});
}
private IIncludeJoin doGetJoin <TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, IIncludeCallbackResolver <TInclude> callbackResolver) where TInclude : class
{
var idSource = includeOperator.IdSource as Expression <Func <TDoc, object> >;
var joinType = (JoinType)includeOperator.JoinType.Value;
var visitor = new FindMembers();
visitor.Visit(idSource);
var members = visitor.Members.ToArray();
var mapping = _schema.MappingFor(typeof(TDoc)).ToQueryableDocument();
var typeContainer = new IncludeTypeContainer {
IncludeType = includeOperator.Callback.Body.Type
};
var property = typeof(IncludeResultOperator).GetProperty("Callback");
var callback = callbackResolver.Resolve(property, typeContainer);
var included = _schema.MappingFor(typeContainer.IncludeType).ToQueryableDocument();
return(mapping.JoinToInclude(joinType, included, members, callback));
}
private IIncludeJoin GetJoin <TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator) where TInclude : class
{
var resolver = new DefaultIncludeCallbackResolver <TInclude, TDoc, TOut>(query, includeOperator);
return(doGetJoin(query, includeOperator, resolver));
}
private IIncludeJoin GetDictionaryJoin <TKey, TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator) where TInclude : class
{
var resolver = new DictionaryIncludeCallbackResolver <TKey, TInclude, TDoc, TOut>(query, includeOperator, _schema);
return(doGetJoin <TInclude>(query, includeOperator, resolver));
}
public DefaultIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator)
{
_query = query;
_includeOperator = includeOperator;
}
public DictionaryIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, StorageFeatures storage)
{
_query = query;
_includeOperator = includeOperator;
_storage = storage;
}
private static Action <TInclude> GetJoinCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
return(x => queryProperty.SetValue(query, x));
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
resultOptionType = resultOptionType ?? queryModel.SelectClause.Selector.Type;
if (resultOperator is CastResultOperator)
{
CastResultOperator castResultOperator = (CastResultOperator)resultOperator;
Type castType = castResultOperator.CastItemType;
MethodInfo cast = GetMethod("Cast", expression.Type).MakeGenericMethod(castType);
resultOptionType = castType;
expression = Expression.Call(cast, expression);
return;
}
if (resultOperator is AllResultOperator)
{
AllResultOperator allResultOperator = (AllResultOperator)resultOperator;
ParameterExpression parameterExpression = Expression.Parameter(selectorType, "p");
Expression predicateUpdate = UpdateExpressionVisitor.Update(allResultOperator.Predicate, new[] { parameterExpression }, dbContext, queryContext);
Expression allLamda = Expression.Lambda(predicateUpdate, parameterExpression);
MethodInfo all = GetMethod("All", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(all, new[] { expression, allLamda });
return;
}
if (resultOperator is FirstResultOperator)
{
FirstResultOperator firstResultOperator = (FirstResultOperator)resultOperator;
if (firstResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo firstOrDefault = GetMethod("FirstOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(firstOrDefault, new[] { expression });
}
else
{
MethodInfo first = GetMethod("First", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(first, new[] { expression });
}
return;
}
if (resultOperator is SingleResultOperator)
{
SingleResultOperator singleResultOperator = (SingleResultOperator)resultOperator;
if (singleResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo firstOrDefault = GetMethod("SingleOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(firstOrDefault, new[] { expression });
}
else
{
MethodInfo first = GetMethod("Single", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(first, new[] { expression });
}
return;
}
if (resultOperator is AnyResultOperator)
{
MethodInfo any = GetMethod("Any", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(any, new[] { expression });
return;
}
if (resultOperator is TrackingResultOperator)
{
MethodInfo asNoTracking = typeof(EntityFrameworkQueryableExtensions).GetMethod("AsNoTracking").MakeGenericMethod(selectorType);
expression = Expression.Call(asNoTracking, new[] { expression });
return;
}
if (resultOperator is CountResultOperator)
{
MethodInfo count = GetMethod("Count", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(count, new[] { expression });
return;
}
if (resultOperator is AverageResultOperator)
{
MethodInfo average = GetAgregateMethod("Average", expression.Type, selectorType);
expression = Expression.Call(average, new[] { expression });
return;
}
if (resultOperator is ContainsResultOperator)
{
ContainsResultOperator containsResultOperator = (ContainsResultOperator)resultOperator;
Expression valExp;
object value;
ParameterExpression paramExp = containsResultOperator.Item as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
valExp = Expression.Constant(value);
}
else
{
valExp = containsResultOperator.Item;
}
if (containsResultOperator.Item is SubQueryExpression)
{
SubQueryExpression subQueryExpression = (SubQueryExpression)containsResultOperator.Item;
QueryModelVisitor queryModelVisitor = new QueryModelVisitor(dbContext, queryContext);
queryModelVisitor.VisitQueryModel(subQueryExpression.QueryModel);
valExp = queryModelVisitor.expression;
}
MethodInfo contains = GetMethod("Contains", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(contains, new[] { expression, valExp });
return;
}
if (resultOperator is DefaultIfEmptyResultOperator)
{
DefaultIfEmptyResultOperator defaultIfEmptyResultOperator = (DefaultIfEmptyResultOperator)resultOperator;
MethodInfo defaultIfEmpty;
if (defaultIfEmptyResultOperator.OptionalDefaultValue != null)
{
defaultIfEmpty = GetMethod("DefaultIfEmpty", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(defaultIfEmpty, new[] { expression, defaultIfEmptyResultOperator.OptionalDefaultValue });
}
defaultIfEmpty = GetMethod("DefaultIfEmpty", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(defaultIfEmpty, expression);
return;
}
if (resultOperator is DistinctResultOperator)
{
MethodInfo distinct = GetMethod("Distinct", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(distinct, expression);
return;
}
if (resultOperator is GroupResultOperator)
{
GroupResultOperator groupResultOperator = (GroupResultOperator)resultOperator;
Type keySelectorType = GetTypeParameter(groupResultOperator.KeySelector);
ParameterExpression keyExpressionParam = Expression.Parameter(keySelectorType, "p");
Expression keyExpression = UpdateExpressionVisitor.Update(groupResultOperator.KeySelector, new[] { keyExpressionParam }, dbContext, queryContext);
LambdaExpression keyLambdaExpression = Expression.Lambda(keyExpression, keyExpressionParam);
Type elementSelectorType = GetTypeParameter(groupResultOperator.ElementSelector);
ParameterExpression ElementExpressionParam = Expression.Parameter(elementSelectorType, "p");
Expression ElementExpression = UpdateExpressionVisitor.Update(groupResultOperator.ElementSelector, new[] { ElementExpressionParam }, dbContext, queryContext);
LambdaExpression ElementLambdaExpression = Expression.Lambda(ElementExpression, ElementExpressionParam);
Type tSource = queryModel.MainFromClause.ItemType;
Type tKey = keyExpression.Type;
Type tElement = ElementExpression.Type;
Type tResult = queryModel.ResultTypeOverride;
MethodInfo groupBy = GetMethods("GroupBy", expression.Type, 2).Where(p => p.GetParameters()[2].Name == "elementSelector").Single().
MakeGenericMethod(tSource, tKey, tElement);
expression = Expression.Call(groupBy, new[] { expression, keyLambdaExpression, ElementLambdaExpression });
return;
}
if (resultOperator is LastResultOperator)
{
LastResultOperator lastResultOperator = (LastResultOperator)resultOperator;
if (lastResultOperator.ReturnDefaultWhenEmpty)
{
MethodInfo lastOrDefault = GetMethod("LastOrDefault", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(lastOrDefault, new[] { expression });
}
else
{
MethodInfo last = GetMethod("Last", expression.Type, 0).MakeGenericMethod(selectorType);
expression = Expression.Call(last, new[] { expression });
}
return;
}
if (resultOperator is LongCountResultOperator)
{
MethodInfo longCount = GetMethod("LongCount", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(longCount, new[] { expression });
return;
}
if (resultOperator is MaxResultOperator)
{
MethodInfo max = GetMethod("Max", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(max, expression);
return;
}
if (resultOperator is MinResultOperator)
{
MethodInfo min = GetMethod("Min", expression.Type).MakeGenericMethod(selectorType);
expression = Expression.Call(min, expression);
return;
}
if (resultOperator is SumResultOperator)
{
MethodInfo sum = GetAgregateMethod("Sum", expression.Type, selectorType);
expression = Expression.Call(sum, expression);
return;
}
if (resultOperator is SkipResultOperator)
{
SkipResultOperator skipResultOperator = (SkipResultOperator)resultOperator;
Expression expVal;
object value;
ParameterExpression paramExp = skipResultOperator.Count as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
expVal = Expression.Constant(value);
}
else
{
expVal = skipResultOperator.Count;
}
MethodInfo skip = GetMethod("Skip", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(skip, new[] { expression, expVal });
return;
}
if (resultOperator is TakeResultOperator)
{
TakeResultOperator takeResultOperator = (TakeResultOperator)resultOperator;
Expression expVal;
object value;
ParameterExpression paramExp = takeResultOperator.Count as ParameterExpression;
if (paramExp != null &&
queryContext.ParameterValues.TryGetValue(paramExp.Name, out value))
{
expVal = Expression.Constant(value);
}
else
{
expVal = takeResultOperator.Count;
}
MethodInfo take = GetMethod("Take", expression.Type, 1).MakeGenericMethod(selectorType);
expression = Expression.Call(take, new[] { expression, expVal });
return;
}
if (resultOperator is IncludeResultOperator)
{
IncludeResultOperator includeResultOperator = (IncludeResultOperator)resultOperator;
Expression includeExpression = includeResultOperator.NavigationPropertyPath;
Type paramExpressionType = null;
ParameterExpression parameterExpression = null;
if (includeExpression is MemberExpression)
{
MemberExpression memberExpression = (MemberExpression)includeExpression;
paramExpressionType = memberExpression.Expression.Type;
parameterExpression = Expression.Parameter(paramExpressionType, "p");
includeExpression = Expression.Property(parameterExpression, memberExpression.Member.Name);
}
else
{
paramExpressionType = GetTypeParameter(includeExpression);
parameterExpression = Expression.Parameter(paramExpressionType, "p");
}
Expression updateOuterExpression = UpdateExpressionVisitor.Update(includeExpression, new[] { parameterExpression }, dbContext, queryContext);
LambdaExpression lambdaIncludeExpression = Expression.Lambda(updateOuterExpression, parameterExpression);
MethodInfo include = typeof(EntityFrameworkQueryableExtensions).GetMethods().First(m => m.Name == "Include").MakeGenericMethod(selectorType, updateOuterExpression.Type);
expression = Expression.Call(include, new[] { expression, lambdaIncludeExpression });
if (includeResultOperator.ChainedNavigationProperties != null)
{
foreach (PropertyInfo propertyInfo in includeResultOperator.ChainedNavigationProperties)
{
Type propertyType = propertyInfo.PropertyType;
Type argument = expression.Type.GetGenericArguments().Last();
MethodInfo thenInclude;
Type realType;
if (typeof(IEnumerable).IsAssignableFrom(argument))
{
realType = argument.GetGenericArguments().First();
thenInclude = ThenIncludeCollection.MakeGenericMethod(includeResultOperator.QuerySource.ItemType, realType, propertyType);
}
else
{
realType = argument;
thenInclude = ThenIncludeProperty.MakeGenericMethod(includeResultOperator.QuerySource.ItemType, realType, propertyType);
}
ParameterExpression parameterThenIncludeExpression = Expression.Parameter(realType, "p");
MemberExpression property = Expression.Property(parameterThenIncludeExpression, propertyInfo);
LambdaExpression lambdaThenIncludeExpression = Expression.Lambda(property, parameterThenIncludeExpression);
expression = Expression.Call(thenInclude, new[] { expression, lambdaThenIncludeExpression });
}
}
return;
}
if (resultOperator is OfTypeResultOperator)
{
OfTypeResultOperator ofTypeResultOperator = (OfTypeResultOperator)resultOperator;
selectorType = ofTypeResultOperator.SearchedItemType;
var miOfType = GetMethod("OfType", expression.Type).MakeGenericMethod(ofTypeResultOperator.SearchedItemType);
expression = Expression.Call(miOfType, new[] { expression });
return;
}
throw new NotSupportedException();
}
public DictionaryIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, IDocumentSchema schema)
{
_query = query;
_includeOperator = includeOperator;
_schema = schema;
}
/// <summary>
/// Copied from EntityFramework Core source code
/// </summary>
private IEnumerable <INavigation> BindChainedNavigations(IEnumerable <INavigation> boundNavigations, IncludeResultOperator includeResultOperator)
{
var boundNavigationsList = boundNavigations.ToList();
if (includeResultOperator.ChainedNavigationProperties != null)
{
foreach (var propertyInfo in includeResultOperator.ChainedNavigationProperties)
{
var lastNavigation = boundNavigationsList.Last();
var navigation = lastNavigation.GetTargetType().FindNavigation(propertyInfo.Name);
if (navigation == null)
{
return(null);
}
boundNavigationsList.Add(navigation);
}
}
var replaced = includeResultOperator as ReplaceIncludeResultOperator;
if (replaced != null)
{
// match expressions to navigation
foreach (var navigation in boundNavigationsList)
{
var name = $"{navigation.DeclaringEntityType.Name}-{navigation.Name}";
HashSet <Expression> expressions;
if (replaced.Expressions.TryGetValue(name, out expressions))
{
this.ExpressionCollection.AddOrUpdate(navigation, expressions);
}
}
}
return(boundNavigationsList);
}
