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));
}
