HOWTO: 32-Bit App Can Determine When a Shelled Process Ends

• Standard, Professional, and Enterprise Editions of Microsoft Visual Basic, 32-bit only, for Windows, version 4.0

SUMMARY

Executing the Shell() function in a Visual Basic for Windows program starts another executable program asynchronously and returns control to the Visual Basic application. This shelled program continues to run independent of your application until the user closes it.

However, if your Visual Basic application needs to wait for the shelled process to terminate, you could use the Windows API to poll the status of the application, but this is not a very efficient process. This article shows by example how to use a better process.

There is a completely different process that would be used to accomplish the same thing from a 16-bit application. For additional information on the 16-bit implementation, please see the following article in the Microsoft Knowledge Base:

   ARTICLE-ID: Q96844
   TITLE     : HOWTO: Determine When a Shelled Process Has Terminated

MORE INFORMATION

The Win32 API has integrated functionality that enables your application to wait until a shelled process has completed. To use these functions, you need to have a handle to the shelled process. To accomplish this, you need to use the CreateProcess() function to begin your shelled program instead of the Shell() function.

Creating the Shelled Process

In a 32-bit application, you need to create an addressable process. To do this, use the CreateProcess() function to start your shelled application. The CreateProcess() function gives your program the process handle of the shelled process via one of its passed parameters.

Waiting for the Shelled Process to Terminate

Having used CreateProcess() to get a process handle, you can pass that handle to the WaitForSingleObject() function. This causes your Visual Basic application to suspend execution until the shelled process terminates.

Below are the steps necessary to build a Visual Basic for Windows program that uses the CreateProcess() function to execute the Windows Notepad (NOTEPAD.EXE) application. This code shows by example how to use the Windows API CreateProcess() and WaitForSingleObject() functions to wait until a shelled process terminates before resuming execution.

The syntax of the CreateProcess() function is extremely complicated, so in the example code, it is encapsulated into a function called ExecCmd(). ExecCmd() takes one parameter, the command line of the application to execute.

Step-by-Step Example

1. Start a new project in Visual Basic. Form1 is created by default.

2. Add the following code to the general declarations section of Form1:

         Private Type STARTUPINFO
            cb As Long
            lpReserved As String
            lpDesktop As String
            lpTitle As String
            dwX As Long
            dwY As Long
            dwXSize As Long
            dwYSize As Long
            dwXCountChars As Long
            dwYCountChars As Long
            dwFillAttribute As Long
            dwFlags As Long
            wShowWindow As Integer
            cbReserved2 As Integer
            lpReserved2 As Long
            hStdInput As Long
            hStdOutput As Long
            hStdError As Long
         End Type
   
         Private Type PROCESS_INFORMATION
            hProcess As Long
            hThread As Long
            dwProcessID As Long
            dwThreadID As Long
         End Type
   
         Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal _
            hHandle As Long, ByVal dwMilliseconds As Long) As Long
   
         Private Declare Function CreateProcessA Lib "kernel32" (ByVal _
            lpApplicationName As Long, ByVal lpCommandLine As String, ByVal _
            lpProcessAttributes As Long, ByVal lpThreadAttributes As Long, _
            ByVal bInheritHandles As Long, ByVal dwCreationFlags As Long, _
            ByVal lpEnvironment As Long, ByVal lpCurrentDirectory As Long, _
            lpStartupInfo As STARTUPINFO, lpProcessInformation As _
            PROCESS_INFORMATION) As Long
   
         Private Declare Function CloseHandle Lib "kernel32" (ByVal _
            hObject As Long) As Long
   
         Private Const NORMAL_PRIORITY_CLASS = &H20&
         Private Const INFINITE = -1&
   
         Public Sub ExecCmd(cmdline$)
            Dim proc As PROCESS_INFORMATION
            Dim start As STARTUPINFO
   
            ' Initialize the STARTUPINFO structure:
            start.cb = Len(start)
   
            ' Start the shelled application:
            ret& = CreateProcessA(0&, cmdline$, 0&, 0&, 1&, _
               NORMAL_PRIORITY_CLASS, 0&, 0&, start, proc)
   
            ' Wait for the shelled application to finish:
            ret& = WaitForSingleObject(proc.hProcess, INFINITE)
            ret& = CloseHandle(proc.hProcess)
         End Sub
   
   

3. Add the following code the Form_Click() event procedure of Form1:

         Sub Form_Click ()
            ExecCmd "notepad.exe"
            MsgBox "Process Finished"
         End Sub
   
   

4. Press the F5 key to run the application.

5. Using the mouse, click the Form1 window. At this point the Notepad application is shelled.