J'essaie de sélectionner les champs qui commencent par quelque chose en utilisant la bibliothèque de requêtes dynamique, je suis limité à utiliser le nom de la colonne et les champs pour être dans des variables. J'ai essayé:
var x = myqueriable.Where("" + X1 + " LIKE @0 and " + X2 + "= @1 ", Y1 + "%", Y2);
J'ai l'erreur: "system.Linq.Dynamic.ParseException: Expression de type Boolean attendue>
Existe-t-il un moyen d'accomplir ce qui est mentionné?
3 Réponses :
var x = myQueryable.Where(y => y.StartsWith(param0));
Les réponses basées uniquement sur le code sont de mauvaises réponses. Veuillez ajouter une explication pour pourquoi votre solution résout le problème.
Je veux dire, sa question était une ligne de code. J'ai posté la syntaxe correcte. Cela fonctionne parce que, c'est ... non? Je ne sais pas. C'est la bonne façon de procéder. Cela fonctionne parce que c'est comme ça.
Pourquoi avez-vous décidé que myqueriable est IQueryable? De la question: sélectionnez les champs qui commencent par . La question est également marquée avec la balise dynamic-linq , donc je pense que myQueryable est IQueryable et X est un nom de propriété. Je ne suis pas sûr alors j'ai demandé à OP dans les commentaires
merci pour votre tentative @Jon, mais je n'ai pas le champ à sélectionner, il est stocké dans les variables X1 et X2
Désolé, j'ai mal compris la question, je n'ai pas vu que vous utilisiez Dynamic LINQ
Vous devez créer une expression lambda dynamique comme
var x = myqueriable.Where(myqueriable.BuildLambda(X, Y))
Vous pouvez le faire sans bibliothèques externes en utilisant l'API Expressions intégrée. Voir cette méthode d'extension:
public static class QueryableExt
{
public static Expression<Func<T, bool>> BuildLambda<T>(this IQueryable<T> input, string propertyName, string startsWith)
{
var elemenType = input.ElementType;
var property = elemenType.GetProperty(propertyName);
if (property == null)
throw new ArgumentException($"There is no property {propertyName} in {elemenType.Name}");
if (property.PropertyType != typeof(string))
throw new ArgumentException($"Expected string property but actual type is {property.PropertyType.Name}");
var startsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
var p = Expression.Parameter(elemenType, "p"); // p => ...
var memberExpression = Expression.Property(p, property); // ... p.Propery
var startsWithValue = Expression.Constant(startsWith); // "some prefix"
var startsWithExpression = Expression.Call(memberExpression, startsWithMethod, startsWithValue); // ... p.Property.StartsWith("some prefix")
var result = Expression.Lambda<Func<T, bool>>(startsWithExpression, p); // p => p.Property.StartsWith("some prefix")
return result;
}
}
Veuillez noter que BuildLambda est plus sûr de type que de simples concaténations de chaînes: cette méthode vérifie effectivement que propertyName existe et a un type valide. Vous pouvez maintenant l'utiliser comme
p => p.Property.StartsWith("some prefix");
Lorsque vous utilisez System.Linq.Dynamic.Core , vous devriez pouvoir pour utiliser StartsWith () .
Exemple de code:
-- Region Parameters DECLARE @p0 NVarChar(1000) = 'x%' -- EndRegion SELECT [t0].[Id], [t0].[Url], [t0].[Rating] FROM [Entity1] AS [t0] WHERE [t0].[Url] LIKE @p0
Ceci est traduit en SQL comme:
var result = Entity1s.Where("Url.StartsWith(\"x\")");
Donc
Xest un nom de propriété etYest une valeur avec laquelle comparer?oui ils sont @Aleks
Saisissez simplement le filtre du type interrogeable
désolé, mais je ne sais pas ce que vous entendez par saisir le filtre.