Ejemplo n.º 1
0
		public void SimpleConversion()
		{
			Expression<double> expr = new Expression<double>("2 * 100");
			double result = expr.Evaluate();

			Assert.AreEqual(200.0d, result);
		}
 internal UnsafeAccessExpression(CsTokenList tokens, Operator operatorType, Expression value)
     : base(ExpressionType.UnsafeAccess, tokens)
 {
     this.operatorType = operatorType;
     this.value = value;
     base.AddExpression(value);
 }
Ejemplo n.º 3
0
        public MethodCall(Expression target, string/*!*/ methodName, Arguments args, Block block, SourceSpan location)
            : base(args, block, location) {
            Assert.NotEmpty(methodName);

            _methodName = methodName;
            _target = target;
        }
Ejemplo n.º 4
0
		public void ConversionToLessSpecficWithBoxingToObject()
		{
			Expression<object> expr = new Expression<object>("2 + 2");
			object result = expr.Evaluate();

			Assert.AreEqual(4, result);
		}
Ejemplo n.º 5
0
 public GreaterThanExpression(Expression left, Expression right)
 {
     Operands.Add(left);
     Operands.Add(right);
     //TODO validate ParamType
     ReturnType = typeof (bool);
 }
Ejemplo n.º 6
0
 public void Collect(Expression tvBasePointer, int basePointerSize, Expression eField, Expression effectiveAddress)
 {
     this.basePointer = tvBasePointer;
     this.basePointerSize = basePointerSize;
     this.eField = eField;
     effectiveAddress.Accept(this);
 }
		/// <summary>
		/// Produces a choice pattern for <c>expr1 op expr2</c> or <c>expr2 op expr1</c>.
		/// </summary>
		public static Expression CommutativeOperator(Expression expr1, BinaryOperatorType op, Expression expr2)
		{
			return new Choice {
				new BinaryOperatorExpression(expr1, op, expr2),
				new BinaryOperatorExpression(expr2.Clone(), op, expr1.Clone())
			};
		}
Ejemplo n.º 8
0
 public UnaryExpression(Terminal op, Expression expression)
 {
     Operator = op;
     Expression = expression;
     AddAttribute(new OperatorAttr(op));
     AddChild(expression);
 }
Ejemplo n.º 9
0
		public static bool TryGetFormattingParameters(CSharpInvocationResolveResult invocationResolveResult, InvocationExpression invocationExpression,
		                                     		  out Expression formatArgument, out TextLocation formatStart, out IList<Expression> arguments,
		                                              Func<IParameter, Expression, bool> argumentFilter)
		{
			if (argumentFilter == null)
				argumentFilter = (p, e) => true;

			formatArgument = null;
			formatStart = default(TextLocation);
			arguments = new List<Expression>();
			var argumentToParameterMap = invocationResolveResult.GetArgumentToParameterMap();
			var resolvedParameters = invocationResolveResult.Member.Parameters;
			var allArguments = invocationExpression.Arguments.ToArray();
			for (int i = 0; i < allArguments.Length; i++) {
				var parameterIndex = argumentToParameterMap[i];
				if (parameterIndex < 0 || parameterIndex >= resolvedParameters.Count) {
					// No valid mapping for this parameter, skip it
					continue;
				}
				var parameter = resolvedParameters[parameterIndex];
				var argument = allArguments[i];
				if (parameter.Type.IsKnownType(KnownTypeCode.String) && parameterNames.Contains(parameter.Name)) {
					formatArgument = argument;
					formatStart = argument.StartLocation;
				} else if ((formatArgument != null || parameter.IsParams) && argumentFilter(parameter, argument)) {
					arguments.Add(argument);
				}
			}
			return formatArgument != null;
		}
        /// <summary>
        /// Emits an expression and discards the result.  For some nodes this emits
        /// more optimial code then EmitExpression/Pop
        /// </summary>
        private void EmitExpressionAsVoid(Expression node) {
            Debug.Assert(node != null);

            ExpressionStart startEmitted = EmitExpressionStart(node);

            switch (node.NodeType) {
                case ExpressionType.Assign:
                    EmitAssign((BinaryExpression)node, EmitAs.Void);
                    break;
                case ExpressionType.Block:
                    Emit((BlockExpression)node, EmitAs.Void);
                    break;
                case ExpressionType.Throw:
                    EmitThrow((UnaryExpression)node, EmitAs.Void);
                    break;
                case ExpressionType.Constant:
                case ExpressionType.Default:
                case ExpressionType.Parameter:
                    // no-op
                    break;
                default:
                    EmitExpression(node, false);
                    if (node.Type != typeof(void)) {
                        _ilg.Emit(OpCodes.Pop);
                    }
                    break;
            }
            EmitExpressionEnd(startEmitted);
        }
Ejemplo n.º 11
0
        public override Expression Parse(System.IO.TextReader reader, TextManager manager)
        {
            var expr = new Expression();
            expr.Parts.Add(new Text { Spelling = reader.ReadToEnd() });

            return expr;
        }
Ejemplo n.º 12
0
        internal ComInvokeBinder(
                CallInfo callInfo, 
                DynamicMetaObject[] args,
                bool[] isByRef,
                BindingRestrictions restrictions, 
                Expression method, 
                Expression dispatch, 
                ComMethodDesc methodDesc
                )
        {
            Debug.Assert(callInfo != null, "arguments");
            Debug.Assert(args != null, "args");
            Debug.Assert(isByRef != null, "isByRef");
            Debug.Assert(method != null, "method");
            Debug.Assert(dispatch != null, "dispatch");

            Debug.Assert(TypeUtils.AreReferenceAssignable(typeof(ComMethodDesc), method.Type), "method");
            Debug.Assert(TypeUtils.AreReferenceAssignable(typeof(IDispatch), dispatch.Type), "dispatch");

            _method = method;
            _dispatch = dispatch;
            _methodDesc = methodDesc;

            _callInfo = callInfo;
            _args = args;
            _isByRef = isByRef;
            _restrictions = restrictions;

            // Set Instance to some value so that CallBinderHelper has the right number of parameters to work with
            _instance = dispatch;
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Backwards compatible Convert for the old sites that need to flow CodeContext
 /// </summary>
 public static Expression/*!*/ Convert(Expression/*!*/ codeContext, PythonContext/*!*/ binder, Type/*!*/ type, ConversionResultKind resultKind, Expression/*!*/ target) {
     return Ast.Dynamic(
         binder.Convert(type, resultKind),
         type,
         target
     );
 }
        public void BinaryOperationExpressionCombinesSequences()
        {
            var a = new Expression[] { 1, 2, null, "Hello", JS.Function().Call() };
            var c = a.Combined(BinaryOperator.Add);

            Assert.AreEqual("1+2+null+\"Hello\"+(function(){})();", c.ToString());
        }
Ejemplo n.º 15
0
 private void MaybeEmitCr1(Expression e)
 {
     if (!instr.setsCR0)
         return;
     var cr1 = frame.EnsureFlagGroup(arch.cr, 0x2, "cr1", PrimitiveType.Byte);
     emitter.Assign(cr1, emitter.Cond(e));
 }
Ejemplo n.º 16
0
        public static Expression Convert(Expression expression, Type type) {
            ContractUtils.RequiresNotNull(expression, "expression");

            if (expression.Type == type) {
                return expression;
            }

            if (expression.Type == typeof(void)) {
                return Expression.Block(expression, Utils.Default(type));
            }

            if (type == typeof(void)) {
                return Void(expression);
            }

            // TODO: this is not the right level for this to be at. It should
            // be pushed into languages if they really want this behavior.
            if (type == typeof(object)) {
                if (expression.Type == typeof(int)) {
                    return Expression.Convert(expression, typeof(object), ScriptingRuntimeHelpers.Int32ToObjectMethod);
                } else if (expression.Type == typeof(bool)) {
                    return Expression.Convert(expression, typeof(object), ScriptingRuntimeHelpers.BooleanToObjectMethod);
                }
            }

            return Expression.Convert(expression, type);
        }
Ejemplo n.º 17
0
 /// <summary>
 /// Create a field expression.
 /// </summary>
 /// <param name="position"></param>
 /// <param name="target"></param>
 /// <param name="member"></param>
 /// <param name="generics">An optional collection of genericTypes</param>
 public FieldExpression(TokenPosition position, Expression target, string member, Type[] genericTypes = null)
     : base(position)
 {
     _target = target;
     _member = member;
     _genericTypes = genericTypes;
 }
Ejemplo n.º 18
0
        protected virtual void EmitNameExpression(string name, Expression namedExpression, Expression expression)
        {
            var resolveResult = this.Emitter.Resolver.ResolveNode(namedExpression, this.Emitter);

            if (!this.Emitter.AssemblyInfo.PreserveMemberCase)
            {
                name = Object.Net.Utilities.StringUtils.ToLowerCamelCase(name);
            }

            if (resolveResult != null && resolveResult is MemberResolveResult)
            {
                var member = ((MemberResolveResult)resolveResult).Member;
                var preserveCase = !this.Emitter.IsNativeMember(member.FullName) ? this.Emitter.AssemblyInfo.PreserveMemberCase : false;
                name = this.Emitter.GetEntityName(member, preserveCase);

                var isProperty = member.SymbolKind == SymbolKind.Property;

                if (!isProperty)
                {
                    this.Write(name);
                }
                else
                {
                    this.Write(isProperty ? Helpers.GetPropertyRef(member, this.Emitter, !(expression is ArrayInitializerExpression)) : name);
                }
            }
            else
            {
                this.Write(name);
            }

            this.WriteColon();
            expression.AcceptVisitor(this.Emitter);
        }
Ejemplo n.º 19
0
 /// <summary>
 /// Converts an expression to a void type.
 /// </summary>
 /// <param name="expression">An <see cref="Expression"/> to convert to void. </param>
 /// <returns>An <see cref="Expression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ConvertChecked" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> property set to void.</returns>
 public static Expression Void(Expression expression) {
     ContractUtils.RequiresNotNull(expression, "expression");
     if (expression.Type == typeof(void)) {
         return expression;
     }
     return Expression.Block(typeof(void), expression);
 }
		CodeAction CreateFromExpression(RefactoringContext context, Expression expression)
		{
			var resolveResult = context.Resolve(expression);
			if (resolveResult.IsError)
				return null;
			
			return new CodeAction(context.TranslateString("Extract method"), script => {
				string methodName = "NewMethod";
				var method = new MethodDeclaration() {
					ReturnType = context.CreateShortType(resolveResult.Type),
					Name = methodName,
					Body = new BlockStatement() {
						new ReturnStatement(expression.Clone())
					}
				};
				if (!StaticVisitor.UsesNotStaticMember(context, expression))
					method.Modifiers |= Modifiers.Static;
				var task = script.InsertWithCursor(context.TranslateString("Extract method"), Script.InsertPosition.Before, method);

				Action<Task> replaceStatements = delegate {
					var target = new IdentifierExpression(methodName);
					script.Replace(expression, new InvocationExpression(target));
					script.Link(target, method.NameToken);
				};

				if (task.IsCompleted) {
					replaceStatements (null);
				} else {
					task.ContinueWith (replaceStatements, TaskScheduler.FromCurrentSynchronizationContext ());
				}
			});
		}
Ejemplo n.º 21
0
 public override bool Replace(Node oldValue, Node newValue)
 {
   return
     Replace(Value, oldValue, newValue, n => Value = n)
     ||
     base.Replace(oldValue, newValue);
 }
Ejemplo n.º 22
0
        public override bool Equals(Expression E)
        {
            Product P = E as Product;
            if (ReferenceEquals(P, null)) return base.Equals(E);

            return Terms.SequenceEqual(P.Terms);
        }
Ejemplo n.º 23
0
        /// <summary>
        /// The helper to create the AST method call node. Will add conversions (Utils.Convert)
        /// to parameters and instance if necessary.
        /// </summary>
        public static MethodCallExpression SimpleCallHelper(Expression instance, MethodInfo method, params Expression[] arguments) {
            ContractUtils.RequiresNotNull(method, "method");
            ContractUtils.Requires(instance != null ^ method.IsStatic, "instance");
            ContractUtils.RequiresNotNullItems(arguments, "arguments");

            ParameterInfo[] parameters = method.GetParameters();

            ContractUtils.Requires(arguments.Length == parameters.Length, "arguments", "Incorrect number of arguments");

            if (instance != null) {
                instance = Convert(instance, method.DeclaringType);
            }

            Expression[] convertedArguments = ArgumentConvertHelper(arguments, parameters);

            ReadOnlyCollection<Expression> finalArgs;
            if (convertedArguments == arguments) {
                // we didn't convert anything, just convert the users original
                // array to a readonly collection.
                finalArgs = convertedArguments.ToReadOnly();
            } else {
                // we already copied the array so just stick it in a readonly collection.
                finalArgs = new ReadOnlyCollection<Expression>(convertedArguments);
            }

            // the arguments are now all correct, avoid re-validating the call parameters and
            // directly create the expression.
            return Expression.Call(instance, method, finalArgs);
        }
Ejemplo n.º 24
0
        private static Expression[] ArgumentConvertHelper(Expression[] arguments, ParameterInfo[] parameters) {
            Debug.Assert(arguments != null);
            Debug.Assert(arguments != null);

            Expression[] clone = null;
            for (int arg = 0; arg < arguments.Length; arg++) {
                Expression argument = arguments[arg];
                if (!CompatibleParameterTypes(parameters[arg].ParameterType, argument.Type)) {
                    // Clone the arguments array if needed
                    if (clone == null) {
                        clone = new Expression[arguments.Length];
                        // Copy the expressions into the clone
                        for (int i = 0; i < arg; i++) {
                            clone[i] = arguments[i];
                        }
                    }

                    argument = ArgumentConvertHelper(argument, parameters[arg].ParameterType);
                }

                if (clone != null) {
                    clone[arg] = argument;
                }
            }
            return clone ?? arguments;
        }
Ejemplo n.º 25
0
 public Binary(SourceSpan span, Operator op, Expression left, Expression right)
     : base(span)
 {
     _op = op;
     _left = left;
     _right = right;
 }
Ejemplo n.º 26
0
 public static Expression Coalesce(LambdaBuilder builder, Expression left, Expression right)
 {
     ParameterExpression temp;
     Expression result = Coalesce(left, right, out temp);
     builder.AddHiddenVariable(temp);
     return result;
 }
Ejemplo n.º 27
0
        private static MSAst.Expression GetSliceValue(AstGenerator ag, Expression expr) {
            if (expr != null) {
                return ag.Transform(expr);
            }

            return Ast.Field(null, typeof(MissingParameter).GetField("Value"));
        }
Ejemplo n.º 28
0
		public ForLoopStatement(ScriptLoadingContext lcontext, Token nameToken, Token forToken)
			: base(lcontext)
		{
			//	for Name ‘=’ exp ‘,’ exp [‘,’ exp] do block end | 

			// lexer already at the '=' ! [due to dispatching vs for-each]
			CheckTokenType(lcontext, TokenType.Op_Assignment);

			m_Start = Expression.Expr(lcontext);
			CheckTokenType(lcontext, TokenType.Comma);
			m_End = Expression.Expr(lcontext);

			if (lcontext.Lexer.Current.Type == TokenType.Comma)
			{
				lcontext.Lexer.Next();
				m_Step = Expression.Expr(lcontext);
			}
			else
			{
				m_Step = new LiteralExpression(lcontext, DynValue.NewNumber(1));
			}

			lcontext.Scope.PushBlock();
			m_VarName = lcontext.Scope.DefineLocal(nameToken.Text);
			m_RefFor = forToken.GetSourceRef(CheckTokenType(lcontext, TokenType.Do));
			m_InnerBlock = new CompositeStatement(lcontext);
			m_RefEnd = CheckTokenType(lcontext, TokenType.End).GetSourceRef();
			m_StackFrame = lcontext.Scope.PopBlock();

			lcontext.Source.Refs.Add(m_RefFor);
			lcontext.Source.Refs.Add(m_RefEnd);
		}		
Ejemplo n.º 29
0
        public override void SetParent(Expression parent)
        {
            base.SetParent(parent);

            if (Value != null)
                Value.SetParent(this);
        }
Ejemplo n.º 30
0
 public virtual IQueryable CreateQuery(Expression expression)
     => (IQueryable)_genericCreateQueryMethod
         .MakeGenericMethod(expression.Type.GetSequenceType())
         .Invoke(this, new object[] { expression });
Ejemplo n.º 31
0
 public TEntity Single(Expression<Func<TEntity, bool>> predicate)
 {
     return _dbSet.Single(predicate);
 }
Ejemplo n.º 32
0
 internal CqlLinqNotSupportedException(Expression expression, ParsePhase parsePhase)
     : base(string.Format("The expression {0} = [{1}] is not supported in {2} parse phase.",
                 expression.NodeType.ToString(), expression.ToString(), parsePhase.ToString()))
 {
     Expression = expression;
 }
Ejemplo n.º 33
0
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (node.Method.Name == "Select")
            {
                this.Visit(node.Arguments[0]);

                using(phasePhase.set(ParsePhase.What))
                    this.Visit(node.Arguments[1]);

                return node;
            }
            else if (node.Method.Name == "Where")
            {
                this.Visit(node.Arguments[0]);

                using (phasePhase.set(ParsePhase.Condition))
                {
                    if (WhereClause.Length != 0)
                        WhereClause.Append(" AND ");
                    this.Visit(node.Arguments[1]);
                }
                return node;
            }
            else if (node.Method.Name == "Take")
            {
                this.Visit(node.Arguments[0]);
                using (phasePhase.set(ParsePhase.Take))
                    this.Visit(node.Arguments[1]);
                return node;
            }
            else if (node.Method.Name == "OrderBy" || node.Method.Name == "ThenBy")
            {
                this.Visit(node.Arguments[0]);
                using (phasePhase.set(ParsePhase.OrderBy))
                    this.Visit(node.Arguments[1]);
                return node;
            }
            else if (node.Method.Name == "OrderByDescending" || node.Method.Name == "ThenByDescending")
            {
                this.Visit(node.Arguments[0]);
                using (phasePhase.set(ParsePhase.OrderByDescending))
                    this.Visit(node.Arguments[1]);
                return node;
            }
            else if (node.Method.Name == "FirstOrDefault" || node.Method.Name == "First")
            {
                this.Visit(node.Arguments[0]);
                if (node.Arguments.Count == 3)
                {
                    using (phasePhase.set(ParsePhase.Condition))
                        this.Visit(node.Arguments[2]);
                }
                Limit = 1;
                return node;
            }

            if (phasePhase.get() == ParsePhase.Condition)
            {
                if (node.Method.Name == "Contains")
                {
                    Expression what = null;
                    Expression inp = null;
                    if (node.Object == null)
                    {
                        what = node.Arguments[1];
                        inp = node.Arguments[0];
                    }
                    else
                    {
                        what = node.Arguments[0];
                        inp = node.Object;
                    }
                    this.Visit(what);
                    WhereClause.Append(" IN (");
                    var values = (IEnumerable)Expression.Lambda(inp).Compile().DynamicInvoke();
                    bool first = false;
                    foreach (var obj in values)
                    {
                        if (!first)
                            first = true;
                        else
                            WhereClause.Append(", ");
                        WhereClause.Append(obj.Encode());
                    }
                    if (!first)
                        throw new CqlArgumentException("Collection " + inp.ToString() + " is empty.");
                    WhereClause.Append(")");
                    return node;
                }
                else if (node.Method.Name == "CompareTo")
                {
                    this.Visit(node.Object);
                    WhereClause.Append(" " + binaryExpressionTag.get() + " ");
                    this.Visit(node.Arguments[0]);
                    return node;
                }
                else if(node.Method.Name == "Equals")
                {
                    this.Visit(node.Object);
                    WhereClause.Append(" = ");
                    this.Visit(node.Arguments[0]);
                    return node;
                }
                else if (node.Type.Name == "CqlToken")
                {
                    WhereClause.Append("token(");
                    var exprs = node.Arguments;
                    this.Visit(exprs.First());
                    foreach (var e in exprs.Skip(1))
                    {
                        WhereClause.Append(", ");
                        this.Visit(e);
                    }
                    WhereClause.Append(")");
                    return node;
                }
                else
                {
                    var val = Expression.Lambda(node).Compile().DynamicInvoke();
                    WhereClause.Append(val.Encode());
                    return node;
                }

            }

            throw new CqlLinqNotSupportedException(node, phasePhase.get());
        }
Ejemplo n.º 34
0
 public void Evaluate(Expression expression)
 {
     this.Visit(expression);
 }
Ejemplo n.º 35
0
 public async Task<TEntity> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate)
 {
     return await _dbSet.SingleOrDefaultAsync();
 }
Ejemplo n.º 36
0
 public TEntity SingleOrDefault(Expression<Func<TEntity, bool>> predicate)
 {
     return _dbSet.SingleOrDefault();
 }
Ejemplo n.º 37
0
 public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate)
 {
     return _dbSet.FirstOrDefault(predicate);
 }
Ejemplo n.º 38
0
 public static LambdaExpression FooReturn2()
 {
     Expression<Func<object, bool>> e = f => false;
     return e;
 }
Ejemplo n.º 39
0
 public async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate)
 {
     return await _dbSet.FirstOrDefaultAsync(predicate);
 }
Ejemplo n.º 40
0
        /// <summary>
        /// 递归解析表达式路由计算
        /// </summary>
        /// <returns></returns>
        private string CreateSqlElements(Expression exp, ref MemberType type, bool isTure = true)
        {
            if (exp is LambdaExpression)
            {
                LambdaExpression lambda = exp as LambdaExpression;
                var expression = lambda.Body;
                MemberType EleType = MemberType.None;
                return CreateSqlElements(expression, ref EleType);
            }
            else if (exp is BinaryExpression)
            {
                var expression = exp as BinaryExpression;
                MemberType leftType = MemberType.None;
                MemberType rightType = MemberType.None;
                var leftIsDateTime = expression.Left.Type.ToString().Contains("System.DateTime");
                var rightIsDateTime = expression.Right.Type.ToString().Contains("System.DateTime");
                var left = CreateSqlElements(expression.Left, ref leftType);
                var right = CreateSqlElements(expression.Right, ref rightType);
                var oper = GetOperator(expression.NodeType);
                var isKeyOperValue = leftType == MemberType.Key && rightType == MemberType.Value;
                var isValueOperKey = rightType == MemberType.Key && leftType == MemberType.Value;
                #region 处理 null
                if (isKeyOperValue & (right == "null" || right == null) && oper.Trim() == "=")
                {
                    var oldLeft = AddParas(ref left, right);
                    return string.Format(" ({0} is null ) ", oldLeft);
                }
                else if (isKeyOperValue & (right == "null" || right == null) && oper.Trim() == "<>")
                {
                    var oldLeft = AddParas(ref left, right);
                    return string.Format(" ({0} is not null ) ", oldLeft);
                }
                else if (isValueOperKey & (left == "null" || left == null) && oper.Trim() == "=")
                {
                    return string.Format(" ({0} is null ) ", right);
                }
                else if (isValueOperKey & (left == "null" || left == null) && oper.Trim() == "<>")
                {
                    return string.Format(" ({0} is not null ) ", right);
                }
                #endregion
                else if (isKeyOperValue)
                {
                    object parValue = null;
                    if (leftIsDateTime && right != null && right.IsDate())
                    {
                        parValue = Convert.ToDateTime(right);
                    }
                    else
                    {
                        parValue = right;
                    }
                    var oldLeft = AddParas(ref left, parValue);
                    return string.Format(" ({0} {1} :{2}) ", oldLeft, oper, left);
                }
                else if (isValueOperKey)
                {
                    object parValue = null;
                    if (rightIsDateTime && left != null && left.IsDate())
                    {
                        parValue = Convert.ToDateTime(left);
                    }
                    else
                    {
                        parValue = left;
                    }
                    var oldRight = AddParasReturnRight(parValue, ref  right);
                    return string.Format("( :{0} {1} {2} )", right, oper, oldRight);
                }
                else if (leftType == MemberType.Value && rightType == MemberType.Value)
                {
                    return string.Format("( '{0}' {1} '{2}' )", left, oper, right);
                }
                else
                {
                    return string.Format("( {0} {1} {2} )", left, oper, right);
                }

            }
            else if (exp is BlockExpression)
            {

            }
            else if (exp is ConditionalExpression)
            {

            }
            else if (exp is MethodCallExpression)
            {
                MethodCallExpression mce = (MethodCallExpression)exp;
                string methodName = mce.Method.Name;
                if (methodName == "Contains")
                {
                    return Contains(methodName, mce, isTure);
                }
                else if (methodName == "StartsWith")
                {
                    return StartsWith(methodName, mce, isTure);
                }
                else if (methodName == "EndsWith")
                {
                    return EndWith(methodName, mce, isTure);
                }
                else if (methodName == "ToString")
                {
                    type = MemberType.Value;
                    return MethodToString(methodName, mce, ref type);
                }
                else
                {
                    type = MemberType.Value;
                    return MethodTo(methodName, mce, ref type);
                }

            }
            else if (exp is ConstantExpression)
            {
                type = MemberType.Value;
                ConstantExpression ce = ((ConstantExpression)exp);
                if (ce.Value == null)
                    return "null";
                else
                {
                    return ce.Value.ToString();
                }
            }
            else if (exp is MemberExpression)
            {
                MemberExpression me = ((MemberExpression)exp);
                if (me.Expression == null || me.Expression.NodeType.ToString() != "Parameter")
                {
                    type = MemberType.Value;
                    object dynInv = null;
                    try
                    {
                        // var dynInv = Expression.Lambda(exp).Compile().DynamicInvoke();原始写法性能极慢,下面写法性能提高了几十倍
                        // var dynInv= Expression.Lambda(me.Expression as ConstantExpression).Compile().DynamicInvoke();
                        var conExp = me.Expression as ConstantExpression;
                        if (conExp != null)
                        {
                            dynInv = (me.Member as System.Reflection.FieldInfo).GetValue((me.Expression as ConstantExpression).Value);
                        }
                        else
                        {

                            var memberInfos = new Stack<MemberInfo>();

                            // "descend" toward's the root object reference:
                            while (exp is MemberExpression)
                            {
                                var memberExpr = exp as MemberExpression;
                                memberInfos.Push(memberExpr.Member);
                                exp = memberExpr.Expression;
                            }

                            // fetch the root object reference:
                            var constExpr = exp as ConstantExpression;
                            var objReference = constExpr.Value;

                            // "ascend" back whence we came from and resolve object references along the way:
                            while (memberInfos.Count > 0)  // or some other break condition
                            {
                                var mi = memberInfos.Pop();
                                if (mi.MemberType == MemberTypes.Property)
                                {
                                    objReference = objReference.GetType()
                                                               .GetProperty(mi.Name)
                                                               .GetValue(objReference, null);
                                }
                                else if (mi.MemberType == MemberTypes.Field)
                                {
                                    objReference = objReference.GetType()
                                                               .GetField(mi.Name)
                                                               .GetValue(objReference);
                                }
                            }
                            dynInv = objReference;
                        }
                    }
                    catch (Exception ex)
                    {
                        if (me.ToString() == "DateTime.Now")
                        {
                            return DateTime.Now.ToString();
                        }
                        Check.Exception(true, "错误信息:{0} \r\n message:{1}", "拉姆达解析出错,参数可支持的函数有 Trim 、Contains 、ObjToXXX、 Convert.ToXXX、Contains、StartsWith和StartsEnd。 ", ex.Message);
                    }

                    if (dynInv == null) return null;
                    else
                        return dynInv.ToString();
                }
                else
                {
                    if (Type == ResolveExpressType.nT)
                    {
                        type = MemberType.Key;
                        return exp.ToString();
                    }

                    string name = me.Member.Name;
                    type = MemberType.Key;
                    return name;
                }
            }
            else if (exp is UnaryExpression)
            {
                UnaryExpression ue = ((UnaryExpression)exp);
                var mex = ue.Operand;
                return CreateSqlElements(mex, ref type, false);
            }
            return null;
        }
Ejemplo n.º 41
0
 public Task<TEntity> FirstAsync(Expression<Func<TEntity, bool>> predicate)
 {
     return _dbSet.FirstAsync(predicate);
 }
Ejemplo n.º 42
0
        protected void OnPropertyChanged<T>([NotNull] Expression<Func<T>> propertyExpression)
        {
            Contract.Requires(propertyExpression != null);

            OnPropertyChanged(PropertySupport.ExtractPropertyName(propertyExpression));
        }
Ejemplo n.º 43
0
        public static MvcHtmlString AutocompleteFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, string actionName, string controllerName)
        {
            string autocompleteUrl = UrlHelper.GenerateUrl(null, actionName, controllerName,
                                                           null,
                                                           html.RouteCollection,
                                                           html.ViewContext.RequestContext,
                                                           includeImplicitMvcValues: true);

            return(html.TextBoxFor(expression, new { data_autocomplete_url = autocompleteUrl }));
        }
Ejemplo n.º 44
0
        public async Task <bool> RemoveAsync(Expression <Func <UserInfo, bool> > express)
        {
            var spec = Specification <UserInfo> .Eval(express);

            return(adminManage.RemoveAt(spec) ? await context.SaveChangesAsync() > 0 : false);
        }
Ejemplo n.º 45
0
        protected bool SetProperty<T>([CanBeNull] ref T backingField, [CanBeNull] T value, [NotNull] Expression<Func<T>> propertyExpression, [NotNull] Action<T, T> changeCallback)
        {
            Contract.Requires(propertyExpression != null);
            Contract.Requires(changeCallback != null);

            return SetProperty(ref backingField, value, PropertySupport.ExtractPropertyName(propertyExpression), changeCallback);
        }
Ejemplo n.º 46
0
 public async Task<PageModel<b_phone_table_type>> GetPage(int page)
 {
     Expression<Func<b_phone_table_type, bool>> whereExpression = a => a.IsDeleted != true;
     return await _b_phone_table_typeServices.Query(whereExpression, page, 10, "");
 }
Ejemplo n.º 47
0
 public CompareModel<T> CompareOneToOne(List<string> exemptProperties, List<string> subObjects, Expression<Func<T, bool>> sourceExpr, Expression<Func<T, bool>> targetExpr, TextWriter outputStream=null)
 {
     CompareModel<T> data = new CompareModel<T>();
     data.ExemptProperties = exemptProperties;
     data.SubObjects = subObjects;
     data.SourceObject = _sourceDb.GetTable<T>().Where(sourceExpr).FirstOrDefault();
     data.TargetObject = _targetDb.GetTable<T>().Where(targetExpr).FirstOrDefault();
     return CompareObjectsValues(data, outputStream);
 }
 internal static MarkedAsDuplicateEvent Create(Expression expression)
 {
     return(new MarkedAsDuplicateEvent(expression));
 }
        public IEnumerable <OrderLine> Find(Expression <Func <OrderLine, Boolean> > predicate)
        {
            var result = _db.OrderLines.Include(o => o.Order).Where(predicate).ToList();

            return(result);
        }
Ejemplo n.º 50
0
 public virtual Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken)
     => _queryCompiler.ExecuteAsync<TResult>(expression, cancellationToken);
Ejemplo n.º 51
0
 public async Task<List<b_phone_table_type>> Get()
 {
     Expression<Func<b_phone_table_type, bool>> whereExpression = a => a.IsDeleted != true;
     return await _b_phone_table_typeServices.Query(whereExpression);
 }
Ejemplo n.º 52
0
 public virtual object Execute(Expression expression)
     => Execute<object>(expression);
 internal MarkedAsDuplicateEvent(Expression expression) : base(expression)
 {
 }
Ejemplo n.º 54
0
 public virtual int Count(Expression<Func<T, bool>> where)
 {
     return dbSet.Count(where);
 }
Ejemplo n.º 55
0
 public virtual IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression)
     => _queryCompiler.ExecuteAsync<TResult>(expression);
Ejemplo n.º 56
0
        protected override Expression VisitMember(MemberExpression node)
        {
            if (phasePhase.get() == ParsePhase.Condition)
            {
                if (node.Expression.NodeType == ExpressionType.Parameter)
                {
                    WhereClause.Append(Alter[node.Member.Name].CqlIdentifier());
                    return node;
                }
                else if (node.Expression.NodeType == ExpressionType.Constant)
                {
                    var val = Expression.Lambda(node).Compile().DynamicInvoke();
                    if (val is CqlToken)
                    {
                        WhereClause.Append("token(");
                        WhereClause.Append((val as CqlToken).Values.First().Encode());
                        foreach (var e in (val as CqlToken).Values.Skip(1))
                        {
                            WhereClause.Append(", ");
                            WhereClause.Append(e.Encode());
                        }
                        WhereClause.Append(")");
                    }
                    else
                    {
                        WhereClause.Append(val.Encode());
                    }
                    return node;
                }
                else if (node.Expression.NodeType == ExpressionType.MemberAccess)
                {
                    var val = Expression.Lambda(node).Compile().DynamicInvoke();
                    WhereClause.Append(val.Encode());
                    return node;
                }
            }
            else if (phasePhase.get() == ParsePhase.SelectBinding)
            {
                var name = node.Member.Name;
                if (node.Expression.NodeType == ExpressionType.Constant || node.Expression.NodeType == ExpressionType.MemberAccess)
                {
                    if (Alter.ContainsKey(currentBindingName.get()))
                    {
                        var val = Expression.Lambda(node.Expression).Compile().DynamicInvoke();
                        Mappings[currentBindingName.get()] = Tuple.Create(name, val, Mappings.Count);
                        SelectFields.Add(name);
                    }
                    else
                    {
                        var val = Expression.Lambda(node).Compile().DynamicInvoke();
                        Mappings[currentBindingName.get()] = Tuple.Create<string,object,int>(null, val, Mappings.Count);
                    }
                    return node;
                }
                else if (node.Expression.NodeType == ExpressionType.Parameter)
                {
                    Mappings[currentBindingName.get()] = Tuple.Create<string, object, int>(name, name, Mappings.Count);
                    SelectFields.Add(name);
                    return node;
                }
            }
            else if (phasePhase.get() == ParsePhase.OrderBy || phasePhase.get() == ParsePhase.OrderByDescending)
            {
                var name = node.Member.Name;
                OrderBy.Add(Alter[(string)name].CqlIdentifier() + (phasePhase.get() == ParsePhase.OrderBy ? " ASC" : " DESC"));

                if ((node.Expression is ConstantExpression))
                {
                    return node;
                }
                else if (node.Expression.NodeType == ExpressionType.Parameter)
                {
                    return node;
                }
            }
            throw new CqlLinqNotSupportedException(node, phasePhase.get());
        }
Ejemplo n.º 57
0
 public virtual TResult Execute<TResult>(Expression expression)
     => _queryCompiler.Execute<TResult>(expression);
Ejemplo n.º 58
0
 public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where, string includes)
 {
     return dbSet.Where(where).ToList();
 }
Ejemplo n.º 59
0
 public virtual IQueryable<TElement> CreateQuery<TElement>(Expression expression)
     => new EntityQueryable<TElement>(this, expression);
Ejemplo n.º 60
-1
        public void ShouldSolveSystemWith1EquationAnd2Variables()
        {
            //x+y=10    x=6; y=4
            //x-y=2
            var variableX = new Variable("x");
            var variableY = new Variable("y");

            var left1FirstEq = new Expression(1, variableX);
            var left2FirstEq = new Expression(1, variableY);
            var rightFirstEq = new Expression(10, Variable.NULL);

            var left1SecondEq = new Expression(1, variableX);
            var left2SecondEq = new Expression(-1, variableY);
            var rightSecondEq = new Expression(2, Variable.NULL);

            var firstEquation = new Equation(new List<Expression>() { left1FirstEq, left2FirstEq }, rightFirstEq);
            var secondEquation = new Equation(new List<Expression>() {left1SecondEq, left2SecondEq}, rightSecondEq);

            var target = new SystemOfEquations(new List<Equation>() {firstEquation, secondEquation});
            target.Solve();
            var resultX = variableX.Value;
            var resultY = variableY.Value;

            Assert.AreEqual(1, resultX.Count);
            Assert.AreEqual(1, resultY.Count);
            Assert.AreEqual(Variable.NULL, resultX.First().Variable);
            Assert.AreEqual(6, resultX.First().Coefficient);
            Assert.AreEqual(Variable.NULL, resultY.First().Variable);
            Assert.AreEqual(4, resultY.First().Coefficient);
        }