Ejemplos de System.Linq.Expressions Expression.Decrement en C# (CSharp)

Decrement() public static method

Creates a UnaryExpression that represents the decrementing of the expression by 1.

public static Decrement ( Expression expression ) : UnaryExpression
expression	Expression	An to decrement.
return	UnaryExpression

Ejemplo n.º 1

Archivo: IncrDecrVisitor.cs Proyecto: NikitaChernyavskii/Epam-Mentoring-D2-D3

        protected override Expression1 VisitBinary(BinaryExpression node)
        {
            if (node.NodeType != ExpressionType.Add && node.NodeType != ExpressionType.Subtract)
            {
                return(base.VisitBinary(node));
            }
            if (node.Left.NodeType != ExpressionType.Parameter && node.Left.NodeType != ExpressionType.Constant)
            {
                return(base.VisitBinary(node));
            }

            ParameterExpression param    = (ParameterExpression)node.Left;
            ConstantExpression  constant = (ConstantExpression)node.Right;

            if (constant.Type != typeof(int) || (int)constant.Value != 1)
            {
                return(base.VisitBinary(node));
            }

            if (node.NodeType == ExpressionType.Add)
            {
                return(Expression1.Increment(param));
            }

            return(Expression1.Decrement(param));
        }

Ejemplo n.º 2

Archivo: Deserializer.UnaryExpression.cs Proyecto: drigofonte/expression-json-serializer-portable

        private UnaryExpression UnaryExpression(
            ExpressionType nodeType, System.Type type, JObject obj)
        {
            var operand = this.Prop(obj, "operand", this.Expression);
            var method  = this.Prop(obj, "method", this.Method);

            switch (nodeType)
            {
            case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));

            case ExpressionType.Convert: return(Expr.Convert(operand, type, method));

            case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));

            case ExpressionType.Decrement: return(Expr.Decrement(operand, method));

            case ExpressionType.Increment: return(Expr.Increment(operand, method));

            case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));

            case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));

            case ExpressionType.Negate: return(Expr.Negate(operand, method));

            case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));

            case ExpressionType.Not: return(Expr.Not(operand, method));

            case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));

            case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));

            case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));

            case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));

            case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));

            case ExpressionType.Quote: return(Expr.Quote(operand));

            case ExpressionType.Throw: return(Expr.Throw(operand, type));

            case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));

            case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));

            case ExpressionType.Unbox: return(Expr.Unbox(operand, type));

            default: throw new NotSupportedException();
            }
        }