private Expression BuildQueryBody(ParameterExpression parameterExpression, List <string> selectedValues) { if (selectedValues.Count == 0) { // If no subexpressions were contributed, return a false contstant expression to prevent // anything from showing up return(Expression.Constant(false)); } else { List <Expression> orFragments = new List <Expression>(); foreach (string serializedValue in selectedValues) { Dictionary <string, object> dict = new Dictionary <string, object>(); Column.ExtractForeignKey(dict, serializedValue); List <Expression> andFragments = new List <Expression>(); foreach (var entry in dict) { Expression property = LinqExpressionHelper.CreatePropertyExpression(parameterExpression, entry.Key); object value = Convert.ChangeType(entry.Value, LinqExpressionHelper.GetUnderlyingType(property.Type)); Expression equalsExpression = Expression.Equal(property, Expression.Constant(value, property.Type)); andFragments.Add(equalsExpression); } var expr = LinqExpressionHelper.Join(andFragments, Expression.AndAlso); orFragments.Add(expr); } return(LinqExpressionHelper.Join(orFragments, Expression.OrElse)); } }
void IQueryVisitor.Visit(FilteringDescriptor filter) { // The member you want to evaluate (x => x.FirstName) Expression member = LinqExpressionHelper.GetMemberChainExpression(_param, filter.Field); // The value you want to evaluate Expression constant = Expression.Constant(filter.Criterion); if (filter.IgnoreCase && filter.Criterion is string) { member = Expression.Call(Expression.Coalesce(member, LinqProviderStatic.EmptyStr), LinqProviderStatic.ToUpper); constant = Expression.Constant(string.IsNullOrEmpty((string)filter.Criterion) ? string.Empty : (string)filter.Criterion); constant = Expression.Call(constant, LinqProviderStatic.ToUpper); } // Determine how we want to apply the expression switch (filter.Predicate) { case CriterionPredicate.Eq: case CriterionPredicate.Null: _expression = Expression.Equal(member, constant); break; case CriterionPredicate.Neq: case CriterionPredicate.NotNull: _expression = Expression.NotEqual(member, constant); break; case CriterionPredicate.Gt: _expression = Expression.GreaterThan(member, constant); break; case CriterionPredicate.GtEq: _expression = Expression.GreaterThanOrEqual(member, constant); break; case CriterionPredicate.Lt: _expression = Expression.LessThan(member, constant); break; case CriterionPredicate.LtEq: _expression = Expression.LessThanOrEqual(member, constant); break; case CriterionPredicate.Contains: //return Expression.AndAlso(Expression.NotEqual(member, Expression.Constant(null)), //Expression.Call(member, PaggedLinqBaseStatics.ContainsMethod, constant)); _expression = Expression.Call(Expression.Coalesce(member, LinqProviderStatic.EmptyStr), LinqProviderStatic.ContainsMethod, constant); break; case CriterionPredicate.StartsWith: _expression = Expression.Call(Expression.Coalesce(member, LinqProviderStatic.EmptyStr), LinqProviderStatic.StartsWithMethod, constant); break; case CriterionPredicate.EndsWith: _expression = Expression.Call(Expression.Coalesce(member, LinqProviderStatic.EmptyStr), LinqProviderStatic.EndsWithMethod, constant); break; } }
private Expression BuildQueryBody(ParameterExpression parameterExpression) { Expression propertyExpression = LinqExpressionHelper.GetValue(LinqExpressionHelper.CreatePropertyExpression(parameterExpression, Column.Name)); TypeConverter converter = TypeDescriptor.GetConverter(Column.ColumnType); BinaryExpression greaterThanExpression = BuildCompareExpression(propertyExpression, converter.ConvertFromString(DateFrom), Expression.GreaterThanOrEqual); return(greaterThanExpression); }
public static SortingDescriptor Get <TEntity>(Expression <Func <TEntity, object> > memberSelector, bool desc) { return(new SortingDescriptor { Field = LinqExpressionHelper.GetMembersChain(memberSelector), Desc = desc }); }
static NewExpression MutateNew(NewExpression node, IList <Expression> operands) { Type[] types = node.Members == null?node.Constructor.GetParameters().Select(p => p.ParameterType).ToArray() : node.Members.Select(m => m.GetMemberReturnType()).ToArray(); for (int i = 0; i < operands.Count; i++) { operands[i] = LinqExpressionHelper.CheckNeedConvert(operands[i], types[i]); } return(node.Update(operands)); }
public static FilteringDescriptor Get <TEntity>( Expression <Func <TEntity, object> > memberSelector, object criterion, CriterionPredicate predicate = CriterionPredicate.Eq, bool ignoreCase = false) { return(new FilteringDescriptor() { Field = LinqExpressionHelper.GetMembersChain(memberSelector), Predicate = predicate, Criterion = criterion, IgnoreCase = ignoreCase }); }
private static void Main(string[] args) { var enumCollection = new List <StoreType> { StoreType.Children, StoreType.Farm }; var repo = new StoreRepository(); var enumFilter = LinqExpressionHelper.BuildEnumFilter(enumCollection); var result = repo.GetStores().Where(enumFilter).ToList(); foreach (var store in result) { Console.WriteLine($"Name={store.Name}, Type={store.StoreType}"); } Console.ReadKey(); }
void IQueryVisitor.Visit(SortingDescriptor sd) { Validator.ValidatePropertyName <T>(sd.Field); string ordAsc = _isFirstItem ? "OrderBy" : "ThenBy"; string ordDesc = _isFirstItem ? "OrderByDescending" : "ThenByDescending"; _isFirstItem = false; Expression propertyAccess = LinqExpressionHelper.GetMemberChainExpression(_param, sd.Field); LambdaExpression orderByExp = Expression.Lambda(propertyAccess, _param); MethodCallExpression resultExp = Expression.Call(typeof(Queryable), sd.Desc ? ordDesc : ordAsc, new[] { _t, propertyAccess.Type }, _query.Expression, Expression.Quote(orderByExp)); _query = _query.Provider.CreateQuery <T>(resultExp); }
public static IQueryable <T> GetById <T>(this IQueryable <T> query, long id) { var propertyInfo = typeof(T).GetProperty("Id"); if (propertyInfo == null || propertyInfo.PropertyType != typeof(long)) { throw new ArgumentException(); } var parameter = Expression.Parameter(typeof(T), "x"); var property = Expression.Property(parameter, propertyInfo); var constant = LinqExpressionHelper.ParametrizeConstant(id, typeof(long)); var equals = Expression.Equal(property, constant); var lambda = Expression.Lambda <Func <T, bool> >(equals, parameter); return(query.Where(lambda)); }
public override IQueryable GetQueryable(IQueryable source) { if (String.IsNullOrEmpty(TextBox1.Text)) { return(source); } object value = TextBox1.Text; if (DefaultValues != null) { DefaultValues[Column.Name] = value; } var whereCall = LinqExpressionHelper.BuildCustomQuery(source, Column.Table, Column, TextBox1.Text, QueryType.EndsWith); return(source.Provider.CreateQuery(whereCall)); }
public void GetMemberChainExpression() { var param = Expression.Parameter(typeof(Client), "parm"); var expr = LinqExpressionHelper.GetMemberChainExpression(param, "Referer.Address.Zip"); var c = new Client() { Referer = new Referer() { Address = new Address2() { Zip = 121108 } } }; Assert.AreEqual(121108, Expression.Lambda <Func <Client, int> >(expr, param).Compile()(c)); }
protected void Page_Init(object sender, EventArgs e) { var fkColumn = Column as MetaForeignKeyColumn; //// dynamically build the context key so the web service knows which table we're talking about //autoComplete1.ContextKey = fkColumn.ParentTable.Provider.DataModel.ContextType.FullName + "#" + fkColumn.ParentTable.Name; autoComplete1.ContextKey = AutocompleteFilterService.GetContextKey(fkColumn.ParentTable); // add JavaScript to create post-back when user selects an item in the list var method = "function(source, eventArgs) {\r\n" + "var valueField = document.getElementById('" + AutocompleteValue.ClientID + "');\r\n" + "valueField.value = eventArgs.get_value();\r\n" + "setTimeout('" + Page.ClientScript.GetPostBackEventReference(AutocompleteTextBox, null).Replace("'", "\\'") + "', 0);\r\n" + "}"; autoComplete1.OnClientItemSelected = method; // modify behaviorID so it does not clash with other autocomplete extenders on the page autoComplete1.Animations = autoComplete1.Animations.Replace(autoComplete1.BehaviorID, AutocompleteTextBox.UniqueID); autoComplete1.BehaviorID = AutocompleteTextBox.UniqueID; if (!Page.IsPostBack && !String.IsNullOrEmpty(DefaultValue)) { // set the initial value of the filter if it's present in the request URL MetaTable parentTable = fkColumn.ParentTable; IQueryable query = parentTable.GetQuery(); // multi-column PK values are separated by commas var singleCall = LinqExpressionHelper.BuildSingleItemQuery(query, parentTable, DefaultValue.Split(',')); var row = query.Provider.Execute(singleCall); string display = parentTable.GetDisplayString(row); AutocompleteTextBox.Text = display; AutocompleteValue.Value = DefaultValue; } AutocompleteTextBox.ToolTip = this.AppRelativeVirtualPath.GetFileNameTitle(); }
public void GetMembersChain() { Assert.AreEqual("Referer.Address.Zip", LinqExpressionHelper.GetMembersChain((Client c) => c.Referer.Address.Zip)); Assert.AreEqual("Referer.Address.Zip", LinqExpressionHelper.GetMembersChain <Client>(c => c.Referer.Address.Zip)); }