C# ServiceProcess.ServiceBase类代码示例

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main()
        {
            string serviceFolder = Path.GetDirectoryName( System.Reflection.Assembly.GetExecutingAssembly().Location );
            SqlServerTypes.Utilities.LoadNativeAssemblies( serviceFolder );
            System.Diagnostics.Debugger.Launch();
            RockMemoryCache.Clear();

            // set the current directory to the same as the current exe so that we can find the web.connectionstrings.config
            Directory.SetCurrentDirectory( serviceFolder );
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                new JobScheduler()
            };

            //// NOTE: To run and debug this service in Visual Studio uncomment out the debug code below
            //// Make sure you have a web.connectionstring.config in your debug/bin directory!
            //JobScheduler debug = new JobScheduler();
            //debug.StartJobScheduler();

            // if you'd rather debug the app running as an actual service do the following:
            // 1. Install the app as a service 'installutil <yourproject>.exe' (installutil is found C:\Windows\Microsoft.NET\Framework64\v4.0.30319\)
            // 2. Add the line System.Diagnostics.Debugger.Launch(); where you'd like to debug
            //
            // Note: to uninstall the service run 'installutil /u <yourproject>.exe'
            //System.Diagnostics.Debugger.Launch();

            ServiceBase.Run( ServicesToRun );
        }

    	/// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
			var commandLine = new CommandLine(args);

			if (commandLine.RunAsService)
			{
				var ServicesToRun = new ServiceBase[] { new ShredHostService() };
				ServiceBase.Run(ServicesToRun);
			}
			else if (!String.IsNullOrEmpty(commandLine.PreviousExeConfigurationFilename))
			{
				var groups = SettingsGroupDescriptor.ListInstalledLocalSettingsGroups();
				groups.Add(new SettingsGroupDescriptor(typeof (ShredSettingsMigrator).Assembly.GetType("ClearCanvas.Server.ShredHost.ShredHostServiceSettings")));
				foreach (var group in groups)
					SettingsMigrator.MigrateSharedSettings(group, commandLine.PreviousExeConfigurationFilename);

				ShredSettingsMigrator.MigrateAll(commandLine.PreviousExeConfigurationFilename);
			}
			else
			{
				ShredHostService.InternalStart();
				Console.WriteLine("Press <Enter> to terminate the ShredHost.");
				Console.WriteLine();
				Console.ReadLine();
				ShredHostService.InternalStop();
			}
        }

        static void Main()
        {
#if DEBUG
            try
            {
                ServiceStartup.Run();
                Console.WriteLine("Press <CTRL>+C to stop.");
                SetConsoleCtrlHandler(ConsoleCtrlCheck, true);
                Thread.Sleep(Timeout.Infinite);
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: {0}: {1}", ex.GetType().Name, ex.Message);
                throw;
            }
            finally
            {
                ServiceStartup.Stop();
            }
#else
            var appHost = ServiceStartup.GetAppHostListner();

            var servicesToRun = new ServiceBase[] 
            { 
                new WinService(appHost, ServiceStartup.ListeningOn) 
            };
            ServiceBase.Run(servicesToRun);
#endif

        }

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main()
        {
            #if (!DEBUG)
              ServiceBase[] ServicesToRun;
              ServicesToRun = new ServiceBase[]
                        {
                          new TimerService()
                        };
              ServiceBase.Run(ServicesToRun);

              #else
              //// Debug code: this allows the process to run as a non-service.

              //// It will kick off the service start point, but never kill it.

              //// Shut down the debugger to exit

              TimerService service = new TimerService();
              service.StartService(false, false, true);

              //// Put a breakpoint on the following line to always catch
              //// your service when it has finished its work
              System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);

              #endif
        }

        static void Main()
        {
            if (!Environment.UserInteractive)
            {
                // Startup as service.
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[]
                {
                    new Service1()
                };
                ServiceBase.Run(ServicesToRun);
            }
            else
            {
                // Startup as application
                try
                {
                    var options = System.Configuration.ConfigurationManager.GetSection("CrawlerOptions") as CrawlerOptions;
                    logger.Info("Config is {0}", options);
                    var crawler = new Crawler(options);
                    crawler.Start();
                }
                catch (Exception ex)
                {
                    logger.Fatal(ex);
                }

            }


        }

        /// <summary>
        ///     The main entry point for the application.
        /// </summary>
        private static void Main()
        {
            //#if DEBUG
            //            //If the mode is in debugging
            //            //create a new service instance
            //            var myService = new MonitoringUnit();
            //            //call the start method - this will start the Timer.
            //            myService.Start();
            //            //Set the Thread to sleep
            //            Thread.Sleep(1000000000);
            //            Console.Read();
            //#else
            //var servicesToRun = new ServiceBase[]
            //{
            //    new MonitoringUnit()
            //};
            //ServiceBase.Run(servicesToRun);
            //#endif

            var servicesToRun = new ServiceBase[]
            {
                new MonitoringUnit()
            };
            ServiceBase.Run(servicesToRun);
        }

 private static void Main()
 {
     try
     {
         AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
     #if DEBUG
     var s = new Service1();
     new Error().Add("moo");
     s.OnDebug();
     System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
     #else
         ServiceBase[] ServicesToRun;
         ServicesToRun = new ServiceBase[]
     {
         new Service1()
     };
         ServiceBase.Run(ServicesToRun);
     #endif
     }
     catch (Exception e)
     {
         var message =
         e.Message + Environment.NewLine + e.Source + Environment.NewLine + e.StackTrace
         + Environment.NewLine + e.InnerException;
         new Error().Add(message);
     }
 }

        public HostService(ServiceBase[] services)
        {
            this.Services = services;
            InitializeComponent();

            OnStartMethod = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.NonPublic | BindingFlags.Instance);
        }

        public void Run()
        {
            _log.Debug("[Topshelf] Starting up as a windows service application");
            var servicesToRun = new ServiceBase[] {this};

            Run(servicesToRun);
        }

        static void Main(string[] args)
        {
            #if Service
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                new HttpService()
            };
            ServiceBase.Run(ServicesToRun);
            #else

            Console.BufferWidth = 120;
            Console.BufferHeight = 1024;

            StaticServerStuff.args = args;
            StaticServerStuff.Init();

            while (true)
            {
                Console.Write("\r" + StaticServerStuff.promt);
                try
                {
                    StaticServerStuff.ProcessCommand(Console.ReadLine());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            #endif
        }

 /// <summary>
 /// The main entry point for the application.
 /// </summary>
 static void Main(string[] args)
 {
     if (args.Length == 0)
     {
         ServiceBase[] ServicesToRun;
         ServicesToRun = new ServiceBase[]
         {
             new SetItUpService()
         };
         ServiceBase.Run(ServicesToRun);
     }
     else if (args.Length == 1)
     {
         if (args[0] == "install")
         {
             InstallService();
             StartService();
         }
         if (args[0] == "uninstall")
         {
             StopService();
             UninstallService();
         }
     }
 }

		static void Main(string[] args)
		{
			try
			{
				// service that contains a single engine which automatically discovers ISchedulerTask implementations
				var service = new SingleSchedulerEngineExecutionService<AllHostTasksSchedulerEngine>("MyTaskSchedulerService");

				// to manually control included ISchedulerTasks, create your own engine by inheriting from SchedulerEngine.
				// to have more engines running concurrently, create your own scheduler engine executor by inheriting from SchedulerEngineExecutionServiceBase

				//runnning the service as any other windows service:
				if (Environment.UserInteractive)
				{
					Console.WriteLine("Starting ExampleService in command-line mode ..");
					Console.WriteLine("Press CTRL-C to terminate ..");

					service.Start();
					Console.ReadLine();
					service.Stop();
				}
				else
				{
					var ServicesToRun = new ServiceBase[] { service };
					ServiceBase.Run(ServicesToRun);
				}
			}
			catch (Exception exception)
			{
				Debugger.Break();
				throw;
			}
		}

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main()
        {
            String[] myargs = Environment.GetCommandLineArgs();
            if (myargs.Length > 1)
            {
                String arg = myargs[1].ToLower();
                if ((arg == "-install") || (arg == "-i"))
                {
                    String[] args = new String[1];
                    args[0] = Assembly.GetExecutingAssembly().Location;
                    ExecuteInstallUtil(args);
                }
                if ((arg == "-uninstall") || (arg == "-u"))
                {
                    String[] args = new String[2];
                    args[0] = Assembly.GetExecutingAssembly().Location;
                    args[1] = "-u";
                    ExecuteInstallUtil(args);
                }
                return;
            }

            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                new AnvizService()
            };
            ServiceBase.Run(ServicesToRun);
        }

 /// <summary>
 /// 应用程序的主入口点。
 /// </summary>
 static void Main()
 {
     int type = ServiceConfigs.ServiceType;
     ServiceBase[] ServicesToRun = null;
     if (type == 1)
     {
         ServicesToRun = new ServiceBase[] 
         { 
             new SyncMessageService() 
         };
     }
     //else if (type == 2)
     //{
     //    ServicesToRun = new ServiceBase[] 
     //    { 
     //        new MQConsumerService() 
     //    };
     //}
     //else
     //{
     //    ServicesToRun = new ServiceBase[] 
     //    { 
     //        new SyncMessageService(),
     //        new MQConsumerService() 
     //    };
     //}
     ServiceBase.Run(ServicesToRun);
 }

 /// <summary>
 /// The main entry point for the application.
 /// </summary>
 static void Main()
 {
     if (Type.GetType("Mono.Runtime") != null // mono-service2 sucks; run as foreground process instead
     #if DEBUG
         || Debugger.IsAttached
     #endif
         )
     {
         try
         {
             var svc = new FooSyncService();
             var args = Environment.GetCommandLineArgs();
             svc.Start(args.Where((arg, index) => index > 0).ToArray());
         }
         catch (Exception ex)
         {
             Console.WriteLine("Unhandled {0}: {1}", ex.GetType().Name, ex.Message);
     Console.WriteLine(ex.StackTrace);
         }
     }
     else
     {
         ServiceBase[] ServicesToRun;
         ServicesToRun = new ServiceBase[]
         {
             new FooSyncService()
         };
         ServiceBase.Run(ServicesToRun);
     }
 }