C#实现程序开机自启动

随着服务器应用程序越来越多，手动去一个个启动不现实，既费时，也费力。如果使用自带的定时任务和注册表，有些bat无法正常调用。

核心代码如下：

    /// <summary>
    /// 进程操作类
    /// </summary>
    public class ProcessManage
    {
        private static Log4Net log = new Log4Net();
        private static string runPath = string.Empty;
        private static string filename = string.Empty;
        /// <summary>
        /// 停止所有程序
        /// </summary>
        public static void StopProcess()
        {
            try
            {
                if (null != AppConfig.ItemConfigList && 0 != AppConfig.ItemConfigList.Count)
                {
                    //获取所有进程程序
                    Process[] p = Process.GetProcesses();
                    foreach (Process pro in p)
                    {
                        foreach (ItemConfig itemconfig in AppConfig.ItemConfigList)
                        {
                            if (itemconfig.RunPath.LastIndexOf(pro.ProcessName) > 0)
                            {
                                //关闭程序
                                pro.Kill();
                                pro.WaitForExit(itemconfig.Time * 1000);
                                log.Log4NetLogger(pro.ProcessName + "关闭," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "StopProcess");
            }
        }

        /// <summary>
        /// 判断进程是否存在
        /// </summary>
        /// <param name="appName">程序名</param>
        /// <returns></returns>
        public static bool CheckProcessExist(string appName)
        {
            bool flag = false;
            try
            {
                if (!string.IsNullOrEmpty(appName))
                {
                    //获取所有进程程序
                    Process[] p = Process.GetProcesses();
                    foreach (Process pro in p)
                    {
                        if (appName.LastIndexOf(pro.ProcessName) > 0)
                        {
                            flag = true;
                            break;
                        }
                    }
                }
                return flag;
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "CheckProcessExist");
                return false;
            }
        }

        /// <summary>
        /// 开启所有程序
        /// </summary>
        public static void StartProcess()
        {
            //停止服务
            StopProcess();
            try
            {
                #region 打开程序
                if (null != AppConfig.ItemConfigList && 0 != AppConfig.ItemConfigList.Count)
                {
                    foreach (ItemConfig itemconfig in AppConfig.ItemConfigList)
                    {
                        //不考虑win7/8/2008的情况
                        //StartExe(itemconfig);

                        lock (itemconfig)
                        {
                            switch (System.IO.Path.GetExtension(itemconfig.RunPath))
                            {
                                case ".exe":
                                    //考虑win7/8/2008的情况
                                    StartExeByWin7(itemconfig);
                                    break;
                                case ".bat":
                                    StartBat(itemconfig);
                                    break;
                            }

                        }
                        if (itemconfig.Time != 0)
                            Thread.Sleep(itemconfig.Time * 1000);
                        else
                            Thread.Sleep(2000);
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "StopProcess");
            }
        }

        /// <summary>
        /// 启动程序
        /// </summary>
        /// <param name="itemconfig"></param>
        /// <returns></returns>
        private static bool StartExeByWin7(ItemConfig itemconfig)
        {
            try
            {
                if (string.IsNullOrEmpty(itemconfig.RunPath))
                {
                    log.Log4NetLogger("程序启动路径为空," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
                if (!System.IO.File.Exists(itemconfig.RunPath))
                {
                    log.Log4NetLogger(itemconfig.RunPath + " 程序启动程序不存在1," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
                runPath = itemconfig.RunPath;
                filename = System.IO.Path.GetFileName(runPath);
                ProcessManage.CreateProcess(runPath, itemconfig.Argument, runPath.Replace(filename, ""));//调用系统exe程序
                if (CheckProcessExist(runPath))
                {
                    log.Log4NetLogger(itemconfig.RunPath + " " + "程序开始启动," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return true;
                }
                else
                {
                    log.Log4NetLogger(itemconfig.RunPath + " " + "程序开始启动失败," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "StartExeByWin7");
                return false;
            }

        }

        private static bool StartBat(ItemConfig itemconfig)
        {
            try
            {
                if (string.IsNullOrEmpty(itemconfig.RunPath))
                {
                    log.Log4NetLogger("bat启动路径为空," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
                if (!System.IO.File.Exists(itemconfig.RunPath))
                {
                    log.Log4NetLogger("bat启动程序不存在," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }

                Process proc = new Process();
                proc.StartInfo.WorkingDirectory = itemconfig.RunPath.Replace(System.IO.Path.GetFileName(itemconfig.RunPath), "");
                proc.StartInfo.FileName = System.IO.Path.GetFileName(itemconfig.RunPath);
                proc.StartInfo.Arguments = itemconfig.Argument;
                proc.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
                proc.Start();
                log.Log4NetLogger(System.IO.Path.GetFileName(itemconfig.RunPath) + "bat开始启动," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                return true;
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "StartBat");
                return false;
            }
        }

        /// <summary>
        /// 启动程序
        /// </summary>
        /// <param name="itemconfig"></param>
        /// <returns></returns>
        private static bool StartExe(ItemConfig itemconfig)
        {
            try
            {
                if (string.IsNullOrEmpty(itemconfig.RunPath))
                {
                    log.Log4NetLogger("程序启动路径为空," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
                if (!System.IO.File.Exists(itemconfig.RunPath))
                {
                    log.Log4NetLogger("程序启动程序不存在," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }

                Process proc = new Process();
                proc.StartInfo.FileName = itemconfig.RunPath;
                proc.StartInfo.UseShellExecute = false;
                proc.StartInfo.RedirectStandardInput = true;
                proc.StartInfo.RedirectStandardError = true;
                proc.StartInfo.CreateNoWindow = true;
                proc.Start();
                if (OneInstance.IsFirst(proc.StartInfo.FileName))
                {
                    log.Log4NetLogger(proc.StartInfo.FileName + "程序开始启动," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return true;
                }
                else
                {
                    log.Log4NetLogger(proc.StartInfo.FileName + "程序开始启动失败," + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.sss"));
                    return false;
                }
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "StartExe");
                return false;
            }
        }

        /// <summary>
        /// 获取程序是否启动
        /// </summary>
        /// <returns></returns>
        public static bool GetRunState()
        {
            bool flag = false;
            if (null != AppConfig.ItemConfigList && 0 != AppConfig.ItemConfigList.Count)
            {
                var list = AppConfig.ItemConfigList.Where(q => System.IO.Path.GetExtension(q.RunPath) != ".bat").ToList();
                if (list.Count() == 0)
                    return false;
                //获取所有进程程序
                Process[] p = Process.GetProcesses();
                foreach (Process pro in p)
                {
                    foreach (ItemConfig itemconfig in list)
                    {
                        if (itemconfig.RunPath.LastIndexOf(pro.ProcessName) > 0)
                        {
                            return true;
                        }
                    }
                }
            }
            return flag;
        }

        #region 判断window服务是否存在
        public static bool ServiceIsExisted(string serviceName)
        {
            ServiceController[] services = ServiceController.GetServices();
            foreach (ServiceController s in services)
            {
                if (s.ServiceName == serviceName)
                {
                    return true;
                }
            }
            return false;
        }
        public static bool ServiceIsExisted(string serviceName, out bool isRun)
        {
            isRun = false;
            ServiceController[] services = ServiceController.GetServices();
            foreach (ServiceController s in services)
            {
                if (s.ServiceName == serviceName)
                {
                    if (s.Status == System.ServiceProcess.ServiceControllerStatus.Running)
                    {
                        isRun = true;
                        return true;
                    }
                    else
                    {
                        isRun = false;
                        return true;
                    }
                }
            }
            return false;
        }
        #endregion

        #region 安装服务
        public static bool InstallService(string serviceName, string servicePath, string serviceDes)
        {
            string comString = "/c sc create {0} binPath= \"{1}\"  type= share start= auto displayname= \"{2}\"";
            comString = string.Format(comString, serviceName, servicePath, serviceDes);
            System.Diagnostics.ProcessStartInfo processInfo = new System.Diagnostics.ProcessStartInfo();
            processInfo.FileName = "cmd.exe";
            processInfo.UseShellExecute = false;
            processInfo.RedirectStandardError = true;
            processInfo.RedirectStandardInput = true;
            processInfo.RedirectStandardOutput = true;
            processInfo.CreateNoWindow = true;
            processInfo.Arguments = comString;
            System.Diagnostics.Process objProcess = System.Diagnostics.Process.Start(processInfo);
            String stateString = objProcess.StandardOutput.ReadToEnd();
            objProcess.Refresh();
            if (stateString.IndexOf("成功") > -1)
            {
                return SetServiceInteract(serviceName);
            }
            else
            {

                return false;
            }

        }
        #endregion

        #region 设置与桌面交互
        public static bool SetServiceInteract(string serviceName)
        {
            string comString = "/c sc config {0} type= interact type= own";
            comString = string.Format(comString, serviceName);
            System.Diagnostics.ProcessStartInfo processInfo = new System.Diagnostics.ProcessStartInfo();
            processInfo.FileName = "cmd.exe";
            processInfo.UseShellExecute = false;
            processInfo.RedirectStandardError = true;
            processInfo.RedirectStandardInput = true;
            processInfo.RedirectStandardOutput = true;
            processInfo.CreateNoWindow = true;
            processInfo.Arguments = comString;
            System.Diagnostics.Process objProcess = System.Diagnostics.Process.Start(processInfo);
            String stateString = objProcess.StandardOutput.ReadToEnd();
            objProcess.Refresh();
            if (stateString.IndexOf("成功") > -1)
            {
                return true;
            }
            else
            {

                return false;
            }

        }
        #endregion

        #region 卸载windows服务
        public static bool UnInstallService(string serviceName)
        {
            string comString = "/c sc delete {0}";
            comString = string.Format(comString, serviceName);
            System.Diagnostics.ProcessStartInfo processInfo = new System.Diagnostics.ProcessStartInfo();
            processInfo.FileName = "cmd.exe";
            processInfo.UseShellExecute = false;
            processInfo.RedirectStandardError = true;
            processInfo.RedirectStandardInput = true;
            processInfo.RedirectStandardOutput = true;
            processInfo.CreateNoWindow = true;
            processInfo.Arguments = comString;
            System.Diagnostics.Process objProcess = System.Diagnostics.Process.Start(processInfo);
            String stateString = objProcess.StandardOutput.ReadToEnd();

            if (stateString.IndexOf("成功") > -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 启动服务
        public static bool StartService(string serviceName)
        {
            bool flag = true;
            if (ServiceIsExisted(serviceName))
            {
                System.ServiceProcess.ServiceController service = new System.ServiceProcess.ServiceController(serviceName);
                if (service.Status != System.ServiceProcess.ServiceControllerStatus.Running && service.Status != System.ServiceProcess.ServiceControllerStatus.StartPending)
                {
                    service.Start();
                    service.Refresh();
                    TimeSpan timeout = TimeSpan.FromSeconds(60);
                    service.WaitForStatus(System.ServiceProcess.ServiceControllerStatus.Running, timeout);
                    if (service.Status != System.ServiceProcess.ServiceControllerStatus.Running)
                        flag = false;
                }
            }
            return flag;
        }
        #endregion

        #region 停止服务
        public static bool StopService(string serviceName)
        {
            bool flag = true;
            if (ServiceIsExisted(serviceName))
            {
                System.ServiceProcess.ServiceController service = new System.ServiceProcess.ServiceController(serviceName);
                if (service.Status == System.ServiceProcess.ServiceControllerStatus.Running)
                {
                    service.Stop();
                    service.Refresh();
                    TimeSpan timeout = TimeSpan.FromSeconds(60);
                    service.WaitForStatus(System.ServiceProcess.ServiceControllerStatus.Stopped, timeout);
                    if (service.Status != System.ServiceProcess.ServiceControllerStatus.Stopped)
                        flag = false;
                }
            }
            return flag;
        }
        #endregion

        /// <summary>
        /// 调用批处理文件
        /// </summary>
        /// <param name="batName"></param>
        /// <param name="isCheck"></param>
        public static void RunBat(string batName, bool isCheck)
        {
            try
            {
                string filePath = string.Format("{0}\\{1}", Application.StartupPath, batName);
                if (ProcessManage.ServiceIsExisted("AutoRunService") == isCheck)
                {
                    if (isCheck)
                    {
                        string temp = string.Format("当前{0}注册服务不存在，请注册", batName);
                        (new Log4Net()).Log4NetLogger(temp);
                    }
                    else
                    {
                        string temp = string.Format("当前{0}注册服务已存在，请检查", batName);
                        (new Log4Net()).Log4NetLogger(temp);
                    }
                    return;
                }
                string CurrentDirectory = System.Environment.CurrentDirectory + "\\";
                System.Environment.CurrentDirectory = CurrentDirectory; //string.Format("{0}\\", Application.StartupPath);
                Process process = new Process();
                process.StartInfo.UseShellExecute = false;
                process.StartInfo.FileName = batName;
                process.StartInfo.CreateNoWindow = true;
                process.Start();
                if (isCheck)
                {
                    (new Log4Net()).Log4NetLogger("RunBat");
                }
            }
            catch (Exception ex)
            {
                (new Log4Net()).WriteException(ex, "RunBat");
            }
        }

        #region 穿透Session 0 隔离解决win7\8\2008问题
        public static IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;

        public static void ShowMessageBox(string message, string title)
        {
            int resp = 0;
            WTSSendMessage(
                WTS_CURRENT_SERVER_HANDLE,
                WTSGetActiveConsoleSessionId(),
                title, title.Length,
                message, message.Length,
                0, 0, out resp, false);
        }

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern int WTSGetActiveConsoleSessionId();

        [DllImport("wtsapi32.dll", SetLastError = true)]
        public static extern bool WTSSendMessage(
            IntPtr hServer,
            int SessionId,
            String pTitle,
            int TitleLength,
            String pMessage,
            int MessageLength,
            int Style,
            int Timeout,
            out int pResponse,
            bool bWait);

        public static void CreateProcess(string app, string argument, string path)
        {
            IntPtr hToken = WindowsIdentity.GetCurrent().Token;
            IntPtr hDupedToken = IntPtr.Zero;

            PROCESS_INFORMATION pi = new PROCESS_INFORMATION();
            try
            {
                bool result;


                SECURITY_ATTRIBUTES sa = new SECURITY_ATTRIBUTES();
                sa.Length = Marshal.SizeOf(sa);

                STARTUPINFO si = new STARTUPINFO();
                si.cb = Marshal.SizeOf(si);
                si.lpDesktop = "winsta0\\default";
                si.lpTitle = null;

                int dwSessionID = WTSGetActiveConsoleSessionId();
                result = WTSQueryUserToken(dwSessionID, out hToken);

                if (!result)
                {
                    //ShowMessageBox("WTSQueryUserToken failed", "AlertService Message");
                    (new Log4Net()).Log4NetLogger("WTSQueryUserToken failed");
                }

                result = DuplicateTokenEx(
                      hToken,
                      GENERIC_ALL_ACCESS,
                      ref sa,
                      (int)SECURITY_IMPERSONATION_LEVEL.SecurityIdentification,
                      (int)TOKEN_TYPE.TokenPrimary,
                      ref hDupedToken
                   );

                if (!result)
                {
                    //ShowMessageBox("DuplicateTokenEx failed", "AlertService Message");
                    (new Log4Net()).Log4NetLogger("DuplicateTokenEx failed");
                }

                IntPtr lpEnvironment = IntPtr.Zero;
                result = CreateEnvironmentBlock(out lpEnvironment, hDupedToken, false);

                if (!result)
                {
                    //ShowMessageBox("CreateEnvironmentBlock failed", "AlertService Message");
                    (new Log4Net()).Log4NetLogger("CreateEnvironmentBlock failed");
                }

                result = CreateProcessAsUser(
                                     hDupedToken,
                                     null,
                                     string.Format("\"{0}\" {1}", app, argument),
                                     ref sa, ref sa,
                                     false, 0, IntPtr.Zero,
                                     null, ref si, ref pi);




                if (!result)
                {
                    int error = Marshal.GetLastWin32Error();
                    string message = String.Format("CreateProcessAsUser Error: {0}", error);
                    //ShowMessageBox(message, "AlertService Message");
                    (new Log4Net()).Log4NetLogger(message);
                }
            }
            catch (Exception ex)
            {
                log.WriteException(ex, "CreateProcess");
            }
            finally
            {
                if (pi.hProcess != IntPtr.Zero)
                    CloseHandle(pi.hProcess);
                if (pi.hThread != IntPtr.Zero)
                    CloseHandle(pi.hThread);
                if (hDupedToken != IntPtr.Zero)
                    CloseHandle(hDupedToken);
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct STARTUPINFO
        {
            public Int32 cb;
            public string lpReserved;
            public string lpDesktop;
            public string lpTitle;
            public Int32 dwX;
            public Int32 dwY;
            public Int32 dwXSize;
            public Int32 dwXCountChars;
            public Int32 dwYCountChars;
            public Int32 dwFillAttribute;
            public Int32 dwFlags;
            public Int16 wShowWindow;
            public Int16 cbReserved2;
            public IntPtr lpReserved2;
            public IntPtr hStdInput;
            public IntPtr hStdOutput;
            public IntPtr hStdError;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public Int32 dwProcessID;
            public Int32 dwThreadID;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SECURITY_ATTRIBUTES
        {
            public Int32 Length;
            public IntPtr lpSecurityDescriptor;
            public bool bInheritHandle;
        }

        public enum SECURITY_IMPERSONATION_LEVEL
        {
            SecurityAnonymous,
            SecurityIdentification,
            SecurityImpersonation,
            SecurityDelegation
        }

        public enum TOKEN_TYPE
        {
            TokenPrimary = 1,
            TokenImpersonation
        }

        public const int GENERIC_ALL_ACCESS = 0x10000000;

        [DllImport("kernel32.dll", EntryPoint = "CloseHandle", SetLastError = true,
            CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("advapi32.dll", SetLastError = true,
            CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
        public static extern bool CreateProcessAsUser(
            IntPtr hToken,
            string lpApplicationName,
            string lpCommandLine,
            ref SECURITY_ATTRIBUTES lpProcessAttributes,
            ref SECURITY_ATTRIBUTES lpThreadAttributes,
            bool bInheritHandle,
            Int32 dwCreationFlags,
            IntPtr lpEnvrionment,
            string lpCurrentDirectory,
            ref STARTUPINFO lpStartupInfo,
            ref PROCESS_INFORMATION lpProcessInformation);

        [DllImport("advapi32.dll", EntryPoint = "DuplicateTokenEx", SetLastError = true)]
        public static extern bool DuplicateTokenEx(
            IntPtr hExistingToken,
            Int32 dwDesiredAccess,
            ref SECURITY_ATTRIBUTES lpThreadAttributes,
            Int32 ImpersonationLevel,
            Int32 dwTokenType,
            ref IntPtr phNewToken);

        [DllImport("wtsapi32.dll", SetLastError = true)]
        public static extern bool WTSQueryUserToken(
            Int32 sessionId,
            out IntPtr Token);

        [DllImport("userenv.dll", SetLastError = true)]
        static extern bool CreateEnvironmentBlock(
            out IntPtr lpEnvironment,
            IntPtr hToken,
            bool bInherit);

        #endregion
    }

    /// <summary>    
    /// 确认只有一个程序实例能够运行   
    /// /// </summary>  
    public abstract class OneInstance
    {
        /// <summary>     
        /// 用来判断一个指定的程序是否正在运行  
        /// </summary>       
        /// <param name="appId">程序名称,长一点比较好,防止有重复</param>        
        /// <returns>如果程序是第一次运行返回True,否则返回False</returns>       
        public static bool IsFirst(string appId)
        {
            bool ret = false;
            if (OpenMutex(0x1F0001, 0, appId) == IntPtr.Zero)
            {
                CreateMutex(IntPtr.Zero, 0, appId);
                ret = true;
            }
            return ret;
        }

        /// <summary>        
        /// 尝试调用指定的进程，返回句柄   
        /// </summary>      
        /// <param name="dwDesiredAccess">access</param>     
        /// <param name="bInheritHandle">inheritance option</param>        
        /// <param name = "lpName" > object name</param>        
        ///<returns>相应的句柄</returns>
        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        private static extern IntPtr OpenMutex(uint dwDesiredAccess, int bInheritHandle, string lpName);
        /// <summary>       
        /// 创建进程，返回相应的句柄 
        /// </summary>      
        /// <param name="lpMutexAttributes">SD</param>   
        /// <param name="bInitialOwner">initial owner</param>    
        /// <param name="lpName">object name</param>       
        /// <returns>相应的句柄</returns>       
        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        private static extern IntPtr CreateMutex(IntPtr lpMutexAttributes,
            int bInitialOwner, string lpName);
        [DllImport("user32.dll")]
        public static extern int GetDesktopWindow();
        [DllImport("user32.dll")]
        public static extern IntPtr GetProcessWindowStation();
        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentThreadId();
        [DllImport("user32.dll")]
        public static extern IntPtr GetThreadDesktop(IntPtr dwThread);
        [DllImport("user32.dll")]
        public static extern IntPtr OpenWindowStation(string a, bool b, int c);
        [DllImport("user32.dll")]
        public static extern IntPtr OpenDesktop(string lpszDesktop, uint dwFlags, bool fInherit, uint dwDesiredAccess);
        [DllImport("user32.dll")]
        public static extern IntPtr CloseDesktop(IntPtr p);
        [DllImport("rpcrt4.dll", SetLastError = true)]
        public static extern IntPtr RpcImpersonateClient(int i);
        [DllImport("rpcrt4.dll", SetLastError = true)]
        public static extern IntPtr RpcRevertToSelf();
        [DllImport("user32.dll")]
        public static extern IntPtr SetThreadDesktop(IntPtr a);
        [DllImport("user32.dll")]
        public static extern IntPtr SetProcessWindowStation(IntPtr a);
        [DllImport("user32.dll")]
        public static extern IntPtr CloseWindowStation(IntPtr a);
    }

源代码下载地址：源代码