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); }
public MethodCall(Expression target, string/*!*/ methodName, Arguments args, Block block, SourceSpan location) : base(args, block, location) { Assert.NotEmpty(methodName); _methodName = methodName; _target = target; }
public void ConversionToLessSpecficWithBoxingToObject() { Expression<object> expr = new Expression<object>("2 + 2"); object result = expr.Evaluate(); Assert.AreEqual(4, result); }
public GreaterThanExpression(Expression left, Expression right) { Operands.Add(left); Operands.Add(right); //TODO validate ParamType ReturnType = typeof (bool); }
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()) }; }
public UnaryExpression(Terminal op, Expression expression) { Operator = op; Expression = expression; AddAttribute(new OperatorAttr(op)); AddChild(expression); }
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); }
public override Expression Parse(System.IO.TextReader reader, TextManager manager) { var expr = new Expression(); expr.Parts.Add(new Text { Spelling = reader.ReadToEnd() }); return expr; }
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; }
/// <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()); }
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)); }
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); }
/// <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; }
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); }
/// <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 ()); } }); }
public override bool Replace(Node oldValue, Node newValue) { return Replace(Value, oldValue, newValue, n => Value = n) || base.Replace(oldValue, newValue); }
public override bool Equals(Expression E) { Product P = E as Product; if (ReferenceEquals(P, null)) return base.Equals(E); return Terms.SequenceEqual(P.Terms); }
/// <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); }
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; }
public Binary(SourceSpan span, Operator op, Expression left, Expression right) : base(span) { _op = op; _left = left; _right = right; }
public static Expression Coalesce(LambdaBuilder builder, Expression left, Expression right) { ParameterExpression temp; Expression result = Coalesce(left, right, out temp); builder.AddHiddenVariable(temp); return result; }
private static MSAst.Expression GetSliceValue(AstGenerator ag, Expression expr) { if (expr != null) { return ag.Transform(expr); } return Ast.Field(null, typeof(MissingParameter).GetField("Value")); }
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); }
public override void SetParent(Expression parent) { base.SetParent(parent); if (Value != null) Value.SetParent(this); }
public virtual IQueryable CreateQuery(Expression expression) => (IQueryable)_genericCreateQueryMethod .MakeGenericMethod(expression.Type.GetSequenceType()) .Invoke(this, new object[] { expression });
public TEntity Single(Expression<Func<TEntity, bool>> predicate) { return _dbSet.Single(predicate); }
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; }
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()); }
public void Evaluate(Expression expression) { this.Visit(expression); }
public async Task<TEntity> SingleOrDefaultAsync(Expression<Func<TEntity, bool>> predicate) { return await _dbSet.SingleOrDefaultAsync(); }
public TEntity SingleOrDefault(Expression<Func<TEntity, bool>> predicate) { return _dbSet.SingleOrDefault(); }
public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> predicate) { return _dbSet.FirstOrDefault(predicate); }
public static LambdaExpression FooReturn2() { Expression<Func<object, bool>> e = f => false; return e; }
public async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> predicate) { return await _dbSet.FirstOrDefaultAsync(predicate); }
/// <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; }
public Task<TEntity> FirstAsync(Expression<Func<TEntity, bool>> predicate) { return _dbSet.FirstAsync(predicate); }
protected void OnPropertyChanged<T>([NotNull] Expression<Func<T>> propertyExpression) { Contract.Requires(propertyExpression != null); OnPropertyChanged(PropertySupport.ExtractPropertyName(propertyExpression)); }
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 })); }
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); }
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); }
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, ""); }
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); }
public virtual Task<TResult> ExecuteAsync<TResult>(Expression expression, CancellationToken cancellationToken) => _queryCompiler.ExecuteAsync<TResult>(expression, cancellationToken);
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); }
public virtual object Execute(Expression expression) => Execute<object>(expression);
internal MarkedAsDuplicateEvent(Expression expression) : base(expression) { }
public virtual int Count(Expression<Func<T, bool>> where) { return dbSet.Count(where); }
public virtual IAsyncEnumerable<TResult> ExecuteAsync<TResult>(Expression expression) => _queryCompiler.ExecuteAsync<TResult>(expression);
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()); }
public virtual TResult Execute<TResult>(Expression expression) => _queryCompiler.Execute<TResult>(expression);
public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where, string includes) { return dbSet.Where(where).ToList(); }
public virtual IQueryable<TElement> CreateQuery<TElement>(Expression expression) => new EntityQueryable<TElement>(this, expression);
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); }