示例#1
0
        public static IParser GetParser(string htmlResponse)
        {
            var isCompactSource = htmlResponse.IndexOf("compact-items wlrdZeroTable") > -1;
            IParser parser = null;

            if(isCompactSource)
                parser = new CompactParser();
            else
                parser = new FullParser();

            parser.SetSource(htmlResponse);
            return parser;
        }
示例#2
0
        public void ODataDemo()
        {
            Parser parser = new ODataParser();
            var    expr1  = parser.Parse <Person, bool>("contains(Address/City,'ams') and FirstName gt 'm'");

            // same query, using another syntax, and so using another parser
            parser = new CompactParser();
            var expr2 = parser.Parse <Person, bool>("Address.City?ams&FirstName>m");

            Assert.AreEqual(expr1.ToString(), expr2.ToString());

            parser = new Parser(new Grammar(ScriptSyntax <DefaultSyntaxExtender> .Instance));
            var    args   = new { a = 10, b = DateTime.Now, c = "foo", d = 10.2 };
            var    expr3  = parser.WithReturnType <double>().Parse("a + day(b) + length(c) + d/2", args);
            var    fn     = expr3.Compile();
            double result = fn(args);

            Debug.WriteLine(result);
        }
示例#3
0
        static int Main(string[] args)
        {
            SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);

            //const string ConnectionString = "Initial Catalog=MiniProf;Data Source=.\\SqlExpress;Integrated Security=true;";
            //using(var conn = new SqlConnection(ConnectionString))
            //{
            //    conn.Open();
            //    conn.Execute(SqlServerStorage.TableCreationScript);
            //}
            //MiniProfiler.Settings.Storage = new SqlServerStorage(ConnectionString);
            MiniProfiler.Settings.ProfilerProvider = new SingletonProfilerProvider();
            MiniProfiler.Settings.ProfilerProvider.Start(ProfileLevel.Info);
            MiniProfiler.Settings.SqlFormatter = new StackExchange.Profiling.SqlFormatters.InlineFormatter();
            MiniProfilerEF6.Initialize();
            MiniProfiler.Start();

            Parser parser     = new CompactParser();
            var    debug      = true;
            Type   entityType = null;

            con.WriteLine("*** type help for command list ***");

            while (true)
            {
                if (entityType != null)
                {
                    System.Console.Write("[enter query for entity '" + entityType.Name + "'] : ");
                }
                else
                {
                    System.Console.Write(": ");
                }
                var input = System.Console.ReadLine();
                switch (input)
                {
                case "quit":
                case "exit":
                    return(0);

                case "cls":
                case "clr":
                    System.Console.Clear();
                    continue;

                case "strict":
                    parser.Grammar.Strict = !parser.Grammar.Strict;
                    System.Console.WriteLine("strict is: " + parser.Grammar.Strict);
                    break;

                case "entity":
                    System.Console.Write("[use entity type] : ");
                    var typeName = System.Console.ReadLine();
                    if (string.IsNullOrEmpty(typeName))
                    {
                        entityType = null;
                        break;
                    }
                    entityType = Type.GetType(typeof(Address).AssemblyQualifiedName.Replace("Address", typeName), false, true);
                    if (entityType == null)
                    {
                        con.WriteLine("Type " + typeName + " not found, use Address or Person");
                    }
                    break;

                case "debug":
                    debug = !debug;
                    System.Console.WriteLine("debug is: " + debug);
                    break;

                case "functions":
                    foreach (var m in parser.Grammar.Functions.Select(m => m.Name).Distinct().OrderBy(s => s))
                    {
                        System.Console.WriteLine(m);
                    }
                    break;

                case "?":
                case "help":
                    System.Console.WriteLine("Commands:");
                    System.Console.WriteLine(" quit       - quit program");
                    System.Console.WriteLine(" cls        - clear screen");
                    System.Console.WriteLine(" strict     - toggle strict on/off");
                    System.Console.WriteLine(" debug      - toggle debug on/off");
                    System.Console.WriteLine(" syntax     - change syntax");
                    System.Console.WriteLine(" functions  - show functions");
                    System.Console.WriteLine(" entity     - set/change entity type as a LINQ query target");
                    System.Console.WriteLine(" <other>    - expression that will be evaluated");
                    break;

                case "syntax":
                    System.Console.Write("[change syntax into] : ");
                    switch (System.Console.ReadLine())
                    {
                    case "odata":
                        parser = new ODataParser();
                        break;

                    case "compact":
                        parser = new CompactParser();
                        break;

                    case "query":
                        parser = new QueryParser();
                        break;

                    case "math":
                        parser = new MathParser();
                        break;

                    default:
                        System.Console.WriteLine("* Unknown syntax. Known syntax types: odata,compact,query,math");
                        break;
                    }
                    break;

                default:
                    if (entityType != null)
                    {
                        if (!string.IsNullOrEmpty(input))
                        {
                            var result = ExpressionToLinqExecuter.Execute(parser, entityType, input);
                            con.WriteLine("* Count: " + result.Count());
                            MiniProfiler.Settings.ProfilerProvider.Stop(false);
                            WriteExecutedQueries();
                            //MiniProfiler.Settings.Storage.Save(MiniProfiler.Current);
                            MiniProfiler.Settings.ProfilerProvider.Start(ProfileLevel.Info);
                        }
                        else
                        {
                            entityType = null;
                        }
                        break;
                    }
                    try
                    {
                        var lambda    = parser.Parse <object, object>(input);
                        var @delegate = lambda.Compile();
                        var result    = @delegate(new object());
                        if (debug)
                        {
                            System.Console.WriteLine("? {0} => {1}", lambda, lambda.Simplify());
                        }
                        System.Console.WriteLine("= {0}", result ?? "NULL");
                    }
                    catch (XPressionException ex)
                    {
                        System.Console.WriteLine(ex.FullMessage);
                    }
                    catch (Exception ex)
                    {
                        System.Console.WriteLine(ex.Message);
                    }
                    break;
                }
            }
        }