C# + Wscript.Shell

static class ProcessHelper
{
    public static void StartProcessAndWaitForAllChildrenToExit(string fileName, string arguments = null)
    {
        IntPtr hJob = NativeMethods.CreateJobObject(IntPtr.Zero, null);
        IntPtr hPort = IntPtr.Zero;
        if (hJob != IntPtr.Zero)
        {
            // Создаем процесс в suspended состоянии
            STARTUPINFO startupInfo = STARTUPINFO.New();
            PROCESS_INFORMATION processInformation;
            if (NativeMethods.CreateProcess(
                fileName, "\"" + fileName + "\" " + arguments,
                IntPtr.Zero, IntPtr.Zero,
                false,
                ProcessCreationFlags.CreateSuspended | ProcessCreationFlags.CreateNewConsole,
                IntPtr.Zero,
                null,
                ref startupInfo,
                out processInformation
                ))
            {
                // Связываем процесс с job объектом
                NativeMethods.AssignProcessToJobObject(hJob, processInformation.hProcess);
 
                // Создаем I/O completion port и связываем его с job объектом
                hPort = NativeMethods.CreateIoCompletionPort(NativeMethods.InvalidHandleValue, IntPtr.Zero, IntPtr.Zero, 0);
                var jobPortAssoc = new JOBOBJECT_ASSOCIATE_COMPLETION_PORT();
                jobPortAssoc.CompletionPort = hPort;
                jobPortAssoc.CompletionKey = Marshal.AllocHGlobal(10);
                bool infoSet = NativeMethods.SetInformationJobObject(
                    hJob,
                    JOBOBJECTINFOCLASS.AssociateCompletionPortInformation,
                    ref jobPortAssoc,
                    (uint)Marshal.SizeOf<JOBOBJECT_ASSOCIATE_COMPLETION_PORT>()
                );
 
                // Запускаем процесс
                NativeMethods.ResumeThread(processInformation.hThread);
 
                // Ждем сообщения JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO
                // Оно говорит что процесс и все его дочерние процессы завершились
                uint completionCode;
                const int JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO = 4;
                UIntPtr completionKey;
                IntPtr overlapped;
                const uint INFINITE = UInt32.MaxValue;
                while (NativeMethods.GetQueuedCompletionStatus(hPort, out completionCode, out completionKey, out overlapped, INFINITE) && completionCode != JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO)
                {
                }
 
                Marshal.FreeHGlobal(jobPortAssoc.CompletionKey);
                NativeMethods.CloseHandle(processInformation.hThread);
                NativeMethods.CloseHandle(processInformation.hProcess);
            }
            NativeMethods.CloseHandle(hJob);
            if (hPort != IntPtr.Zero) NativeMethods.CloseHandle(hPort);
        }
    }
 
    static class NativeMethods
    {
        public static readonly IntPtr InvalidHandleValue = new IntPtr(-1);
 
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
        public static extern IntPtr CreateJobObject(IntPtr jobAttributes, string name);
 
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode, EntryPoint = "CreateProcessW")]
        public static extern bool CreateProcess(
            [MarshalAs(UnmanagedType.LPWStr)] string lpApplicationName,
            [MarshalAs(UnmanagedType.LPWStr)] string lpCommandLine,
            IntPtr lpProcessAttributes,
            IntPtr lpThreadAttributes,
            bool bInheritHandles,
            //uint dwCreationFlags,
            ProcessCreationFlags creationFlags,
            IntPtr lpEnvironment,
            [MarshalAs(UnmanagedType.LPWStr)] string lpCurrentDirectory,
            [In] ref STARTUPINFO lpStartupInfo,
            out PROCESS_INFORMATION lpProcessInformation);
 
        [DllImport("kernel32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CloseHandle(IntPtr hObject);
 
        [DllImport("kernel32.dll")]
        public static extern uint ResumeThread(IntPtr hThread);
 
        [DllImport("kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);
 
        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr CreateIoCompletionPort(IntPtr fileHandle, IntPtr existingCompletionPort,
            IntPtr completionKey, uint numberOfConcurrentThreads);
 
        [DllImport("kernel32.dll")]
        public static extern bool SetInformationJobObject(IntPtr hJob,
            JOBOBJECTINFOCLASS jobObjectInfoClass, ref JOBOBJECT_ASSOCIATE_COMPLETION_PORT lpJobObjectInfo,
            uint cbJobObjectInfoLength);
 
        [DllImport("kernel32.dll")]
        public static extern bool GetQueuedCompletionStatus(IntPtr completionPort, out uint lpNumberOfBytes,
            out UIntPtr lpCompletionKey, out IntPtr lpOverlapped, uint dwMilliseconds);
    }
 
 
    [StructLayout(LayoutKind.Sequential)]
    struct JOBOBJECT_ASSOCIATE_COMPLETION_PORT
    {
        public IntPtr CompletionKey;
        public IntPtr CompletionPort;
    }
 
    enum JOBOBJECTINFOCLASS
    {
        AssociateCompletionPortInformation = 7,
        BasicLimitInformation = 2,
        BasicUIRestrictions = 4,
        EndOfJobTimeInformation = 6,
        ExtendedLimitInformation = 9,
        SecurityLimitInformation = 5,
        GroupInformation = 11
    }
 
    [Flags]
    enum ProcessCreationFlags
    {
        CreateSuspended = 0x00000004,
        DetachedProcess = 0x00000008,
        CreateNewConsole = 0x00000010
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    struct STARTUPINFO
    {
        public Int32 cb;
        public IntPtr lpReserved;
        public string lpDesktop;
        public string lpTitle;
        public Int32 dwX;
        public Int32 dwY;
        public Int32 dwXSize;
        public Int32 dwYSize;
        public Int32 dwXCountChars;
        public Int32 dwYCountChars;
        public Int32 dwFillAttribute;
        public Int32 dwFlags;
        public Int16 wShowWindow;
        public Int16 cbReserved2;
        public IntPtr lpReserved2;
        public IntPtr hStdInput;
        public IntPtr hStdOutput;
        public IntPtr hStdError;
 
        public static STARTUPINFO New()
        {
            STARTUPINFO startupInfo = new STARTUPINFO();
            startupInfo.cb = Marshal.SizeOf<STARTUPINFO>();
            startupInfo.lpReserved = IntPtr.Zero;
            startupInfo.cbReserved2 = 0;
            startupInfo.lpReserved2 = IntPtr.Zero;
            return startupInfo;
        }
    }
 
    [StructLayout(LayoutKind.Sequential)]
    struct PROCESS_INFORMATION
    {
        public IntPtr hProcess;
        public IntPtr hThread;
        public int dwProcessId;
        public int dwThreadId;
    }
 
    //[StructLayout(LayoutKind.Sequential)]
    //public struct SECURITY_ATTRIBUTES
    //{
    //  public int Length;
    //  public IntPtr SecurityDescriptor;
    //  public int InheritHandle;
    //}
}