Scopri di programmazione se un processo è esigente input dell'utente

Question

Come faccio a livello di codice (in C#) stabilire, se un'altra domanda estera (nativo, Java, .NET o qualsiasi altra cosa ...) è attualmente esigente input dell'utente? Questo può essere fatto completamente nel codice gestito?

Quello che sto cercando è la realizzazione di:

static Boolean IsWaitingForUserInput(String processName) 
{ 
    ??? 
} 

Chiedendo l'input dell'utente che intendo quando un'applicazione richiede all'utente di inserire alcuni dati o uscire un messaggio di errore (le finestre di dialogo modale) e non è in grado di svolgere i suoi compiti normali più. Un'applicazione di disegno che attende che l'utente disegni qualcosa non è qui intesa.

PS: Dopo le modifiche in modo da riflettere i commenti in fondo e fare la preoccupazione più chiara, alcuni commenti e le risposte non possono essere al 100% in linea con la domanda. Prendi questo in considerazione quando valuti le risposte e le osservazioni.

Answer 1

In generale è impossibile. Prendiamo ad esempio un tipo comune di applicazione, un word processor. Al giorno d'oggi che esegue controlli ortografici in background, salva automaticamente il tuo documento, eccetera. Eppure dal punto di vista degli utenti è in attesa di input tutto il tempo.

Un altro caso comune sarebbe un visualizzatore di presentazioni. In qualsiasi momento è possibile premere un tasto per far avanzare una diapositiva. Eppure il tuo utente tipico non lo vedrebbe come "in attesa di input".

In sintesi: "in attesa di input" è uno stato soggettivo e quindi non può essere determinata a livello di codice.

Answer 2

Se ho capito bene, si può tentare di enumerare le discussioni del processo e controllare i loro stati. Task Manager di Windows fa qualcosa di simile. Questo però richiede funzioni Win32 - Thread32First e Thread32Next tra gli altri - ma è possibile raggiungere questo obiettivo con l'uso più semplice di P/Invoke in C#:

[DllImport("Executor.dll")] 
    public static extern bool Thread32First(IntPtr handle, IntPtr threadEntry32); 

(firma precisa può differire).

EDIT: Ok, vi sono funzioni corrispondenti nella libreria NET.

Answer 3

Come ti piace?

ho elaborato una soluzione che sembra funzionare, per favore mi notifica in caso di problemi con questo codice così ho anche ottenere beneficio di miglioramenti. Funziona per Excel per quanto ho provato. L'unico problema che non mi piace è che ho dovuto usare chiamate non gestite. Gestisce anche il caso quando un'applicazione si basa su una finestra di dialogo come per MFC, derivata da CDialog.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Runtime.InteropServices; 
using System.Threading; 
using System.Diagnostics; 

namespace Util 
{ 
    public class ModalChecker 
    { 
     public static Boolean IsWaitingForUserInput(String processName) 
     { 
      Process[] processes = Process.GetProcessesByName(processName); 
      if (processes.Length == 0) 
       throw new Exception("No process found matching the search criteria"); 
      if (processes.Length > 1) 
       throw new Exception("More than one process found matching the search criteria"); 
      // for thread safety 
      ModalChecker checker = new ModalChecker(processes[0]); 
      return checker.WaitingForUserInput; 
     } 

     #region Native Windows Stuff 
     private const int WS_EX_DLGMODALFRAME = 0x00000001; 
     private const int GWL_EXSTYLE = (-20); 
     private delegate int EnumWindowsProc(IntPtr hWnd, int lParam); 
     [DllImport("user32")] 
     private extern static int EnumWindows(EnumWindowsProc lpEnumFunc, int lParam); 
     [DllImport("user32", CharSet = CharSet.Auto)] 
     private extern static uint GetWindowLong(IntPtr hWnd, int nIndex); 
     [DllImport("user32")] 
     private extern static uint GetWindowThreadProcessId(IntPtr hWnd, out IntPtr lpdwProcessId); 
     #endregion 

     // The process we want the info from 
     private Process _process; 
     private Boolean _waiting; 

     private ModalChecker(Process process) 
     { 
      _process = process; 
      _waiting = false; //default 
     } 

     private Boolean WaitingForUserInput 
     { 
      get 
      { 
       EnumWindows(new EnumWindowsProc(this.WindowEnum), 0); 
       return _waiting; 
      } 
     } 

     private int WindowEnum(IntPtr hWnd, int lParam) 
     { 
      if (hWnd == _process.MainWindowHandle) 
       return 1; 
      IntPtr processId; 
      GetWindowThreadProcessId(hWnd, out processId); 
      if (processId.ToInt32() != _process.Id) 
       return 1; 
      uint style = GetWindowLong(hWnd, GWL_EXSTYLE); 
      if ((style & WS_EX_DLGMODALFRAME) != 0) 
      { 
       _waiting = true; 
       return 0; // stop searching further 
      } 
      return 1; 
     } 
    } 
} 

Answer 4

Se possibile, riscrivere il altro codice di essere un processore concomitante di ingresso (simile al algoritmo per un web server concorrente):

Wait for input 
Fork process 
    Parent: Repeat 
    Child: (Worker) handle input 

Naturalmente, si potrebbe avere ancora la funzione:

static Boolean IsWaitingForUserInput(String processName) { 
    return true; 
}