public void SetUp ()
{
_leftExpression = Expression.Constant (1);
_rightExpression = Expression.Constant (2);
_expression = new SqlInExpression (_leftExpression, _rightExpression);
}
public override Expression VisitConstant(ConstantExpression expression)
{
this.type = expression.Type;
this.value = expression.Value;
return expression;
}
public void SetUp ()
{
_stringExpression = Expression.Constant (0);
_stringSequence = new[] { "a", "b", "c" };
_dataWithCovariantSequence = new StreamedSequence (_stringSequence, new StreamedSequenceInfo (typeof (object[]), _stringExpression));
}
internal static Expression Replace(Expression expressionToAlter,
ConstantExpression subExpressionToFind, Expression replacementExpression)
{
var visitor = new SubExpressionReplacer(subExpressionToFind, replacementExpression);
return visitor.Visit(expressionToAlter);
}
protected override Expression VisitConstant(ConstantExpression c)
{
if (c.Type == typeof(MethodInfo))
_methodInfo = c.Value as MethodInfo;
return base.VisitConstant(c);
}
protected override Expression VisitConstant(ConstantExpression c)
{
if (c.Type == typeof(JournalItemsContext<UAutoContractJournalItem>))
return Expression.Constant(this.queryableJournalItems);
else
return c;
}
protected override Expression VisitConstant(ConstantExpression c) {
if (c.Value is string)
sb.AppendFormat("\"{0}\"", c.Value);
else
sb.Append(c.Value.ToString());
return c;
}
public override void SetUp ()
{
base.SetUp ();
_defaultValue = Expression.Constant (100);
_nodeWithDefaultValue = new DefaultIfEmptyExpressionNode (CreateParseInfo (), _defaultValue);
_nodeWithoutDefaultValue = new DefaultIfEmptyExpressionNode (CreateParseInfo (), null);
}
protected override Expression VisitConstant(ConstantExpression c)
{
IQueryable q = c.Value as IQueryable;
if (q != null) {
//throw new ApplicationException("Nested expressions not supported.");
}
else if (c.Value == null) {
sb.Append("null");
}
else {
if (c.Value.GetType() == typeof(Guid)) {
sb.Append("'");
sb.Append(c.Value);
sb.Append("'");
}
else {
switch (Type.GetTypeCode(c.Value.GetType())) {
case TypeCode.DateTime:
sb.Append("'");
sb.Append(((DateTime)c.Value).ToString("o"));
sb.Append("'");
break;
case TypeCode.Object:
throw new NotSupportedException(string.Format("The constant for '{0}' is not supported SimpleDB.", c.Value));
default:
sb.Append("'");
sb.Append(c.Value);
sb.Append("'");
break;
}
}
}
return c;
}
protected override Expression VisitConstant(ConstantExpression node)
{
var value = node.Value as int?;
if (value.HasValue)
return Expression.Constant(value + 1, node.Type);
return base.VisitConstant(node);
}
protected override void establish_context()
{
base.establish_context();
expression = Expression.Constant(this);
rewriter = MockRepository.GenerateStub<IExpressionRewriter>();
system_under_test.AddRewriter(rewriter);
}
protected virtual NamedValueExpression CreateNamedValueForConstant(ConstantExpression expression)
{
var name = "p" + (iParam++);
var nv = new NamedValueExpression(name, expression);
map.Add(GetKeyNameForConstantExpression(expression), new List<NamedValueExpression> { nv });
return nv;
}
private static object EvaluateMemberAccessProperty(ConstantExpression node, PropertyInfo propertyAccessor)
{
var prop = node == null ? null : node.Value;
var value = propertyAccessor.GetValue(prop, null);
return ConvertMemberAccessValue(value);
}
public static QueryProxyReference From(ConstantExpression cex)
{
return new QueryProxyReference
{
Type = XmlMetadataInfo.FromMetadata(cex.Type)
};
}
protected override Expression VisitConstant(ConstantExpression constantExpression)
{
if (constantExpression.Value == null)
{
return base.VisitConstant(constantExpression);
}
var type = constantExpression.Value.GetType();
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
if (Convert.ToBoolean(constantExpression.Value))
{
this.Write(this.ParameterIndicatorPrefix);
this.Write(ParamNamePrefix);
this.Write(this.parameterValues.Count);
this.parameterValues.Add(new Tuple<Type, object>(typeof(string), "true"));
return constantExpression;
}
else
{
this.Write(this.ParameterIndicatorPrefix);
this.Write(ParamNamePrefix);
this.Write(this.parameterValues.Count);
this.parameterValues.Add(new Tuple<Type, object>(typeof(string), "false"));
return constantExpression;
}
}
return base.VisitConstant(constantExpression);
}
// See also e.g. Remotion.Linq.Clauses.ExpressionTreeVisitors.FormattingExpressionTreeVisitor
// for another example of this technique.
protected override Expression VisitConstantExpression(ConstantExpression expression)
{
if (expression.Value.IsProxy())
return Expression.Parameter(expression.Type, ObjectHelpers.IdentityToString(expression.Value));
return base.VisitConstantExpression(expression);
}
public void AddQueryPart(UnaryExpression leftItem, ConstantExpression rightValue, ExpressionType nodeType)
{
if(leftItem.Operand is MethodCallExpression)
{
var unaryOperation = (MethodCallExpression)leftItem.Operand;
if(unaryOperation.Method.Name != "get_Item")
{
throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
}
if(unaryOperation.Arguments[0] is ConstantExpression)
{
var attributeRef = ((ConstantExpression) unaryOperation.Arguments[0]).Value;
AddCriteriaToActiveSearchCondition(attributeRef.ToString(), rightValue.Value, GetSearchRelationType(nodeType));
}
else
{
throw new InvalidOperationException("Only constant expressions are currently supported.");
}
}
else
{
throw new InvalidOperationException("Queries based on " + leftItem.Method.Name + " are not yet supported.");
}
}
protected override Expression VisitConstant(ConstantExpression node)
{
var visitor = new MemberExpressionVisitor(this.Context);
visitor.Visit(node);
Column = visitor.Column;
return node;
}
protected override Expression VisitConstant(ConstantExpression c)
{
// have to do something here about type matching the types of Azure services
if (c.Type == typeof(LinqToAzureOrderedQueryable<StorageAccount>) || c.Type == typeof(LinqToAzureOrderedQueryable<CloudService>))
return Expression.Constant(_accounts);
return c;
}
protected override Expression VisitConstant(ConstantExpression constantExpression)
{
var type = constantExpression.Type;
if ((this.options & SqlExpressionComparerOptions.IgnoreConstants) != 0)
{
return constantExpression;
}
if (type.IsValueType)
{
if (constantExpression.Value != null)
{
this.hashCode ^= constantExpression.Value.GetHashCode();
}
}
else if (typeof(Expression).IsAssignableFrom(constantExpression.Type))
{
this.Visit((Expression)constantExpression.Value);
}
else if (type == typeof(string))
{
this.hashCode ^= constantExpression.Value?.GetHashCode() ?? 0;
}
return constantExpression;
}
protected override Expression VisitConstant(ConstantExpression c)
{
if (disableQueryFilter)
return base.VisitConstant(c);
if (typeof(IQueryable).IsAssignableFrom(c.Type))
{
IQueryable query = (IQueryable)c.Value;
if (query.IsBase())
{
Type identType = c.Type.GetGenericArguments().SingleEx();
if (filter && Schema.Current.Tables.ContainsKey(identType))
{
IQueryable newQuery = miFilter.GetInvoker(identType)(Schema.Current, query);
if (newQuery != query)
return newQuery.Expression;
}
return c;
}
else
{
/// <summary>
/// Replaces every expression like ConstantExpression{ Type = IQueryable, Value = complexExpr } by complexExpr
/// </summary>
return DbQueryProvider.Clean(query.Expression, filter, null);
}
}
return base.VisitConstant(c);
}
protected override Expression VisitConstant(ConstantExpression c)
{
IQueryable q = c.Value as IQueryable;
if (q != null)
{
_query.Index = q.ElementType.Name;
}
else if (c.Value == null)
{
//sb.Append("NULL");
}
else
{
switch (Type.GetTypeCode(c.Value.GetType()))
{
case TypeCode.Boolean:
//sb.Append(((bool)c.Value) ? 1 : 0);
break;
case TypeCode.String:
// sb.Append("'");
// sb.Append(c.Value);
// sb.Append("'");
break;
case TypeCode.Object:
throw new NotSupportedException(string.Format("The constant for '{0}' is not supported", c.Value));
default:
// sb.Append(c.Value);
break;
}
}
return c;
}
public static Expression ReplaceConstantsWithArrayIndexes(Expression node,
ConstantExpression[] constantExpressions, ParameterExpression constantsParameter)
{
var visitor = new ConstantArrayIndexizerVisitor(constantExpressions, constantsParameter);
return visitor.Visit(node);
}
protected override Expression VisitConstant(ConstantExpression c)
{
if (c.Type == queryType)
return Expression.Constant(queryableContents);
return c;
}
protected override Expression VisitConstant(ConstantExpression node)
{
if (node.Value is IQueryable)
sourceQueryable = ((IQueryable)node.Value);
return node;
}
protected override Expression VisitConstant(ConstantExpression constantExpression)
{
return constantExpression.Type.GetTypeInfo().IsGenericType
&& constantExpression.Type.GetGenericTypeDefinition() == typeof(EntityQueryable<>)
? VisitEntityQueryable(((IQueryable)constantExpression.Value).ElementType)
: constantExpression;
}
protected override Expression WalkConstant(ConstantExpression con)
{
var q = con.Value as IQueryable;
if (q != null)
{
output.Append("SELECT * FROM ");
output.Append(NameLookup.GetTableName(q.ElementType));
}
else if (con.Value == null)
{
output.Append("NULL");
}
else
{
switch (Type.GetTypeCode(con.Type))
{
case TypeCode.Boolean: output.Append(((bool)con.Value) ? 1 : 0); break;
case TypeCode.String: output.AppendFormat("'{0}'", con.Value); break;
case TypeCode.DateTime: output.AppendFormat("'{0:dd-MM-yyyy HH:mm:ss}'", con.Value); break;
case TypeCode.Object: throw new UnsupportedQueryException(string.Format("Can't handle '{0}' constant in expression", con));
default:
output.Append(con.Value); break;
}
}
return con;
}
private string ConvertEntityRef(ConstantExpression expression)
{
FieldInfo field = expression.Value.GetType().GetFields().First();
object value = field.GetValue(expression.Value);
this.Parameters.Add(value);
return "?";
}
public static ConstantUpdate Create(PropertyInfo property, ConstantExpression constantExpr)
{
Debug.Assert(property != null, "property should not be null");
Debug.Assert(constantExpr != null, "constantExpr should not be null");
return new ConstantUpdate(property, constantExpr.Value);
}
protected override System.Linq.Expressions.Expression VisitConstant(ConstantExpression c)
{
switch(Type.GetTypeCode(c.Value.GetType()))
{
case TypeCode.Boolean:
_sb.Append(((bool)c.Value) ? "Value=\"True\"" : " Value=\"False\"");
break;
case TypeCode.String:
_sb.Append(" Value=\"");
_sb.Append(c.Value);
_sb.Append("\"");
break;
case TypeCode.Object:
throw new NotSupportedException(string.Format("The constant for '{0}' is not supported", c.Value));
default:
_sb.Append(c.Value);
break;
}
//if (!string.IsNullOrEmpty(currentMember)) {
// sb.Append("</");
// sb.Append(currentMember);
// sb.Append(">");
// currentMember = string.Empty;
//}
return c;
}
protected override System.Linq.Expressions.Expression VisitConstant(System.Linq.Expressions.ConstantExpression node)
{
if (constantFields.ContainsKey(node))
{
string fieldName = constantFields[node];
return(Expression.Field(null, constantFieldStorageType, fieldName));
}
return(node);
}
/// <summary>
/// 表达式路由
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
string ExpressionRouter(System.Linq.Expressions.Expression exp)
{
//获取实体列的特性
List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>();
string sb = string.Empty;
if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符
{
System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp);
return(BinarExpressionProvider(be.Left, be.Right, be.NodeType));
}
else if (exp is System.Linq.Expressions.MemberExpression)//成员
{
System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp);
return(me.Member.Name);
}
else if (exp is System.Linq.Expressions.NewArrayExpression)//数组
{
System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp);
StringBuilder tmpstr = new StringBuilder();
foreach (System.Linq.Expressions.Expression ex in ae.Expressions)
{
tmpstr.Append(ExpressionRouter(ex));
tmpstr.Append(",");
}
return(tmpstr.ToString(0, tmpstr.Length - 1));
}
else if (exp is System.Linq.Expressions.MethodCallExpression)//方法
{
return(MethodExpression(exp));
}
else if (exp is System.Linq.Expressions.ConstantExpression)
{
System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp);
if (ce.Value == null)
{
return("null");
}
else if (ce.Value is ValueType)
{
return(ce.Value.ToString());
}
else if (ce.Value is string || ce.Value is DateTime || ce.Value is char)
{
//return string.Format("'{0}'", ce.Value.ToString());
return(string.Format("{0}", ce.Value.ToString()));
}
}
else if (exp is System.Linq.Expressions.UnaryExpression)
{
System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp);
return(ExpressionRouter(ue.Operand));
}
return(null);
}
public Expression Parse(Linq.Expression linqExpression)
{
if (linqExpression is Linq.ConstantExpression)
{
Linq.ConstantExpression cexpr = (Linq.ConstantExpression)linqExpression;
if (!(cexpr.Value is double))
{
throw new Exception("Can't parse a non-numeric constant");
}
return(new NumberExpression((double)cexpr.Value));
}
else if (linqExpression is Linq.ParameterExpression)
{
Linq.ParameterExpression pexpr = (Linq.ParameterExpression)linqExpression;
return(new VariableExpression(pexpr.Name));
}
else if (linqExpression is Linq.MethodCallExpression)
{
Linq.MethodCallExpression mexpr = (Linq.MethodCallExpression)linqExpression;
IList <Expression> arguments = new List <Expression>();
foreach (Linq.Expression arg in mexpr.Arguments)
{
arguments.Add(Parse(arg));
}
if (!exists(mexpr.Method))
{
throw new Exception("Method name doesn't exist in the scope");
}
if (mexpr.Method.Equals(powMethod))
{
return(new BinaryExpression(Binary.Power, arguments[0], arguments[1]));
}
string name = get(mexpr.Method);
return(new FunctionExpression(name, arguments));
}
else if (linqExpression is Linq.BinaryExpression)
{
Linq.BinaryExpression bexpr = (Linq.BinaryExpression)linqExpression;
Expression left = Parse(bexpr.Left);
Expression right = Parse(bexpr.Right);
return(new BinaryExpression(getOperator(bexpr.NodeType), left, right));
}
throw new Exception("Can't parse expression");
}
static void Main(string[] args)
{
System.Console.WriteLine("Hello World!");
Func <int, bool> test = i => i == 5;
Expressions.ConstantExpression constExpr = Expressions.Expression.Constant(5, typeof(int));
System.Console.WriteLine(constExpr.NodeType);
System.Console.WriteLine(constExpr.Type);
System.Console.WriteLine(constExpr.Value);
}
protected override SystemLinq.Expression VisitConstant(SystemLinq.ConstantExpression node)
{
var type = node.Type;
var value = node.Value;
RemoteLinq.ConstantExpression exp;
if (type is not null && typeof(SystemLinq.Expression).IsAssignableFrom(type) && value is SystemLinq.Expression expressionValue)
{
var expValue = Visit(expressionValue).Unwrap();
exp = new RemoteLinq.ConstantExpression(expValue, _typeInfoProvider.GetTypeInfo(type));
}
/// <summary>
/// 执行翻译工作
/// </summary>
/// <param name="expr"></param>
/// <param name="dbTranslator"></param>
/// <param name="sBuilder"></param>
/// <param name="dpc"></param>
private void parse(Expression expr, IDbTranslator dbTranslator, StringBuilder sBuilder, DataParameterCollection dpc)
{
if (expr is BinaryExpression)
{
//翻译二元运算符表达式
this.parseBinaryExpression((BinaryExpression)expr, dbTranslator, sBuilder, dpc);
}
else if (expr is UnaryExpression)
{
//翻译一元运算符的表达式
this.parseUnaryExpression((UnaryExpression)expr, dbTranslator, sBuilder, dpc);
}
else if (expr is MethodCallExpression)
{
//翻译对静态方法或实例方法的调用
this.parseMethodCallExpression((MethodCallExpression)expr, dbTranslator, sBuilder, dpc);
}
else if (expr is System.Linq.Expressions.ConstantExpression)
{
System.Linq.Expressions.ConstantExpression cExp = expr as System.Linq.Expressions.ConstantExpression;
bool cExpValue = false;
if (cExp.Value != null)
{
if (!bool.TryParse(cExp.Value.ToString(), out cExpValue))
{
cExpValue = true;
}
}
if (cExpValue)
{
sBuilder.Append("(1=1)");
}
else
{
sBuilder.Append("(1<>1)");
}
}
else
{
if (isBooleanFieldOrProperty(expr))
{
IPropertyMapper propertyMapper = this.getPropertyMapper(((MemberExpression)expr).Member.Name);
//生成SQL片段和参数
this.buildSqlAndDataParameter(propertyMapper, ColumnFunction.None, CompareOpration.Equal, true, dbTranslator, sBuilder, dpc);
}
else
{
throw new MapleException("该操作不支持！" + expr.Type.FullName);
}
}
}
protected override System.Linq.Expressions.Expression VisitConstant(System.Linq.Expressions.ConstantExpression node)
{
if (!CanEmitILConstant(node.Type) && node.Value != null)
{
if (!constantFields.ContainsKey(node))
{
string name = "const" + constantFields.Count;
constantFields[node] = name;
constantFieldStorageType.DefineField(name, node.Type, FieldAttributes.Public | FieldAttributes.Static);
}
}
return(node);
}
private Expression Convert(LinqExp.ConstantExpression linqConstant)
{
switch (linqConstant.Value)
{
case Expression dlrExpression:
return(dlrExpression);
case LinqExp.Expression linqExpression:
return(ConvertExp(linqExpression));
default:
return(Expression.Constant(linqConstant.Value, linqConstant.Type));
}
}
protected override System.Linq.Expressions.Expression VisitConstant(System.Linq.Expressions.ConstantExpression c)
{
// Ef cannot map enumerations to the database, we need to use ints instead
if (c.Value != null && c.Type.IsEnum) // Handle Enums
{
return(Expression.Constant((int)c.Value, typeof(int)));
}
else if (c.Value != null && c.Type.IsGenericType && c.Type.GetGenericTypeDefinition() == typeof(Nullable <>) && c.Type.GetGenericArguments().Single().IsEnum)
{
return(Expression.Constant((int)c.Value, typeof(int?))); // You can't extract a int? from an enum value
}
else
{
return(base.VisitConstant(c));
}
}
internal DebugInfoRewriter(
DebugContext debugContext,
bool transformToGenerator,
MSAst.Expression traceLocations,
MSAst.Expression thread,
MSAst.Expression frame,
MSAst.Expression pushFrame,
MSAst.Expression debugMarker,
MSAst.Expression globalDebugMode,
Dictionary <DebugSourceFile, MSAst.ParameterExpression> sourceFilesToVariablesMap,
MSAst.LabelTarget generatorLabel,
Dictionary <MSAst.ParameterExpression, MSAst.ParameterExpression> replacedLocals,
Dictionary <MSAst.ParameterExpression, VariableInfo> localsToVarInfos,
DebugLambdaInfo lambdaInfo)
{
_debugContext = debugContext;
_transformToGenerator = transformToGenerator;
_traceLocations = traceLocations;
_thread = thread;
_frame = frame;
_pushFrame = pushFrame;
if (_transformToGenerator)
{
_debugYieldValue = Ast.Constant(DebugContext.DebugYieldValue);
// When transforming to generator we'll also create marker-location and position-handler maps
_markerLocationMap = new Dictionary <int, DebugSourceSpan>();
_variableScopeMap = new Dictionary <int, IList <VariableInfo> >();
_currentLocals = new Stack <MSAst.BlockExpression>();
_variableScopeMapCache = new Dictionary <MSAst.BlockExpression, IList <VariableInfo> >();
}
_debugMarker = debugMarker;
_globalDebugMode = globalDebugMode;
_sourceFilesToVariablesMap = sourceFilesToVariablesMap;
_generatorLabelTarget = generatorLabel;
_replacedLocals = replacedLocals;
_localsToVarInfos = localsToVarInfos;
_lambdaInfo = lambdaInfo;
}
private SqlExpression ParseConstant(System.Linq.Expressions.ConstantExpression constant)
{
switch (constant.Value)
{
case char ch:
return(new SqlConstantExpression(FieldType.Char, ch));
case string str:
return(new SqlConstantExpression(FieldType.String, str));
case int i:
return(new SqlConstantExpression(FieldType.Int, i));
case double d:
return(new SqlConstantExpression(FieldType.Double, d));
case bool b:
return(new SqlConstantExpression(FieldType.Bool, b));
}
throw new NotImplementedException();
}
private static Expression Convert(LinqExp.ConstantExpression linqConstant) => Expression.Constant(linqConstant.Value, linqConstant.Type);
/// <summary>
/// Visits the <see cref="ConstantExpression"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected internal virtual Expression VisitConstant(ConstantExpression node)
{
return(node);
}
protected internal override Expression VisitConstant(ConstantExpression node)
{
Out(Constant(node.Value));
return(node);
}
protected override Expression VisitConstant(ConstantExpression node) => MakeBinding(node);
public ConstantExpressionProxy(ConstantExpression node)
{
ContractUtils.RequiresNotNull(node, nameof(node));
_node = node;
}
protected virtual Expression VisitConstant(ConstantExpression node)
{
throw new NotImplementedException();
}
protected virtual void VisitConstant(ConstantExpression constant)
{
}
protected override string VisitConstant(ConstantExpression node)
{
var value = node.Value != null?node.Value.ToString() : "null";
return("(" + GetType(node.Type) + ")" + value);
}
protected internal override Expression VisitConstant(ConstantExpression node)
{
var value = node.Value;
switch (value)
{
case null:
Out("null");
break;
case string _ when node.Type == typeof(string):
Out
(
string.Format
(
CultureInfo.CurrentCulture,
"\"{0}\"",
value
)
);
break;
case char _ when node.Type == typeof(char):
Out
(
string.Format
(
CultureInfo.CurrentCulture,
"'{0}'",
value
)
);
break;
case int _ when node.Type == typeof(int):
case bool _ when node.Type == typeof(bool):
Out(value.ToString());
break;
default:
var suffix = GetConstantValueSuffix(node.Type);
if (suffix != null)
{
Out(value.ToString());
Out(suffix);
}
else
{
Out
(
string.Format
(
CultureInfo.CurrentCulture,
".Constant<{0}>({1})",
node.Type.ToString(),
value
)
);
}
break;
}
return(node);
}
protected override System.Linq.Expressions.Expression VisitConstantExpression(System.Linq.Expressions.ConstantExpression expression)
{
return(Expression.Constant("ConstantExpression was visited"));
}
/// <summary>
/// There is never a constant reference, so don't let it go!
/// </summary>
/// <param name="expr"></param>
/// <param name="codeEnv"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public IValue ProcessConstantReference(System.Linq.Expressions.ConstantExpression expr, IGeneratedQueryCode codeEnv, CompositionContainer container)
{
throw new NotImplementedException();
}
private static SysLE.Expression SysExpressionWhere_Analyize(SysLE.Expression exp, StringBuilder builder)
{
if (exp == null)
{
return(null);
}
SysLE.BinaryExpression binEx = exp as SysLE.BinaryExpression;
if (binEx != null)
{
SysExpressionWhere_Analyize(binEx.Left, builder);
}
switch (exp.NodeType)
{
case SysLE.ExpressionType.Parameter:
{
SysLE.ParameterExpression param = (SysLE.ParameterExpression)exp;
builder.Append("(" + param.Name);
return(null);
}
case SysLE.ExpressionType.MemberAccess:
{
SysLE.MemberExpression mexp = (SysLE.MemberExpression)exp;
builder.Append("(" + mexp.Member.Name);
return(null);
}
case SysLE.ExpressionType.Constant:
{
SysLE.ConstantExpression cex = (SysLE.ConstantExpression)exp;
if (cex.Value is string)
{
builder.Append("'" + cex.Value.ToString() + "') ");
}
else
{
builder.Append(cex.Value.ToString() + ")");
}
return(null);
}
default:
{
if (exp.NodeType == SysLE.ExpressionType.Equal)
{
builder.Append("=");
}
else if (exp.NodeType == SysLE.ExpressionType.NotEqual)
{
builder.Append("<>");
}
else if (exp.NodeType == SysLE.ExpressionType.LessThan)
{
builder.Append("<");
}
else if (exp.NodeType == SysLE.ExpressionType.LessThanOrEqual)
{
builder.Append("<=");
}
else if (exp.NodeType == SysLE.ExpressionType.GreaterThan)
{
builder.Append(">");
}
else if (exp.NodeType == SysLE.ExpressionType.GreaterThanOrEqual)
{
builder.Append(">=");
}
else if (exp.NodeType == SysLE.ExpressionType.AndAlso || exp.NodeType == SysLE.ExpressionType.And)
{
builder.Append("and");
}
else if (exp.NodeType == SysLE.ExpressionType.OrElse || exp.NodeType == SysLE.ExpressionType.Or)
{
builder.Append("or");
}
}
break;
}
if (binEx != null)
{
SysExpressionWhere_Analyize(binEx.Right, builder);
}
return(binEx);
}
protected virtual ConstantExpression VisitConstant(ConstantExpression constant)
{
return(constant);
}
protected virtual bool VisitConstant(ConstantExpression c, ConstantExpression c2)
{
return(Equals(c.Value, c2.Value));
}
internal virtual Expression VisitConstant(ConstantExpression c)
{
return((Expression)c);
}
private int DoFilterData()
{
var filterData = GetFilterData();
foreach (var singleFilter in filterData)
{
var dataKey = singleFilter.Field;
var dataOp = singleFilter.Comparison;
var dataValue = singleFilter.Data;
Linq.Expression <Func <T, bool> > wherePredicate;
if (_filterActions.ContainsKey(dataKey.ToLower()))
{
wherePredicate = _filterActions[dataKey.ToLower()].Invoke(dataValue);
}
else if (dataKey.Contains("-date-range-"))
{
var param = Linq.Expression.Parameter(typeof(T), "x");
var propName = dataKey.Substring(0, dataKey.IndexOf("-date-range-", 0));
var property = BuildPropertyExpression(param, propName);
Linq.ConstantExpression filter = Linq.Expression.Constant
(
ChangeType(dataValue, property.Type), property.Type
);
Linq.BinaryExpression condition;
if (dataKey.Contains("-date-range-start"))
{
condition = Linq.Expression.GreaterThanOrEqual(property, filter);
}
else
{
if (filter.Type == typeof(DateTimeOffset))
{
filter = Linq.Expression.Constant(((DateTimeOffset)filter.Value).AddDays(1), property.Type);
}
else
{
filter = Linq.Expression.Constant(((DateTime)filter.Value).AddDays(1), property.Type);
}
condition = Linq.Expression.LessThan(property, filter);
}
wherePredicate = Linq.Expression.Lambda <Func <T, bool> >(condition, param);
}
else if (dataOp == ComparisonOperator.@in)
{
var param = Linq.Expression.Parameter(typeof(T), "x");
var property = BuildPropertyExpression(param, dataKey);
var collectionType = typeof(ICollection <>).MakeGenericType(property.Type);
var collectionData = JsonConvert.DeserializeObject(dataValue, collectionType);
var method = collectionType.GetMethod("Contains", new[] { property.Type });
var value = Linq.Expression.Constant(collectionData, collectionType);
var condition = Linq.Expression.Call(value, method, property);
wherePredicate = Linq.Expression.Lambda <Func <T, bool> >(condition, param);
}
else
{
var param = Linq.Expression.Parameter(typeof(T), "x");
var property = BuildPropertyExpression(param, dataKey);
var value = Linq.Expression.Constant(ChangeType(dataValue, property.Type), property.Type);
if (dataOp == ComparisonOperator.cn && property.Type != typeof(string))
{
dataOp = ComparisonOperator.eq;
}
var contains = typeof(string).GetMethod("Contains", new Type[] { typeof(string) });
var startsWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
var endsWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
Linq.Expression condition;
switch (dataOp)
{
case ComparisonOperator.eq:
condition = Linq.Expression.Equal(property, value);
break;
case ComparisonOperator.ne:
condition = Linq.Expression.NotEqual(property, value);
break;
case ComparisonOperator.lt:
condition = Linq.Expression.LessThan(property, value);
break;
case ComparisonOperator.le:
condition = Linq.Expression.LessThanOrEqual(property, value);
break;
case ComparisonOperator.gt:
condition = Linq.Expression.GreaterThan(property, value);
break;
case ComparisonOperator.ge:
condition = Linq.Expression.GreaterThanOrEqual(property, value);
break;
case ComparisonOperator.bw:
condition = Linq.Expression.Call(property, startsWith, value);
break;
case ComparisonOperator.bn:
condition = Linq.Expression.Not(Linq.Expression.Call(property, startsWith, value));
break;
case ComparisonOperator.ni:
condition = Linq.Expression.Not(Linq.Expression.Call(value, contains, property));
break;
case ComparisonOperator.ew:
condition = Linq.Expression.Call(property, endsWith, value);
break;
case ComparisonOperator.en:
condition = Linq.Expression.Not(Linq.Expression.Call(property, endsWith, value));
break;
case ComparisonOperator.cn:
condition = Linq.Expression.Call(property, contains, value);
break;
case ComparisonOperator.nc:
condition = Linq.Expression.Not(Linq.Expression.Call(property, contains, value));
break;
default:
condition = Linq.Expression.Equal(property, value);
break;
}
wherePredicate = Linq.Expression.Lambda <Func <T, bool> >(condition, param);
}
_queryable = _queryable.Where(wherePredicate);
}
return(_queryable.Count());
}
