Le type apparaît dans les deux structurellement incompatible initialisations au sein d'une seule requête LINQ to entities

Je ne sais pas pourquoi EF a une telle exigence, mais la chose importante est que l'obligation existe et nous devons le prendre en compte.

Le premier code fonctionne car true est un compiler constante de temps, de sorte que le compilateur est à régler au moment de la compilation, de se retrouver avec l'un des deux expressions (essentiellement de retirer l'opérateur ternaire). Alors que dans le second cas, c'est un variable, donc, l'expression de l'arbre contient l'expression d'origine et échoue au moment de l'exécution en raison susmentionnée EF exigence.

Il y a un moment que je cherchais à résoudre ce type de problèmes (pour être honnête, principalement pour la dynamique where filtres) par la mise en œuvre d'une méthode personnalisée qui est d'essayer de résoudre le bool variables, ce qui fait au moment de l'exécution de quelque chose de similaire à ce que fait le compilateur dans le premier cas. Bien sûr, le code est expérimental et n'est pas testé, mais semble gérer correctement de tels scénarios, de sorte que vous pouvez lui donner un essai. L'utilisation est assez simple:

var eventData = dbContext.Event.Select(t => new
    {
        Address = includeAddress ? new AnonymousEventGetAddress
        {
            AddressLine1 = t.Address.AddressLine1,
            CityName = t.Address.AddressCityName
        } : new AnonymousEventGetAddress(),
    }).ReduceConstPredicates();

Et ici est la méthode d'assistance utilisés:

public static partial class QueryableExtensions
{
public static IQueryable<T> ReduceConstPredicates<T>(this IQueryable<T> source)
{
var visitor = new ConstPredicateReducer();
var expression = visitor.Visit(source.Expression);
if (expression != source.Expression)
return source.Provider.CreateQuery<T>(expression);
return source;
}
class ConstPredicateReducer : ExpressionVisitor
{
int evaluateConst;
private ConstantExpression TryEvaluateConst(Expression node)
{
evaluateConst++;
try { return Visit(node) as ConstantExpression; }
finally { evaluateConst--; }
}
protected override Expression VisitConditional(ConditionalExpression node)
{
var testConst = TryEvaluateConst(node.Test);
if (testConst != null)
return Visit((bool)testConst.Value ? node.IfTrue : node.IfFalse);
return base.VisitConditional(node);
}
protected override Expression VisitBinary(BinaryExpression node)
{
if (node.Type == typeof(bool))
{
var leftConst = TryEvaluateConst(node.Left);
var rightConst = TryEvaluateConst(node.Right);
if (leftConst != null || rightConst != null)
{
if (node.NodeType == ExpressionType.AndAlso)
{
if (leftConst != null) return (bool)leftConst.Value ? (rightConst ?? Visit(node.Right)) : Expression.Constant(false);
return (bool)rightConst.Value ? Visit(node.Left) : Expression.Constant(false);
}
else if (node.NodeType == ExpressionType.OrElse)
{
if (leftConst != null) return !(bool)leftConst.Value ? (rightConst ?? Visit(node.Right)) : Expression.Constant(true);
return !(bool)rightConst.Value ? Visit(node.Left) : Expression.Constant(true);
}
else if (leftConst != null && rightConst != null)
{
var result = Expression.Lambda<Func<bool>>(Expression.MakeBinary(node.NodeType, leftConst, rightConst)).Compile().Invoke();
return Expression.Constant(result);
}
}
}
return base.VisitBinary(node);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (evaluateConst > 0)
{
var objectConst = node.Object != null ? TryEvaluateConst(node.Object) : null;
if (node.Object == null || objectConst != null)
{
var arguments = new object[node.Arguments.Count];
bool canEvaluate = true;
for (int i = 0; i < arguments.Length; i++)
{
var argumentConst = TryEvaluateConst(node.Arguments[i]);
if (canEvaluate = (argumentConst != null))
arguments[i] = argumentConst.Value;
else
break;
}
if (canEvaluate)
{
var result = node.Method.Invoke(objectConst != null ? objectConst.Value : null, arguments);
return Expression.Constant(result, node.Type);
}
}
}
return base.VisitMethodCall(node);
}
protected override Expression VisitUnary(UnaryExpression node)
{
if (evaluateConst > 0 && (node.NodeType == ExpressionType.Convert || node.NodeType == ExpressionType.ConvertChecked))
{
var operandConst = TryEvaluateConst(node.Operand);
if (operandConst != null)
{
var result = Expression.Lambda(node.Update(operandConst)).Compile().DynamicInvoke();
return Expression.Constant(result, node.Type);
}
}
return base.VisitUnary(node);
}
protected override Expression VisitMember(MemberExpression node)
{
object value;
if (evaluateConst > 0 && TryGetValue(node, out value))
return Expression.Constant(value, node.Type);
return base.VisitMember(node);
}
static bool TryGetValue(MemberExpression me, out object value)
{
object source = null;
if (me.Expression != null)
{
if (me.Expression.NodeType == ExpressionType.Constant)
source = ((ConstantExpression)me.Expression).Value;
else if (me.Expression.NodeType != ExpressionType.MemberAccess
|| !TryGetValue((MemberExpression)me.Expression, out source))
{
value = null;
return false;
}
}
if (me.Member is PropertyInfo)
value = ((PropertyInfo)me.Member).GetValue(source);
else
value = ((FieldInfo)me.Member).GetValue(source);
return true;
}
}
}

OriginalL'auteur Ivan Stoev

À mon avis, j'essaie toujours de se tenir à l'écart de mettre quelque chose de plus compliqué alors la sélection de données dans IQueryable parce qu'ils sont Expression, ce qui signifie qu'ils ne sont jamais exécutées - ils sont compilés.

Je souhaite donc s'attaquer à ce problème, comme si (ce qui a un bel air de simplicité autour d'elle):

Créer un DTO pour le retour des données:

public class EventDto
{
//some properties here that you need
public Address Address {get;set;}
}

Alors je voudrais diviser votre logique autour de l' includeAddress

public IEnumerable<EventDto> IncludeAddress(DbContext dbContext)
{
return dbContext.Event.Select(t => new
{
//select out your other properties here
Address = new
{
AddressLine1 = t.Address.AddressLine1,
CityName = t.Address.AddressCityName
},
}).ToList().Select(x => new EventDto { Address = Address });
//put what ever mapping logic you have up there, whether you use AutoMapper or hand map it doesn't matter.
}

La méthode NoAddress ou ce que vous voulez l'appeler, il va ressembler, mais avec pas de Address, et vous carte il.

Vous pouvez ensuite choisir simplement:

var eventDtos = new List<EventDto>();
if (includeAddress)
eventDtos.AddRange(this.IncludeAddress(dbContext));
else
eventDtos.AddRange(this.NoAddress(dbContext));
eventDtos.ForEach(e => { if (e.Address == null) e.Address = new Address(); });

Si vous Select ne ont beaucoup de logique, puis je envisager de déplacer dans une procédure stockée, d'où il sera plus facile à lire le SQL.

Évidemment, c'est juste un guide, vous donne une idée sur la façon d'aborder le problème.

OriginalL'auteur Callum Linington

J'ai eu le même problème et trouvé la solution, pour ajouter .ToList() , avant le select-fonction :

var eventData = dbContext.Event.ToList().Select(t => new
{
Address = includeAddress ? new AnonymousEventGetAddress
{
AddressLine1 = t.Address.AddressLine1,
CityName = t.Address.AddressCityName
} : new AnonymousEventGetAddress(),
});

OriginalL'auteur JorgenV