/// <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 );
}
static void Main(string[] args)
{
AddTraceListeners();
if (Environment.UserInteractive == false)
{
ServiceBase[] ServicesToRun = new ServiceBase[] { new ReportService() };
ServiceBase.Run(ServicesToRun);
}
else
{
CreateMethodCache();
Console.Clear();
Console.ForegroundColor = ConsoleColor.White;
Console.WindowWidth = 80;
Console.WindowHeight = 20;
Console.BufferWidth = 100;
Console.BufferHeight = 120;
Console.Title = "ServiceProvider";
if (args.Length > 0)
{
RunCommand(args);
return;
}
StartService();
MainLoop();
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new TrackerService()
};
if (System.Environment.UserInteractive)
{
string parameter = string.Concat(args);
switch (parameter)
{
case "--install":
ManagedInstallerClass.InstallHelper(new string[] { Assembly.GetExecutingAssembly().Location });
break;
case "--uninstall":
ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
break;
}
}
else
{
ServiceBase.Run(ServicesToRun);
}
}
/// <summary>
/// 應用程式的主要進入點。
/// </summary>
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
if (System.Environment.UserInteractive)
{
string parameter = string.Concat(args);
switch (parameter)
{
case "--install":
ManagedInstallerClass.InstallHelper(new string[] { Assembly.GetExecutingAssembly().Location });
break;
case "--uninstall":
ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
break;
}
}
else
{
ServiceBase[] ServicesToRun = new ServiceBase[]
{
new ALOLService_v2()
};
ServiceBase.Run(ServicesToRun);
}
}
private static void Main(string[] args) {
// Install as service, see http://stackoverflow.com/a/12703878
if (Environment.UserInteractive) {
try {
string parameter = string.Concat(args);
switch (parameter) {
case "--install":
ManagedInstallerClass.InstallHelper(new[] { Assembly.GetExecutingAssembly().Location });
break;
case "--uninstall":
ManagedInstallerClass.InstallHelper(new[] { "/u", Assembly.GetExecutingAssembly().Location });
break;
}
}
catch (Exception ex) {
Console.WriteLine("Error on (un)install of Hive Slave service: " + Environment.NewLine + ex);
}
} else {
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new JanitorService()
};
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);
}
static void Main()
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { new WMSWCFService() };
ServiceBase.Run(ServicesToRun);
}
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>
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();
}
}
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);
}
}
/// <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
}
public void Run()
{
_log.Debug("[Topshelf] Starting up as a windows service application");
var servicesToRun = new ServiceBase[] {this};
Run(servicesToRun);
}
/// <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);
}
/// <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();
}
}
}
public HostService(ServiceBase[] services)
{
this.Services = services;
InitializeComponent();
OnStartMethod = typeof(ServiceBase).GetMethod("OnStart", BindingFlags.NonPublic | BindingFlags.Instance);
}
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
}
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>
/// 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);
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
public static void Main(string[] args)
{
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
if (args.Length > 0)
{
// Parse the command line args
var install = ParseCommandLine(args);
if (install == true)
{
InstallationManager.Install(args);
}
else if (install == false)
{
InstallationManager.Uninstall(args);
}
else
{
Trace.Listeners.Add(new ConsoleTraceListener());
Trace.WriteLine("Debugging press return to exit...");
var svc = new SyslogSharpService();
svc.Debug();
Console.ReadLine();
Trace.WriteLine("Finished.");
// Console.WriteLine("Invalid command line args -i for install or -u for uninstall");
}
}
else
{
var servicesToRun = new ServiceBase[] { new SyslogSharpService() };
ServiceBase.Run(servicesToRun);
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
if (args.Length > 0)
{
NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging(NLog.LogLevel.Debug);
if (args[0] == "-debug")
{
Debug(args);
}
else if (args[0] == "-testTask")
{
if (args.Length < 2) throw new Exception("Task file name missing");
TestTask(args[1]);
}
else if (args[0] == "-testJob")
{
if (args.Length < 2) throw new Exception("Job ID missing");
TestJob(args[1]);
}
else
{
Console.WriteLine("Invalid arguments specified.");
Console.WriteLine("Possible options: \n-debug\n-testTask [task json file]\n-testJob [jobId]");
}
return;
}
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
}
static void Main(string[] args)
{
EnsureBuildNumberIsPutIntoSummaryFile();
Dictionary<string,string> arguments = StringUtilities.ParseCommandLine(args);
// If there is a -Service switch then start as a service otherwise start as a regular application
if (arguments.ContainsKey("-Service"))
{
int maximumNumberOfCores = -1;
if (arguments.ContainsKey("-MaximumNumberOfCores"))
maximumNumberOfCores = Convert.ToInt32(arguments["-MaximumNumberOfCores"]);
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new RunnerService(maximumNumberOfCores)
};
ServiceBase.Run(ServicesToRun);
}
else
{
if (!RunJobFromCommandLine(args))
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm(args));
}
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
if (args.Length > 0)
{
// Install service
if (args[0].Trim().ToLower() == "/i")
{
ManagedInstallerClass.InstallHelper(new string[] { "/i", Assembly.GetExecutingAssembly().Location });
return;
}
// Uninstall service
if (args[0].Trim().ToLower() == "/u")
{
ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
return;
}
}
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new ServiceOne(),
new ServiceTwo()
};
ServiceBase.Run(ServicesToRun);
}
//
// http://coding.abel.nu/2012/05/debugging-a-windows-service-project/
static void RunInteractive(ServiceBase[] servicesToRun)
{
Console.WriteLine("Services running in interactive mode.");
Console.WriteLine();
MethodInfo onStartMethod = typeof(ServiceBase).GetMethod("OnStart",
BindingFlags.Instance | BindingFlags.NonPublic);
foreach (ServiceBase service in servicesToRun)
{
Console.Write("Starting {0}...", service.ServiceName);
onStartMethod.Invoke(service, new object[] { new string[] { } });
Console.Write("Started");
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(
"Press any key to stop the services and end the process...");
Console.ReadKey();
Console.WriteLine();
MethodInfo onStopMethod = typeof(ServiceBase).GetMethod("OnStop",
BindingFlags.Instance | BindingFlags.NonPublic);
foreach (ServiceBase service in servicesToRun)
{
Console.Write("Stopping {0}...", service.ServiceName);
onStopMethod.Invoke(service, null);
Console.WriteLine("Stopped");
}
Console.WriteLine("All services stopped.");
// Keep the console alive for a second to allow the user to see the message.
Thread.Sleep(1000);
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
// resolve debug mode
bool runAsService = !args.Contains("-debug");
SiLADemoProviderService service = new SiLADemoProviderService();
if (runAsService)
{
ServiceBase[] servicesToRun;
servicesToRun = new ServiceBase[]
{
service
};
ServiceBase.Run(servicesToRun);
}
else
{
// start service for debugging
service.Start();
Console.WriteLine("- Running: Hit any key to abort -");
Console.ReadKey();
// stop
service.Stop();
}
}
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main(string[] args)
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
// var service = new Service1();
//#if DEBUG
// service.Start(args);
// Console.WriteLine("Service started, press any key to kill");
// Console.ReadKey();
// service.Stop();
//#else
// ServiceBase.Run(new ServiceBase[] { service });
//#endif
}
static void Main(String[] args) {
bool service = false;
Queue<String> vars = new Queue<string>();
foreach (String v in args) vars.Enqueue(v);
while (vars.Count != 0) {
String a = vars.Dequeue();
if (a.StartsWith("@")) {
foreach (String v in CLUt.Parse(File.ReadAllText(a.Substring(1), Encoding.Default))) vars.Enqueue(v);
continue;
}
if (a.StartsWith("/s=")) {
als.Add(a.Substring(3));
}
if (a == "/service") {
service = true;
}
}
if (service) {
ServiceBase[] ServicesToRun = new ServiceBase[] { new Program() };
ServiceBase.Run(ServicesToRun);
}
else {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(als));
}
}
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(string[] args)
{
if (args != null && args.Length == 1 && args[0].Length > 1 && ((int)args[0][0] == 45 || (int)args[0][0] == 47))
{
switch (args[0].Substring(1).ToLower())
{
case "install":
case "i":
ServiceInstaller.InstallMe();
break;
case "uninstall":
case "u":
ServiceInstaller.UninstallMe();
break;
case "start":
ServiceInstaller.StartMe("EIA Model Service");
break;
case "stop":
ServiceInstaller.StopMe("EIA Model Service");
break;
}
}
else
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new ParserService()
};
ServiceBase.Run(ServicesToRun);
}
}
/// <summary>
/// Der Haupteinstiegspunkt für die Anwendung.
/// </summary>
static void Main(string[] args)
{
if (!Environment.UserInteractive)
{
var ServicesToRun = new ServiceBase[]
{
new BarcodeScannerService()
};
ServiceBase.Run(ServicesToRun);
}
else
{
try
{
EnableConsole();
var service = new BarcodeScannerService();
service.StartForeground(args);
}
catch (Exception exc)
{
Console.WriteLine(exc.Message);
var innerExc = exc.InnerException;
while (innerExc != null)
{
Console.WriteLine(innerExc.Message);
innerExc = innerExc.InnerException;
}
}
}
}
public Task Run()
{
System.ServiceProcess.ServiceBase[] ServicesToRun = new System.ServiceProcess.ServiceBase[] { this };
System.ServiceProcess.ServiceBase.Run(ServicesToRun);
return(Task.CompletedTask);
}
/// <include file='doc\ServiceBase.uex' path='docs/doc[@for="ServiceBase.Run1"]/*' />
/// <devdoc>
/// <para>Provides the main
/// entry point for an executable that contains a single
/// service. Loads the service into memory so it can be
/// started.</para>
/// </devdoc>
public static void Run(ServiceBase service)
{
Run(new ServiceBase[] { service });
}
// The main entry point for the process
static void Main()
{
System.ServiceProcess.ServiceBase[] ServicesToRun;
ServicesToRun = new System.ServiceProcess.ServiceBase[] { new IntegrationServer() };
System.ServiceProcess.ServiceBase.Run(ServicesToRun);
}
/// <devdoc>
/// <para>Provides the main entry point for an executable that
/// contains multiple associated services. Loads the specified services into memory so they can be
/// started.</para>
/// </devdoc>
public static unsafe void Run(ServiceBase[] services)
{
if (services == null || services.Length == 0)
{
throw new ArgumentException(SR.NoServices);
}
IntPtr entriesPointer = Marshal.AllocHGlobal(checked ((services.Length + 1) * sizeof(SERVICE_TABLE_ENTRY)));
Span <SERVICE_TABLE_ENTRY> entries = new Span <SERVICE_TABLE_ENTRY>((void *)entriesPointer, services.Length + 1);
entries.Clear();
try
{
bool multipleServices = services.Length > 1;
// The members of the last entry in the table must have NULL values to designate the end of the table.
// Leave the last element in the entries span to be zeroed out.
for (int index = 0; index < services.Length; ++index)
{
ServiceBase service = services[index];
service.Initialize(multipleServices);
// This method allocates on unmanaged heap; Make sure that the contents are freed after use.
entries[index] = service.GetEntry();
}
// While the service is running, this function will never return. It will return when the service
// is stopped.
// After it returns, SCM might terminate the process at any time
// (so subsequent code is not guaranteed to run).
bool res = StartServiceCtrlDispatcher(entriesPointer);
foreach (ServiceBase service in services)
{
if (service._startFailedException != null)
{
// Propagate exceptions throw during OnStart.
// Note that this same exception is also thrown from ServiceMainCallback
// (so SCM can see it as well).
service._startFailedException.Throw();
}
}
string errorMessage = "";
if (!res)
{
errorMessage = new Win32Exception().Message;
Console.WriteLine(SR.CantStartFromCommandLine);
}
foreach (ServiceBase service in services)
{
service.Dispose();
if (!res)
{
service.WriteLogEntry(SR.Format(SR.StartFailed, errorMessage), true);
}
}
}
finally
{
// Free the pointer to the name of the service on the unmanaged heap.
for (int i = 0; i < entries.Length; i++)
{
Marshal.FreeHGlobal(entries[i].name);
}
// Free the unmanaged array containing the entries.
Marshal.FreeHGlobal(entriesPointer);
}
}
