Exemple #1
0
        public CSharpExpressionBuilder()
        {
            _expressionTypeResolver = new ExpressionTypeResolver();

            _methodNames = new Dictionary <string, string>
            {
                { "+", "Add" },
                { "-", "Subtract" },
                { "*", "Multiply" },
                { "/", "Divide" },
                { "%", "Modulus" },
                { "AND", "AndAlso" },
                { "OR", "OrElse" },
                { "=", "Equal" },
                { "<>", "NotEqual" },
                { ">", "GreaterThan" },
                { ">=", "GreaterThanOrEqual" },
                { "<", "LessThan" },
                { "<=", "LessThanOrEqual" },
                { "abs", "Abs" },
                { "ceiling", "Ceiling" },
                { "floor", "Floor" },
                { "power", "Pow" },
                { "substring", "Substring" },
                { "contains", "Contains" },
                { "left", "Left" },
                { "right", "Right" },
                { "len", "Length" },
                { "replace", "Replace" },
            };
        }
Exemple #2
0
        public CSharpExpressionBuilder()
        {
            _expressionTypeResolver = new ExpressionTypeResolver();

            _dispatchTable = new Dictionary <Type, Func <AstNode, Expression> >
            {
                { typeof(StringNode), node => Build((StringNode)node) },
                { typeof(NumberNode), node => Build((NumberNode)node) },
                { typeof(DateNode), node => Build((DateNode)node) },
                { typeof(BooleanNode), node => Build((BooleanNode)node) },
                { typeof(NilNode), node => Build((NilNode)node) },
                { typeof(BinaryExpressionNode), node => Build((BinaryExpressionNode)node) },
                { typeof(UnaryExpressionNode), node => Build((UnaryExpressionNode)node) },
                { typeof(TupleNode), node => Build((TupleNode)node) },
                { typeof(IifFunctionNode), node => Build((IifFunctionNode)node) },
                { typeof(FunctionNode), node => Build((FunctionNode)node) },
                { typeof(ConcatFunctionNode), node => Build((ConcatFunctionNode)node) },
                { typeof(MinFunctionNode), node => Build((MinFunctionNode)node) },
                { typeof(MaxFunctionNode), node => Build((MaxFunctionNode)node) },
                { typeof(IcaseFunctionNode), node => Build((IcaseFunctionNode)node) },
                { typeof(TodayNode), node => Build((TodayNode)node) },
                { typeof(ObjectPropertyNode), node => Build((ObjectPropertyNode)node) },
            };

            _methodNames = new Dictionary <string, string>
            {
                { "+", "Add" },
                { "-", "Subtract" },
                { "*", "Multiply" },
                { "/", "Divide" },
                { "%", "Modulus" },
                { "AND", "AndAlso" },
                { "OR", "OrElse" },
                { "=", "Equal" },
                { "<>", "NotEqual" },
                { ">", "GreaterThan" },
                { ">=", "GreaterThanOrEqual" },
                { "<", "LessThan" },
                { "<=", "LessThanOrEqual" },
                { "abs", "Abs" },
                { "ceiling", "Ceiling" },
                { "floor", "Floor" },
                { "power", "Pow" },
                { "substring", "Substring" },
                { "contains", "Contains" },
                { "left", "Left" },
                { "right", "Right" },
                { "len", "Length" },
                { "replace", "Replace" },
            };
        }