c# windows服务中启动程序

最新推荐文章于 2025-05-19 10:30:07 发布

原创最新推荐文章于 2025-05-19 10:30:07 发布 · 1.4k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c# #windows service #processing

c# 专栏收录该内容

2 篇文章

订阅专栏

本文探讨了在Server环境中启动进程时遇到的环境变量问题，特别是如何正确设置USERPROFILE环境变量，以确保进程能正常使用用户的配置。文章还提供了一个具体的C#示例代码，演示如何使用CreateProcessAsUser()函数以不同用户的权限启动进程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.描述一下遇到的问题：被server打开的进程所引用的环境变量跟server是一致的。（%USERPROFILE% 通常为 C:\Users\用户名）

这样就导致 USERPROFILE，跟正常用户的不一样。在这个程序中保存文件，用默认应用程序打开word时出现了一些看起来是注册表的问题的EX。

例：C:\WINDOWS\system32\config\systemprofile\Desktop引用了一个不可用的位置。

c# 查看环境变量方法,都在Environment中。
string path = Environment.GetEnvironmentVariable("USERPROFILE", EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("USERPROFILE", "C:\\Users\\Gordon", EnvironmentVariableTarget.Process);

2.关于在server中打开进程的方法，网上有很多，放一个实例。最主要还是穿透sessions。关键词 CreateProcessAsUser()。下面方法中CreateProcess()就是打开程序方法。

重点的是 CreateProcessAsUser中的倒数第四个参数： IntPtr lpEnvironment。这个参数在c++ 中参考 CreateProcessAsUser 函数

lpEnvironment：指向新进程的环境块的指针。如果此参数为 NULL，则新进程使用调用进程的环境。

在c++有方法 GetEnvironmentStrings()，获取环境块的指针。但是在c#中我试过 string ,int, IntPtr 传入都图示参数错误。有大佬知道麻烦评论一下，，，

c#: [DllImport("kernel32.dll", SetLastError = true,
CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern string GetEnvironmentStrings();

目前的解决方式就是在server的进程中修改了环境%USERPROFILE% 的值。通过Environment。

/// <summary>
        /// 以当前登录的windows用户(角色权限)运行指定程序进程
        /// </summary>
        /// <param name="hToken"></param>
        /// <param name="lpApplicationName">指定程序(全路径)</param>
        /// <param name="lpCommandLine">参数</param>
        /// <param name="lpProcessAttributes">进程属性</param>
        /// <param name="lpThreadAttributes">线程属性</param>
        /// <param name="bInheritHandles"></param>
        /// <param name="dwCreationFlags"></param>
        /// <param name="lpEnvironment"></param>
        /// <param name="lpCurrentDirectory"></param>
        /// <param name="lpStartupInfo">程序启动属性</param>
        /// <param name="lpProcessInformation">最后返回的进程信息</param>
        /// <returns>是否调用成功</returns>
        [DllImport("ADVAPI32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern bool CreateProcessAsUser(IntPtr hToken, string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes,
                                                      bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory,
                                                      ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

  #region 启动

        public static IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;

        [DllImport("WTSAPI32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern bool WTSEnumerateSessions(
            IntPtr hServer,
            [MarshalAs(UnmanagedType.U4)] UInt32 Reserved,
            [MarshalAs(UnmanagedType.U4)] UInt32 Version,
            ref IntPtr ppSessionInfo,
            [MarshalAs(UnmanagedType.U4)] ref UInt32 pSessionInfoCount
            );

        private enum WTS_CONNECTSTATE_CLASS
        {
            WTSActive,
            WTSConnected,
            WTSConnectQuery,
            WTSShadow,
            WTSDisconnected,
            WTSIdle,
            WTSListen,
            WTSReset,
            WTSDown,
            WTSInit
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        private struct WTS_SESSION_INFO
        {
            public UInt32 SessionID;
            public string pWinStationName;
            public WTS_CONNECTSTATE_CLASS State;
        }

        [DllImport("WTSAPI32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern bool WTSQueryUserToken(UInt32 sessionId, out IntPtr Token);

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public int dwProcessId;
            public int dwThreadId;
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        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 dwYSize;
            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;
        }

        /// <summary>
        /// 以当前登录的windows用户(角色权限)运行指定程序进程
        /// </summary>
        /// <param name="hToken"></param>
        /// <param name="lpApplicationName">指定程序(全路径)</param>
        /// <param name="lpCommandLine">参数</param>
        /// <param name="lpProcessAttributes">进程属性</param>
        /// <param name="lpThreadAttributes">线程属性</param>
        /// <param name="bInheritHandles"></param>
        /// <param name="dwCreationFlags"></param>
        /// <param name="lpEnvironment"></param>
        /// <param name="lpCurrentDirectory"></param>
        /// <param name="lpStartupInfo">程序启动属性</param>
        /// <param name="lpProcessInformation">最后返回的进程信息</param>
        /// <returns>是否调用成功</returns>
        [DllImport("ADVAPI32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern bool CreateProcessAsUser(IntPtr hToken, string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes,
                                                      bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory,
                                                      ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

        [DllImport("KERNEL32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern bool CloseHandle(IntPtr hHandle);

        [DllImport("WTSAPI32.DLL", SetLastError = true, CharSet = CharSet.Auto)]
        static extern void WTSFreeMemory(IntPtr pMemory);


        [DllImport("kernel32.dll", SetLastError = true,
            CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern string GetEnvironmentStrings();

        [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 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);
        }

        /// <summary>
        /// 以当前登录系统的用户角色权限启动指定的进程
        /// </summary>
        /// <param name="ChildProcName">指定的进程(全路径)</param>
        public static int CreateProcess(string ChildProcName, string workPath, string arguments, string npath)
        {
            string path = Environment.GetEnvironmentVariable("USERPROFILE", EnvironmentVariableTarget.Process);
            //    Environment.SetEnvironmentVariable("USERPROFILE", "C:\\Users\\Gordon", EnvironmentVariableTarget.Process);
            ShowMessageBox(path, "AlertService Message");

            IntPtr ppSessionInfo = IntPtr.Zero;
            UInt32 SessionCount = 0;
            int processID = 0;
            if (WTSEnumerateSessions(
                                    (IntPtr)WTS_CURRENT_SERVER_HANDLE,  // Current RD Session Host Server handle would be zero. 
                                    0,  // This reserved parameter must be zero. 
                                    1,  // The version of the enumeration request must be 1. 
                                    ref ppSessionInfo, // This would point to an array of session info. 
                                    ref SessionCount  // This would indicate the length of the above array.
                                    ))
            {
                for (int nCount = 0; nCount < SessionCount; nCount++)
                {
                    WTS_SESSION_INFO tSessionInfo = (WTS_SESSION_INFO)Marshal.PtrToStructure(ppSessionInfo + nCount * Marshal.SizeOf(typeof(WTS_SESSION_INFO)), typeof(WTS_SESSION_INFO));
                    if (WTS_CONNECTSTATE_CLASS.WTSActive == tSessionInfo.State)
                    {
                        IntPtr hToken = IntPtr.Zero;
                        if (WTSQueryUserToken(tSessionInfo.SessionID, out hToken))
                        {
                            PROCESS_INFORMATION tProcessInfo;
                            STARTUPINFO tStartUpInfo = new STARTUPINFO();
                            tStartUpInfo.cb = Marshal.SizeOf(typeof(STARTUPINFO));
                            bool ChildProcStarted = CreateProcessAsUser(
                                                                        hToken,             // Token of the logged-on user. 
                                                                        ChildProcName,      // Name of the process to be started. 
                                                                        arguments,               // Any command line arguments to be passed. 
                                                                        IntPtr.Zero,        // Default Process' attributes. 
                                                                        IntPtr.Zero,        // Default Thread's attributes. 
                                                                        false,              // Does NOT inherit parent's handles. 
                                                                        0,                  // No any specific creation flag. 
                                                                        IntPtr.Zero,               // Default environment path. 
                                                                        workPath,               // Default current directory. 
                                                                        ref tStartUpInfo,   // Process Startup Info.  
                                                                        out tProcessInfo    // Process information to be returned. 
                                                     );
                            if (ChildProcStarted)
                            {
                                CloseHandle(tProcessInfo.hThread);
                                CloseHandle(tProcessInfo.hProcess);
                            }
                            else
                            {
                                int error = Marshal.GetLastWin32Error();
                                string message = String.Format("CreateProcessAsUser Error: {0}", error);
                                ShowMessageBox(message, "AlertService Message");
                                //*ShowServiceMessage("CreateProcessAsUser失败", "CreateProcess");
                            }
                            CloseHandle(hToken);
                            processID = tProcessInfo.dwProcessId;
                            break;
                        }
                    }
                }
                WTSFreeMemory(ppSessionInfo);
            }
            return processID;
        }

        #endregion

3. 一些备注：在server中无法读注册表，emmmm很神奇。

Process 的用户名密码启动

ProcessStartInfo startInfo = new ProcessStartInfo("D:\\mycode\\myTools\\自定义工具\\Wpf热键\\bin\\Debug\\Wpf热键.exe");
                startInfo.WindowStyle = ProcessWindowStyle.Normal;
                startInfo.WorkingDirectory = "D:\\mycode\\myTools\\自定义工具\\Wpf热键\\bin\\Debug";
                startInfo.UseShellExecute = false;
                startInfo.UserName = "Gordon";
                SecureString objSecureString = new SecureString();
                foreach (char c in "1".ToCharArray())
                    objSecureString.AppendChar(c);

                startInfo.Password = objSecureString;
                Process.Start(startInfo);