Início / coding / Perguntas / 79582909
Accepted
Lusiiky
Asked: 2025-04-20 07:36:16 +0800 CST

Como faço para reorientar um script do Powershell após um Start-Process?

  • 772

Tenho um script Pwsh com um menu que executa diversas operações diferentes para me ajudar no dia a dia.

Para uma das operações, eu inicio um processo com Start-Process, exceto que ele focaliza a janela iniciada, mas para facilitar eu gostaria que o script fosse focalizado novamente após o lançamento e não o processo iniciado.

Não quero usar os argumentos “PassThru” ou “NoNewWindow” porque não quero que o processo iniciado seja iniciado no script, nem “WindowStyle” com Minimized porque isso focaliza o processo iniciado de qualquer maneira, nem Hidden porque ainda preciso ver a janela do processo em algum lugar.

Eu tentei esse método que parece funcionar melhor:

Start-Process -FilePath "MyProcessPath"

Start-Sleep -Seconds 1

Add-Type @"
using System;
using System.Runtime.InteropServices;
public class WinAp {
 [DllImport("user32.dll")]
 [return: MarshalAs(UnmanagedType.Bool)]
 public static extern bool SetForegroundWindow(IntPtr hWnd);

 [DllImport("user32.dll")]
 [return: MarshalAs(UnmanagedType.Bool)]
 public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
}
"@

$p = Get-Process | Where-Object { $_.MainWindowTitle -like "*ScriptTitle*" -and $_.ProcessName -eq "powershell" }

$h = $p.MainWindowHandle
[void] [WinAp]::SetForegroundWindow($h)
[void] [WinAp]::ShowWindow($h, 1)

Mas, infelizmente, não funciona. Parece que faz alguma coisa na janela, pois ela pisca na barra de tarefas, mas não foca. Parece que, embora o script seja executado como administrador, ele não funciona para focar uma janela de administrador como essa?

Entretanto, para outra parte do meu script, fiz isso:

$tempPath = [System.IO.Path]::GetTempFileName().Replace(".tmp", ".vbs")
$code = @'
Set WshShell = WScript.CreateObject("WScript.Shell")
WshShell.AppActivate "App.exe"
WScript.Sleep 250
WshShell.SendKeys "{ENTER}"
'@

$code | Out-File $tempPath -Encoding ASCII
Start-Process "wscript.exe" $tempPath -Wait
Remove-Item $tempPath

E funciona bem... ele foca a janela e, em seguida, pressiona a tecla solicitada (embora essa parte não seja necessária no meu problema atual). Tentei com o meu script, mas... nada. Principalmente porque o aplicativo é iniciado com o script, então como administrador também, eu acho? Então, não entendo por que funciona, mas não para o script em si.

Obrigado!

powershell

3 respostas

  1. Best Answer

    Por padrão, o Windows impede a ativação de janelas arbitrárias programaticamente , a menos que o processo de chamada possua a janela de primeiro plano ativa (focada) no momento da chamada , em termos gerais; os critérios exatos estão listados na seção "Comentários" do SetForegroundWindow()tópico de ajuda .

    Se os critérios não forem atendidos, a tentativa de um processo de definir programaticamente a janela em primeiro plano fará com que o ícone da barra de tarefas do processo de destino pisque algumas vezes, sem nenhuma alteração na janela ativa, que é o que você viu.
    (É irrelevante se o seu script é executado com elevação (como administrador) ou não.)

    Isso acontece no seu caso, porque se Start-Processvocê iniciar um processo que cria uma janela (não transitória), esta última recebe o foco (é ativada), [1] e, portanto, impede que seu script do PowerShell reative sua própria janela de console mais tarde.

    Você pode (temporariamente) remover essa restrição com uma chamada P/Invoke para a SystemParametersInfofunção WinAPI, definindo seu SPI_SETFOREGROUNDLOCKTIMEOUTparâmetro como 0.

    • Isso incorrerá em uma penalidade única no desempenho da compilação por sessão do PowerShell, por meio de uma chamada para Add-Type.

    • A ativação da janela entre processos será habilitada durante o restante da sessão do Windows do usuário, para todos os processos (portanto, considere reativar a restrição antes de sair do script, conforme mostrado abaixo).

    O seguinte é um exemplo independente que demonstra a solução; para simplificar, ele usa o método WScript.Shelldo objeto COM .AppActivate()para reativar a janela do console de sessão do PowerShell, usando o ID do processo da sessão, conforme refletido na variável automática$PID . [2]

    # Disable the restriction on programmatically activating arbitrary windows
# from processes not owning the current foreground window, 
# for the remainder session of the user's Windows session.  
# using a P/Invoke call:

# Compile a helper type...
$helperType = 
  Add-Type -PassThru -ErrorAction Stop -Namespace ('NS_{0}_{1}' -f ((Split-Path -Leaf $PSCommandPath) -replace '[^a-z0-9]'), $PID) -Name CGetSetForegroundLockTimeout -MemberDefinition @'
    [DllImport("user32.dll", EntryPoint="SystemParametersInfo", SetLastError=true)]
    static extern bool SystemParametersInfo_Set_UInt32(uint uiAction, uint uiParam, UInt32 pvParam, uint fWinIni);
    public static void EnableCrossProcessWindowActivation(bool enable = true) 
    {
      uint timeout = enable ? (uint)0 : (uint)2147483647;
      if (!SystemParametersInfo_Set_UInt32(0x2001 /* SPI_SETFOREGROUNDLOCKTIMEOUT */, 0, timeout /* timeout in msecs. */, 0 /* non-persistent change */)) {
        throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error(), "Unexpected failure calling SystemParametersInfo() with SPI_SETFOREGROUNDLOCKTIMEOUT. Make sure that the call is made from the process owning the foreground window.");      
      }
    }
'@

#'# ... and call the method that calls the SystemParametersInfo() WinAPI function
#       to enable cross-process window activation.
# IMPORTANT: In order for this call to succeed, it must be made while
#            this PowerShell script is running in the process that owns
#            the current foreground window, 
#            i.e. BEFORE launching your application.
$helperType::EnableCrossProcessWindowActivation()

# Start your application (Notepad in this example), asynchronously.
# (Since Notepad is a *GUI* application, you don't strictly need Start-Process here.)
# This will invariably give the window that Notepad creates the focus. 
Start-Process notepad.exe

# Sleep a little, to make sure Notepad has started up and received the focus.
Start-Sleep 2

# Now reactivating this PowerShell session's console window
# works as intended.
$null = (New-Object -ComObject WScript.Shell).AppActivate($PID)

# Disable cross-process window activation again.
# IMPORTANT: Here too the process running this script must be the one that
#            owns the current foreground window for the call to succeed;
#            this is what the .AppActivate() call ensured.
$helperType::EnableCrossProcessWindowActivation($false)

    Uma nota sobre alternativas potenciais:

    É possível que você tente iniciar seu aplicativo de uma maneira que não desvie o foco da janela do console do seu script do PowerShell, o que eliminaria a necessidade de reativá-lo.

    Por exemplo, (New-Object -ComObject Shell.Application).ShellExecute('yourApp.exe', '', '', '', 4) pode ser iniciado yourapp.exesem alterar a janela ativa; se isso acontece ou não, depende se ele foi projetado para respeitar o estilo de janela de inicialização solicitado - e parece que poucos aplicativos fazem isso.

    Além disso, com o estilo de janela 4, embora a janela do aplicativo não fique ativa , ela ainda pode obscurecer o console do script do PowerShell.

    Se aceitável , o estilo minimiza7 a janela do aplicativo sem roubar o foco, o que evitaria o problema de obscurecimento, mas exigiria que os usuários descobrissem o aplicativo em execução pressionando Alt-Tab ou clicando em seu ícone na barra de tarefas. No entanto, isso também funcionará apenas com aplicativos projetados para respeitar os estilos de janela de inicialização.

    O .ShellExecute()método do Shell.Applicationobjeto COM e os estilos de janela disponíveis são documentados aqui .

    [Microsoft.VisualBasic.Interaction]::Shell()oferece funcionalidade muito semelhante.

    [1] Isso também se aplica se você iniciar um aplicativo GUI diretamente , sem Start-Process. Se você usar Start-Processpara iniciar um aplicativo GUI, mesmo que isso não-WindowStyle Hidden impeça a perda de foco. O problema #24387 do GitHub é uma solicitação de recurso que solicita que a capacidade de iniciar um aplicativo sem que ele receba o foco seja adicionada ao , mas foi recusada , sob a justificativa de que, devido à natureza multiplataforma do PowerShell (Core) 7, não deve ser aprimorado com recursos exclusivos do Windows.Start-ProcessStart-Process

    [2] Observe que esta abordagem, assim como a .MainWindowHandleda pergunta, só funciona se o processo do PowerShell for o proprietário da janela do console em que é executado. Embora isso seja válido para sessões do PowerShell iniciadas diretamente (por exemplo, a partir do Menu Iniciar ou da barra de tarefas), não se aplica a processos do PowerShell iniciados a partir de outro aplicativo de console, por exemplo, de uma cmd.exesessão. Você pode usar a seguinte alternativa para reativação, que também requer uma abordagem P/Invoke (que pode ser combinada com a anterior em uma única Add-Typechamada):
    (Add-Type -PassThru -Name ConsoleActivator -Namespace WinApiHelper -MemberDefinition ' [DllImport("kernel32.dll")] static extern IntPtr GetConsoleWindow(); [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr hWnd); public static void ActivateOwnConsoleWindow() { SetForegroundWindow(GetConsoleWindow()); } ')::ActivateOwnConsoleWindow()

    • 2

  2. Use um script VBS temporário para refocar sua janela do PowerShell após iniciar o processo

    Start-Process -FilePath "MyProcessPath"

Start-Sleep -Seconds 1

$myWindowTitle = (Get-Process -Id $PID).MainWindowTitle

$tempPath = [System.IO.Path]::GetTempFileName().Replace(".tmp", ".vbs")

$code = @"

Set WshShell = WScript.CreateObject("WScript.Shell")

WScript.Sleep 500

WshShell.AppActivate "$myWindowTitle"

"@

$code | Out-File $tempPath -Encoding ASCII

Start-Process "wscript.exe" $tempPath -Wait

Remove-Item $tempPath

    me avise se for útil

    • 0

  3. Pelo que entendi, você tem um script que roda no console e aciona uma aplicação. Nesse ponto, o console perde o foco. Depois de um tempo, você gostaria que o foco retornasse ao console.

    Geralmente uso uma função que criei para essa tarefa:

        ## Define constants for the window display mode
    . {
        $Global:WINDOW_DISPLAY_MODE_HIDDEN = 0
        $Global:WINDOW_DISPLAY_MODE_SHOW_AND_ACTIVATE = 1
        $Global:WINDOW_DISPLAY_MODE_MINIMIZE_AND_ACTIVATE = 2
        $Global:WINDOW_DISPLAY_MODE_MAXIMIZE_AND_ACTIVATE = 3
        $Global:WINDOW_DISPLAY_MODE_SHOW_WITHOUT_ACTIVATING = 4
        $Global:WINDOW_DISPLAY_MODE_SHOW_AT_ORIGINAL_POSITION_AND_ACTIVATE = 5
        $Global:WINDOW_DISPLAY_MODE_MINIMIZE_AND_ACTIVATE_OTHER_WINDOW = 6
        $Global:WINDOW_DISPLAY_MODE_MINIMIZE_WITHOUT_ACTIVATING = 7
        $Global:WINDOW_DISPLAY_MODE_SHOW_AT_ORIGINAL_POSITION_WITHOUT_ACTIVATING = 8
        $Global:WINDOW_DISPLAY_MODE_RESTORE_AND_ACTIVATE = 9
        $Global:WINDOW_DISPLAY_MODE_DEFAULT = 10
        $Global:WINDOW_DISPLAY_MODE_FORCE_MINIMIZE = 11
    }
    Function Get-Console ( $_Format = $Global:WINDOW_DISPLAY_MODE_HIDDEN ) {
        If ( $psISE ) {
            $__Window = Get-Process -Id $PID |
                Select-Object -ExpandProperty 'MainWindowTitle'
            Return-Window -Title $__Window | Out-Null
        } Else {
            $__Resource = '
                [DllImport ( "Kernel32.dll" )]
                public static extern IntPtr GetConsoleWindow();
                [DllImport ( "user32.dll" )]
                public static extern bool ShowWindow ( IntPtr hWnd, Int32 nCmdShow );'
            Add-Type -Namespace 'Console' -Name 'Window' -MemberDefinition $__Resource
            $__ConsoleHandle = [Console.Window]::GetConsoleWindow()
            [Console.Window]::ShowWindow( $__ConsoleHandle, $_Format ) | Out-Null
        }
    }

    A maneira de usá-lo é:

        Get-Console $Global:WINDOW_DISPLAY_MODE_MINIMIZE_AND_ACTIVATE_OTHER_WINDOW
    Get-Console $Global:WINDOW_DISPLAY_MODE_RESTORE_AND_ACTIVATE
    • 0

relate perguntas