我之前在做Windows服务启动桌面应用的项目时，踩过一模一样的坑——Session隔离加上系统的焦点保护策略，简直是双重打击。既然不能改架构，那咱们就从进程启动配置和WPF内部处理这两个核心方向入手，给你几个亲测有效的方案：

1. 先确保WPF进程绑定到用户的交互桌面 #

后台进程启动WPF时，最容易忽略的点就是：如果没把WPF进程关联到用户的winsta0\default桌面（这是用户实际操作的交互桌面），系统会直接把它判定为“非交互窗口”，自然不给焦点。

你可以通过P/Invoke手动配置启动信息，强制指定桌面参数，替代默认的Process.Start：

using System;
using System.Runtime.InteropServices;

public static class WpfProcessStarter
{
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct STARTUPINFO
    {
        public int cb;
        public string lpReserved;
        public string lpDesktop;
        public string lpTitle;
        public int dwX;
        public int dwY;
        public int dwXSize;
        public int dwYSize;
        public int dwXCountChars;
        public int dwYCountChars;
        public int dwFillAttribute;
        public int dwFlags;
        public short wShowWindow;
        public short cbReserved2;
        public IntPtr lpReserved2;
        public IntPtr hStdInput;
        public IntPtr hStdOutput;
        public IntPtr hStdError;
    }

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

    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    private static extern bool CreateProcess(
        string lpApplicationName,
        string lpCommandLine,
        IntPtr lpProcessAttributes,
        IntPtr lpThreadAttributes,
        bool bInheritHandles,
        uint dwCreationFlags,
        IntPtr lpEnvironment,
        string lpCurrentDirectory,
        [In] ref STARTUPINFO lpStartupInfo,
        out PROCESS_INFORMATION lpProcessInformation);

    [DllImport("kernel32.dll")]
    private static extern bool CloseHandle(IntPtr hObject);

    public static void LaunchWpfApp(string wpfExePath)
    {
        STARTUPINFO startupInfo = new STARTUPINFO();
        startupInfo.cb = Marshal.SizeOf(startupInfo);
        startupInfo.lpDesktop = "winsta0\\default"; // 核心：绑定到用户交互桌面
        PROCESS_INFORMATION processInfo = new PROCESS_INFORMATION();

        bool isSuccess = CreateProcess(
            wpfExePath,
            null,
            IntPtr.Zero,
            IntPtr.Zero,
            false,
            0,
            IntPtr.Zero,
            null,
            ref startupInfo,
            out processInfo);

        if (isSuccess)
        {
            // 记得关闭句柄，避免资源泄漏
            CloseHandle(processInfo.hProcess);
            CloseHandle(processInfo.hThread);
        }
        else
        {
            int errorCode = Marshal.GetLastWin32Error();
            // 这里可以加错误日志或提示
            Console.WriteLine($"启动失败，错误码：{errorCode}");
        }
    }
}

用这个方法启动WPF，相当于给系统明确传递了“这个窗口是给用户交互用的”信号，是解决焦点问题的基础。

2. 在WPF内部主动夺取焦点与修复Tab遍历 #

就算进程绑定对了，系统的焦点保护策略还是可能拦你。这时候可以在WPF窗口加载完成后，主动执行一系列操作突破限制，同时修复Tab键遍历的问题：

using System.Windows;
using System.Windows.Input;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        Loaded += Window_Loaded;
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        // 1. 先把窗口设为最顶层，确保系统能“看到”它
        Topmost = true;
        
        // 2. 激活窗口并强制设置焦点
        Activate();
        Focus();
        
        // 3. 延迟取消最顶层，避免一直霸占顶层位置
        Dispatcher.BeginInvoke(new Action(() => Topmost = false), DispatcherPriority.ApplicationIdle);

        // 4. 修复Tab键遍历：显式启用循环遍历
        KeyboardNavigation.SetTabNavigation(this, KeyboardNavigationMode.Cycle);
        KeyboardNavigation.SetControlTabNavigation(this, KeyboardNavigationMode.Cycle);
        
        // 5. 可选：把焦点定位到第一个可交互控件
        if (Content is FrameworkElement rootElement)
        {
            rootElement.MoveFocus(new TraversalRequest(FocusNavigationDirection.First));
        }
    }
}

这里的Topmost是关键——系统通常不会阻止“最顶层”窗口获取焦点，短暂设置后再取消，既能突破限制又不影响用户体验。而显式设置KeyboardNavigationMode，是因为非交互启动的窗口可能会默认禁用Tab遍历。

3. 用Win32 API强制突破焦点锁定（终极方案） #

如果上面的方法还是不行，那就直接用Win32 API硬刚——毕竟WPF的Activate()本质上也是调用这些API，但我们可以更直接地控制：

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Input;

public partial class MainWindow : Window
{
    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool SetForegroundWindow(IntPtr hWnd);

    [DllImport("user32.dll")]
    private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

    private const uint SWP_NOSIZE = 0x0001;
    private const uint SWP_NOMOVE = 0x0002;
    private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
    private static readonly IntPtr HWND_NOTOPMOST = new IntPtr(-2);

    public MainWindow()
    {
        InitializeComponent();
        Loaded += Window_Loaded;
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        ForceActivateWindow();
    }

    private void ForceActivateWindow()
    {
        IntPtr windowHandle = new WindowInteropHelper(this).EnsureHandle();
        
        // 先强制设为最顶层
        SetWindowPos(windowHandle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
        
        // 强制放到前台
        SetForegroundWindow(windowHandle);
        
        // 取消最顶层
        SetWindowPos(windowHandle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
        
        // 修复Tab遍历
        KeyboardNavigation.SetTabNavigation(this, KeyboardNavigationMode.Cycle);
        
        // 聚焦到第一个控件
        if (Content is FrameworkElement rootElement)
        {
            rootElement.MoveFocus(new TraversalRequest(FocusNavigationDirection.First));
        }
    }
}

SetForegroundWindow是Win32里最直接的“把窗口放到前台”的API，配合SetWindowPos的顶层设置，基本能突破绝大多数系统焦点限制。

4. 应急方案：临时调整系统焦点锁定超时 #

如果上面的方法都失效了，还有个终极应急手段——临时修改系统的ForegroundLockTimeout注册表项，这个项控制了系统阻止非用户触发窗口获取焦点的时长：

using Microsoft.Win32;
using System;
using System.Windows;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        Loaded += Window_Loaded;
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        AdjustForegroundLockTimeoutAndActivate();
    }

    private void AdjustForegroundLockTimeoutAndActivate()
    {
        const string regPath = @"Control Panel\Desktop";
        const string regKey = "ForegroundLockTimeout";
        
        // 保存原始值，避免永久修改系统设置
        object originalValue = Registry.CurrentUser.GetValue(regPath, regKey);
        
        try
        {
            // 设置为0，临时禁用焦点锁定
            Registry.CurrentUser.SetValue(regPath, regKey, 0, RegistryValueKind.DWord);
            
            // 激活窗口
            Activate();
            Focus();
        }
        finally
        {
            // 1秒后恢复原始设置
            Dispatcher.BeginInvoke(new Action(() =>
            {
                if (originalValue != null)
                {
                    Registry.CurrentUser.SetValue(regPath, regKey, originalValue);
                }
            }), TimeSpan.FromSeconds(1));
        }
    }
}

⚠️ 注意：这个方法会修改系统全局设置，可能导致其他程序也能随便弹出窗口，所以只建议作为最后手段。

总结 #

优先按这个顺序尝试：

1. 用CreateProcess指定winsta0\default桌面启动WPF（最根本的解决方法）
2. 在WPF内部用Topmost + Activate + Focus组合修复焦点和Tab遍历
3. 用Win32 API强制突破限制
4. 最后才考虑临时修改注册表

我当时就是靠前两个方法解决了问题，祝你顺利搞定这个坑！