Je construis une requête avec la bibliothèque dynamique Linq, donc je ne sais pas combien de paramètres potentiels aurai-je et que je reçois une erreur lors de la recherche de champs de type de date:
opérateur '> = 'Incompatible avec les types d'opérande' DateTime 'et' String ' Strong> P> Lorsque je passe à travers le débogueur dans la dynamic.cs, il montre que la valeur est de type chaîne et que le champ est de type date de type. Donc, le problème est évident mais je n'ai aucune idée de la façon de l'approcher. P> Toute idée? P> BR P> Code: P> using (MyEntities db = new MyEntities())
{
String SQLparam = "CreateDate >= \"" + DateTime.Now.ToShortDateString() + "\"";
List<UserList> UserList = db.UserList.Where(SQLparam).ToList();
}
4 Réponses :
Vous devez utiliser une requête paramétrée, par exemple
Et si vous ne savez pas combien de paramètres potentiels y aura-t-il?
Ensuite, vous construisez la matrice au fur et à mesure. Ce n'est pas difficile.
J'étais dans le même bateau et j'ai pu résoudre ceci en changeant une méthode dans la bibliothèque dynamique. C'est un piratage, mais cela me permet d'utiliser des dates dans des expressions avec des opérateurs d'égalité (=,>, Je poste le code ici au cas où quelqu'un se soucie toujours. Le code vérifie essentiellement si vous essayez de comparer un champ de date (à gauche) avec une chaîne (à droite). Et ensuite, il convertit la bonne expression à une constante de date p> Voici toute la méthode Parsecomparison: P>
Le code que j'ai ajouté est dans le bloc IF autour de la ligne 53 p> // =, ==, !=, <>, >, >=, <, <= operators
Expression ParseComparison()
{
Expression left = ParseAdditive();
while (token.id == TokenId.Equal || token.id == TokenId.DoubleEqual ||
token.id == TokenId.ExclamationEqual || token.id == TokenId.LessGreater ||
token.id == TokenId.GreaterThan || token.id == TokenId.GreaterThanEqual ||
token.id == TokenId.LessThan || token.id == TokenId.LessThanEqual)
{
Token op = token;
NextToken();
Expression right = ParseAdditive();
bool isEquality = op.id == TokenId.Equal || op.id == TokenId.DoubleEqual ||
op.id == TokenId.ExclamationEqual || op.id == TokenId.LessGreater;
if (isEquality && !left.Type.IsValueType && !right.Type.IsValueType)
{
if (left.Type != right.Type)
{
if (left.Type.IsAssignableFrom(right.Type))
{
right = Expression.Convert(right, left.Type);
}
else if (right.Type.IsAssignableFrom(left.Type))
{
left = Expression.Convert(left, right.Type);
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
}
else if (IsEnumType(left.Type) || IsEnumType(right.Type))
{
if (left.Type != right.Type)
{
Expression e;
if ((e = PromoteExpression(right, left.Type, true)) != null)
{
right = e;
}
else if ((e = PromoteExpression(left, right.Type, true)) != null)
{
left = e;
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
}
else if (left.Type == typeof(DateTime) && right.Type == typeof(string))
{
if (right is ConstantExpression)
{
DateTime datevalue;
string value = ((ConstantExpression) right).Value.ToString();
if (DateTime.TryParse(value, out datevalue))
{
right = Expression.Constant(datevalue);
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
else
{
CheckAndPromoteOperands(isEquality ? typeof(IEqualitySignatures) : typeof(IRelationalSignatures),
op.text, ref left, ref right, op.pos);
}
switch (op.id)
{
case TokenId.Equal:
case TokenId.DoubleEqual:
left = GenerateEqual(left, right);
break;
case TokenId.ExclamationEqual:
case TokenId.LessGreater:
left = GenerateNotEqual(left, right);
break;
case TokenId.GreaterThan:
left = GenerateGreaterThan(left, right);
break;
case TokenId.GreaterThanEqual:
left = GenerateGreaterThanEqual(left, right);
break;
case TokenId.LessThan:
left = GenerateLessThan(left, right);
break;
case TokenId.LessThanEqual:
left = GenerateLessThanEqual(left, right);
break;
}
}
return left;
}
Parce que je devais faire une comparaison d'une date d'heure? et j'avais fait cette modification.
else if (left.Type == typeof(DateTime?) && right.Type == typeof(string))
{
if (right is ConstantExpression)
{
DateTime datevalue;
string value = ((ConstantExpression)right).Value.ToString();
if (DateTime.TryParse(value, out datevalue))
{
DateTime? nullableDateValue = datevalue;
right = Expression.Constant(nullableDateValue, typeof(DateTime?));
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
else
{
throw IncompatibleOperandsError(op.text, left, right, op.pos);
}
}
Mike avez-vous déjà eu à faire une comparaison avec juste la partie de date de l'objet DateTime? Essayer de le faire pour le moment contre un objet d'entité de cadre d'entité. Ont essayé de modifier le code Dynamic Linq pour utiliser myProperty.value.date à l'aide de la réflexion mais pas de go j'ai peur. Idéalement, j'aimerais qu'il crée une lambda comme p => p.mydatetimeproperty.value.date == "2012/08/01 / plutôt que p => p.mydatetimeproperty ==" 2012/08/01 ". Toute idée sur Celui-ci serait très apprécié.
J'ai eu le même problème, mais avec Boolean aussi, j'ai aussi généralisé la solution les lignes de la fonction principale, puis deviennent ... Seul désavantage que je peux voir à cette approche, c'est que si l'analyse échoue, nous émettrons et exceptionnellement, mais étant donné que nous enlevons un de toute façon, je ne vois pas que cela importe trop
Je pense que nous devons voir un peu de ce que votre code fait - je ne pense pas que nous en savons suffisamment pour répondre sans beaucoup d'hypothèses et de suppositions