Help! How to judge whether a program is running?
Whale
I use Shell("......") Function to execute a EXE program in
VB 5.0 enterprise, and I need to know when the EXE program
will ends. Can I judge it with the number Shell Function returns?
If can, Which API function should I use?
By the way, the Help says Shell Function will return a
"Program's task ID". What is "Program's task ID"? Is it
the PID or the SID? or others?
Thanks for your help!
Priya
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 : How to 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.
NOTE: The MsgBox statement following the ExecCmd() subroutine is not
executed because the WaitForSingleObject() function prevents it. The
message box does not appear until Notepad is closed when the user chooses
Exit from Notepad's File menu (ALT, F, X).
Hope this helps .
Regards,
Priya
Trisoft Design
E 30 Connaught Place
New Delhi 110 001 - India
Tel: 372 5407, 373 8651, 373 8653 Fax: 372 5407
Email: pri...@trisoftdesign.com
Internet:http://www.trisoftdesign.com/
Whale <ucom...@shcei.com.cn> wrote in article
<01bd1404$ef8a87e0$74e260ca@wxk>...