C# CommandLine.Parse方法代码示例

        static int Main( string[] args )
        {
            CommandLine     commandLine = new CommandLine();
            int             returnVal = 0;

            try
            {
                commandLine.Parse( args );

                if( commandLine.Mode == SyncAppMode.RunEngine )
                {
                    RunSyncEngine( commandLine );
                }
                else if( commandLine.Mode == SyncAppMode.CreateConfigTemplate )
                {
                    CreateConfigTemplateFile( commandLine );
                }
            }
            catch( Exception e )
            {
                Console.Error.WriteLine( "Error: {0}", e.ToString() );
                returnVal = -1;
            }

            if( commandLine.PauseOnExit )
            {
                Console.WriteLine();
                Console.WriteLine( "Press any key to exit..." );
                Console.ReadKey( true );
            }

            return returnVal;
        }

        static void Main(string[] args)
        {
            var commandLine = new CommandLine();
            commandLine.Parse(args);

            var controller = new Controller(commandLine, new Settings());
            controller.Run();

            Console.WriteLine("");
            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            // Parse Command Line.
            var options = new CommandLine();
            if(!options.Parse(args))
                return;

            // Parse link file.
            var links = new LinkFile();
            if(!links.Load(options.LinkFile))
                return;

            MainLoop(options, links);
        }

        public void CustomGame()
        {
            const int game_cnt = 5; // number of games to pass as parameters
            CommandLine line;
            string [] args;
            GameManager.GameLocator [] games;
            GameManager gm = new GameManager ();
            StringBuilder game_list = new StringBuilder ();
            int [] candidates; // Stores the indexes of the games passed as parameters
            int cand_idx = 0;

            games = gm.AvailableGames;
            candidates = new int [game_cnt];

            for (int i = 0; i < games.Length; i++)
            {
                if (games[i].IsGame == false)
                    continue;

                Game game = (Game) Activator.CreateInstance (games[i].TypeOf, true);
                game.Variant = games[i].Variant;

                if (cand_idx > 0)
                    game_list.Append (CommandLine.GAME_SEPARATOR + " ");

                game_list.Append (game.Name);
                candidates [cand_idx++] = i;

                if (cand_idx >= game_cnt)
                    break;
            }

            args = new string [2];
            args [0] = "--customgame";
            args [1] = game_list.ToString ();

            line = new CommandLine (args);
            line.Parse ();

            Assert.AreEqual (cand_idx, line.PlayList.Length);

            cand_idx = 0;
            foreach (int idx in line.PlayList)
                Assert.AreEqual (idx, candidates [cand_idx++]);
        }

        static void Main(string[] args)
        {
            //
            // This is the Bizkit's test area.
            //
            CommandLine cmd = new CommandLine();

            SwitchArg switch_arg = new SwitchArg("testArg", "Test Arg", "Specify if you want to test something");
            cmd.Add(switch_arg);

            ValueArg<int> value_int_arg = new ValueArg<int>("intArg", "Int Arg", "Specify if you want to set int value", true, 5);
            cmd.Add(value_int_arg);

            ValueArg<string> value_string_arg = new ValueArg<string>("stringArg", "String Arg", "Specify if you want to set string value", true, "EMPTY_STRING");
            cmd.Add(value_string_arg);

            Type t = value_int_arg.GetType().GetGenericArguments()[0];

            string[] arguments = new string[] { "dummy_executable_name.exe", "-testArg", "-intArg", "100", "-stringArg", "SomeText" };

            try
            {
                cmd.Parse(arguments);
            }
            catch (System.Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

            //
            // Tests of values stored in arguments
            //
            bool b = switch_arg.Value;
            System.Diagnostics.Debug.Assert(switch_arg.Value == true);

            int i = value_int_arg.Value;
            System.Diagnostics.Debug.Assert(value_int_arg.Value == 100);

            string s = value_string_arg.Value;
            System.Diagnostics.Debug.Assert(value_string_arg.Value == "SomeText");
        }

        static void Main(string[] args)
        {
            var options = new CommandLine();

            try
            {
                // Read arguments from command line.
                options.Parse(args);

                // Validate all options.
                options.Validate();

                var kernel = new Kernel();

                var s = Stopwatch.StartNew();

                // Run log import
                kernel.Run(options);

                s.Stop();

                ConsoleWriter.WriteInfo("Time taken: {0}", s.Elapsed);

                Environment.Exit(0);
            }
            catch (UsageException exception)
            {
                ConsoleWriter.WriteError(Environment.NewLine + exception.Message);

                options.PrintUsage(Console.Error);

                Environment.Exit(2);
            }
            catch (SystemException exception)
            {
                ConsoleWriter.WriteError(exception.ToString());

                Environment.Exit(1);
            }
        }

        public void Execute(string command)
        {
            var commandLine = new CommandLine(command);
            this.historys.Add(commandLine);
            commandLine.Parse(
                this.Engine.GetCommandMember(z => z.CommandParser),
                this.Engine.GetCommandMember(z => z.CommandParameterParser));

            if (commandLine.CommandBlock == null)
            {
                this.Execute(this.Engine.GetCommandMember(z => z.NoneInput), commandLine);
                this.Execute(this.Engine.GetCommandMember(z => z.Helper), commandLine);
            }
            else
            {
                var mapper = this.GetCommandMapper(commandLine);
                if (mapper != null)
                {
                    this.Execute(mapper, commandLine);
                    return;
                }
                this.Execute(this.Engine.GetCommandMember(z => z.Helper), commandLine);
            }
        }

        public static void Main(string [] args)
        {
            try {
                Unix.SetProcessName ("gbrainy");
            }
            catch (Exception e)
            {
                Console.WriteLine ("gbrainy.Main. Could not set process name. Error {0}", e);
            }

            DateTime start_time = DateTime.Now;

            InitCoreLibraries ();

            GtkClient app = new GtkClient ();
            CommandLine.Version ();

            CommandLine line = new CommandLine (args);
            line.Parse ();

            if (line.Continue == false)
                return;

            Gtk.Application.Init ();

            app.Initialize ();
            // Set RandomOrder before setting the custom list then it has effect of custom games
            app.Session.GameManager.RandomOrder = line.RandomOrder;
            if (line.PlayList.Length > 0) {
                app.Session.GameManager.PlayList = line.PlayList;
                app.InitialSessionType = GameSession.Types.Custom;
            }
            app.ProcessDefaults ();
            ThemeManager.Load ();

            TimeSpan span = DateTime.Now - start_time;
            Console.WriteLine (Catalog.GetString ("Startup time {0}"), span);
            Gtk.Application.Run ();
        }

        public void RandomOrder()
        {
            CommandLine line;
            string [] args;

            args = new string [1];
            args [0] = "--norandom";

            line = new CommandLine (args);
            Assert.AreEqual (true, line.RandomOrder);
            line.Parse ();

            Assert.AreEqual (false, line.RandomOrder);
        }

        public Application(ApplicationInfo info)
        {
            nativeInterface = info.nativeInterface;
            width = info.width;
            height = info.height;
            realWidth = info.realWidth;
            realHeight = info.realHeight;

            sharedApplication = this;

            context = new Context();
            updatables = new UpdatableList(1);
            drawables = new DrawableList(1);

            cmdLine = CreateCommandLine();
            cmdLine.Parse(info.args);
        }