Windows平台C#实现：无需复制命令获取任意应用选中文本的方案问询

Great question—this is a common pain point when working with inter-app text retrieval on Windows, especially since messing with the clipboard without user consent can lead to frustrating, unexpected behavior. Let’s break down your two main requests with practical, actionable approaches:

If you want to avoid touching the clipboard entirely, these are your best bets:

• Windows UI Automation (UIA)
  This is the most reliable, modern approach recommended by Microsoft. UIA lets you interact with UI elements across applications programmatically, including retrieving selected text directly from a control without relying on the clipboard.
  In C#, you’ll use the System.Windows.Automation namespace (you may need to add references to UIAutomationClient and UIAutomationTypes assemblies). Here’s a quick example to get selected text from the currently active window:

  using System.Windows.Automation;
  
  public static string GetSelectedText()
  {
      var focusedElement = AutomationElement.FocusedElement;
      if (focusedElement == null) return null;
  
      var selectionPattern = focusedElement.GetCurrentPattern(SelectionPattern.Pattern) as SelectionPattern;
      var textPattern = focusedElement.GetCurrentPattern(TextPattern.Pattern) as TextPattern;
  
      if (textPattern != null && textPattern.SupportedTextSelection != SupportedTextSelection.None)
      {
          var selectedRanges = textPattern.GetSelection();
          if (selectedRanges.Length > 0)
          {
              return selectedRanges[0].GetText(-1).Trim();
          }
      }
      return null;
  }
  

  Note: Your application may need elevated privileges if the target app is running as an administrator, and some legacy Win32 apps might not fully support UIA.

• Window Messages (Limited Use Case)
  For standard Win32 controls (like edit boxes or rich text controls), you can send window messages like WM_GETTEXT or EM_GETSELTEXT to retrieve selected text. This requires knowing the target control’s window handle (HWND) and works best for simple, well-defined controls. However, it’s not universal—custom or modern UI frameworks (like WPF, Electron) often don’t respond to these messages as expected.

• Windows Hooks (Advanced, Risky)
  You could use low-level Windows hooks (via SetWindowsHookEx) to monitor text selection events across applications. This is far more complex, requires careful memory management, and can cause system instability if implemented poorly. It’s generally not recommended unless UIA and window messages don’t meet your needs.

If you absolutely have to use the clipboard (e.g., for apps that don’t support UIA), here’s how to minimize user disruption:

• Backup the Entire Clipboard Data Object
  Don’t just backup plain text—clipboards can hold multiple formats (images, file paths, rich text, etc.). Use Clipboard.GetDataObject() to capture the full state before modifying it, then restore it with Clipboard.SetDataObject() afterward. Example:

  IDataObject originalClipboard = null;
  
  // Backup before modifying
  try
  {
      originalClipboard = Clipboard.GetDataObject();
      // Perform your Ctrl+C or clipboard write operation here
      // ...
  }
  finally
  {
      // Restore only if we successfully backed up
      if (originalClipboard != null)
      {
          Clipboard.SetDataObject(originalClipboard, true);
      }
  }
  

  The true parameter in SetDataObject ensures the clipboard data persists after your app exits.

• Handle Race Conditions & User Consent
  Even with backup, there’s a risk: if the user modifies the clipboard between your backup and restore, you’ll overwrite their changes. To mitigate this:

  • Always inform the user before accessing the clipboard (e.g., a prompt like "This operation will temporarily use your clipboard; it will be restored afterward").
  • Keep the time between backup and restore as short as possible to reduce the chance of user interference.
  • Optionally, check if the clipboard content has changed since backup before restoring (compare data objects or specific formats).

• Avoid Persistent Clipboard Overrides
  Never leave the clipboard in an unexpected state. Always wrap clipboard operations in a try/finally block to guarantee restoration, even if your code throws an exception.

内容的提问来源于stack exchange，提问作者Johannes