Come posso sapere se un processo ha un'interfaccia grafica?

Question

Utilizzo l'automazione per testare un'applicazione, ma a volte desidero avviare l'applicazione tramite un file batch. Quando eseguo "process.WaitForInputIdle (100)" viene visualizzato un messaggio di errore:

"WaitForInputIdle non riuscito. Ciò potrebbe essere dovuto al fatto che il processo non ha un'interfaccia grafica."

Come faccio a sapere se il processo ha un'interfaccia grafica o no?

Answer 1

Vedi Environment.UserInteractive. Questo identificherà se il processo ha un'interfaccia, ad es. i servizi non sono interattivi all'utente.

Si potrebbe anche guardare Process.MainWindowHandle che vi dirà se c'è un'interfaccia grafica.

Una combinazione di questi due controlli dovrebbe coprire tutte le possibilità.

Answer 2

Si può semplicemente cercare di catturare l'eccezione:

Process process = ... 
try 
{ 
    process.WaitForInputIdle(100); 
} 
catch (InvalidOperationException ex) 
{ 
    // no graphical interface 
} 

Answer 3

ero pensare lungo le linee di questo, ancora brutto ma trys per evitare eccezioni.

Process process = ... 

bool hasUI = false; 

if (!process.HasExited) 
{ 
    try 
    { 
     hasUI = process.MainWindowHandle != IntPtr.Zero; 
    } 
    catch (InvalidOperationException) 
    { 
     if (!process.HasExited) 
      throw; 
    } 
} 

if (!process.HasExited && hasUI) 
{ 

    try 
    { 
     process.WaitForInputIdle(100); 
    } 
    catch (InvalidOperationException) 
    { 
     if (!process.HasExited) 
      throw; 
    } 
} 

Answer 4

Così come un controllo MainWindowHandle, si possono elencare i fili di processo e verificare se qualcuno di loro riferimento una finestra visibile tramite P/richiama. Questo sembra fare un buon lavoro catturando qualsiasi finestra che manchi al primo controllo.

private Boolean isProcessWindowed(Process externalProcess) 
{ 
    if (externalProcess.MainWindowHandle != IntPtr.Zero) 
    { 
     return true; 
    } 

    foreach (ProcessThread threadInfo in externalProcess.Threads) 
    { 
     IntPtr[] windows = GetWindowHandlesForThread(threadInfo.Id); 

     if (windows != null) 
     { 
      foreach (IntPtr handle in windows) 
      { 
       if (IsWindowVisible(handle)) 
       { 
        return true; 
       } 
      } 
     } 
    } 

    return false; 
} 

private IntPtr[] GetWindowHandlesForThread(int threadHandle) 
{ 
    results.Clear(); 
    EnumWindows(WindowEnum, threadHandle); 

    return results.ToArray(); 
} 

private delegate int EnumWindowsProc(IntPtr hwnd, int lParam); 

private List<IntPtr> results = new List<IntPtr>(); 

private int WindowEnum(IntPtr hWnd, int lParam) 
{ 
    int processID = 0; 
    int threadID = GetWindowThreadProcessId(hWnd, out processID); 
    if (threadID == lParam) 
    { 
     results.Add(hWnd); 
    } 

    return 1; 
} 

[DllImport("user32.Dll")] 
private static extern int EnumWindows(EnumWindowsProc x, int y); 
[DllImport("user32.dll")] 
public static extern int GetWindowThreadProcessId(IntPtr handle, out int processId); 
[DllImport("user32.dll")] 
static extern bool IsWindowVisible(IntPtr hWnd);