Como posso modificar este C# (dentro do PowerShell) para que ele aguarde o término do processo filho que ele gera?

Como observou o comentarista Jimi , o que você deseja alcançar pode ser feito completamente usando a classe Process do .NET , evitando o código de interoperabilidade de baixo nível. Aqui está uma tentativa de fazer isso.

• Usa somente API .NET pura.
• Aguarda o processo filho sair e retorna seu código de saída.
• Adiciona tratamento de erros capturando quaisquer exceções e exibindo caixas de mensagens.
• Mostra ajuda da linha de comando quando chamado sem ou com parâmetros inválidos (faltando o marcador "--").

Add-Type -OutputType WindowsApplication -OutputAssembly NoConsole.exe -ReferencedAssemblies 'System.Windows.Forms.dll' -TypeDefinition @'
using System;
using System.Diagnostics;
using System.Windows.Forms;
using System.Text.RegularExpressions;

namespace NoConsole
{
    class Program
    {
        [STAThread]
        static int Main( string[] args )
        {
            // Extract the child command
            string childCommand;
            if( ! TryGetChildCommand( out childCommand ) )
            {
                MessageBox.Show( "Usage: NoConsole.exe -- <command> [args]", "NoConsole - Missing Arguments",
                                 MessageBoxButtons.OK, MessageBoxIcon.Error );
                return -1;
            }
            
            // Split the child command into filename and arguments for ProcessStartInfo
            string fileName, arguments;
            ParseCommand( childCommand, out fileName, out arguments );

            var psi = new ProcessStartInfo
            {
                FileName = fileName,
                Arguments = arguments,
                UseShellExecute = false,
                CreateNoWindow = true
            };

            try
            {
                // Launch the child process, wait for exit and return the exit code.
                using( var process = Process.Start( psi ) )
                {
                    process.WaitForExit();
                    return process.ExitCode;
                }
            }
            catch( Exception e )
            {
                MessageBox.Show(
                    "Failed to start process:\n\n" + childCommand + "\n\n" + e.Message + string.Format( " (0x{0:X8})", e.HResult ),
                    "NoConsole - Error", MessageBoxButtons.OK, MessageBoxIcon.Error );
                return -1;
            }
        }
        
        // Extracts the raw commandline after the "--" marker, to avoid the hassles of requoting arguments that contain whitespace.
        static bool TryGetChildCommand( out string childCommand )
        {
            string cmdLine = Environment.CommandLine;
            int markerIndex = cmdLine.IndexOf( " -- " );
            if( markerIndex < 0 || markerIndex + 4 >= cmdLine.Length )
            {
                childCommand = null;
                return false;
            }

            childCommand = cmdLine.Substring( markerIndex + 4 );
            return true;
        }       

        // Splits a full commandline into filename and arguments. Supports both quoted and unquoted filename. Arguments are returned as-is.
        static void ParseCommand( string cmdLine, out string fileName, out string arguments )
        {
            var match = Regex.Match( cmdLine.TrimStart(), @"^(""[^""]+""|\S+)(?:\s+(.*))?$" );
            if( match.Success )
            {
                fileName = match.Groups[1].Value.Trim( '\"' );
                arguments = match.Groups[2].Success ? match.Groups[2].Value : string.Empty;
            }
            else
            {
                fileName = cmdLine.Trim();
                arguments = string.Empty;
            }
        }
    }
}
'@

Exemplos:

PowerShell:

> $proc = Start-Process -FilePath .\NoConsole.exe -ArgumentList '-- pwsh -Command "exit 42"' -Wait -PassThru
> "ExitCode: $($proc.ExitCode)"

ExitCode: 42

Shell CMD:

> start "" /wait NoConsole.exe -- pwsh -Command "exit 42"
> echo ExitCode: %ERRORLEVEL%

ExitCode: 42

Observações:

• O código para gerar "NoConsole.exe" deve ser executado no Windows PowerShell (5.1), pois o PS 7 ainda não suporta a criação de executáveis.
• Os comandos Start-Process(PowerShell) e start /wait (CMD) são necessários para aguardar a saída de "NoConsole.exe", pois se trata de um aplicativo com interface gráfica (GUI) (apesar do nome e de não exibir interface gráfica quando chamado corretamente). Ao contrário de um aplicativo de console, que é executado de forma síncrona, um processo com interface gráfica é executado separadamente do console que o iniciou. Se desejar uma inicialização síncrona, ela pode ser obtida conforme mostrado nos exemplos.
• "NoConsole.exe" também suporta a citação do caminho do arquivo do processo filho, o que é necessário quando o caminho contém espaços. Aqui está um exemplo de como chamar "NoConsole.exe" a partir do shell cmd: NoConsole.exe -- "c:\full path\to\something.exe" arg1 arg2 "quoted arg3"
• A ocultação da janela do console é obtida configurando- CreateNoWindow = truese o parâmetro ProcessStartInfo. Embora isso funcione em muitos casos, aplicativos que dependem da existência de uma janela do console podem se comportar de forma inesperada ou falhar. Uma maneira mais robusta seria configurar WindowStyle = ProcessWindowStyle.Hidden, mas isso na verdade não funciona, a menos que você use , ShellExecute = trueo que tem seu próprio conjunto de problemas. O .NET alterou isso no .NET 8, mas como ele está sendo compilado com o .NET Framework, ele não pegará as novas alterações. Se você encontrar esse problema com o aplicativo específico que está iniciando através do NoConsole.exe, recomendo usar o NoGui original , que desde então foi atualizado para suportar a espera pela saída e o retorno do código de saída, entre outros recursos úteis.

Chame WaitForSingleObjecte passe o identificador do processo retornado por CreateProcesscomo argumento de destino:

// ...

[DllImport("kernel32.dll", SetLastError = true)] 
public static extern int WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);

private static readonly uint INFINITE = 0xFFFFFFFF;

static void Main()
{
    // ...

    bool res = CreateProcessW(
        null,
        newCmdLine,
        IntPtr.Zero,
        IntPtr.Zero,
        true,
        0x00000410,  // CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT
        IntPtr.Zero,
        null,
        ref si,
        out pi
    );

    if (res && pi.hProcess != IntPtr.Zero)
    {
        // wait on process handle
        int waitOutcome = WaitForSingleObject(pi.hProcess, INFINITE);

        if (waitOutcome == 0)
        {
            // successfully waited for process termination
        }
    }
}