Mensaje enviado por "Esteban" <estebangarias@ciudad.com.ar>

Alberto, Este es el código que tengo de la Knowldge Base de Microsoft.
Saludos
   Esteban Arias

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

----------------------------------------------------------------------------
----
The information in this article applies to:

Microsoft Visual Basic Learning Edition for Windows, version 6.0
Microsoft Visual Basic Professional Edition for Windows, version 6.0
Microsoft Visual Basic Enterprise Edition for Windows, version 6.0
Microsoft Visual Basic Standard Edition, 32-bit only, for Windows, version 4.0
Microsoft Visual Basic Professional Edition, 32-bit, for Windows, version 4.0
Microsoft Visual Basic Enterprise Edition, 32-bit, 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 independently 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 technique. The example in
this article demonstrates a better way.

A 16-bit application would use a completely different technique to
accomplish the same effect.

For additional information, click the article number on the 16-bit process
below to view the article on the 16-bit process in the Microsoft Knowledge
Base:
Q96844 HOWTO: Determine When a Shelled Process Has Terminated



MORE INFORMATION
The Win32 API has integrated functionality that enables an application to
wait until a shelled process has completed. To use these functions, you need
a handle to the shelled process. The easiest way to achieve this is to use
the CreateProcess() API function to launch your shelled program rather than
Visual Basic's 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 through one of its passed parameters.
Waiting for the Shelled Process to Terminate
Having used CreateProcess() to get a process handle, pass that handle to the
WaitForSingleObject() function. This causes your Visual Basic application to
suspend execution until the shelled process terminates.
Getting the Exit Code from the Shelled Application
It was common for a DOS application to return an exit code indicating the
status of the completed application. While Windows provides other ways to
convey the same information, some applications only provide exit codes.
Passing the process handle to the GetExitCodeProcess() API allows you to
retrieve this information.

Following 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 demonstrates how to use the
Windows API CreateProcess() and WaitForSingleObject() functions to wait
until a shelled process terminates before resuming execution. It also uses
the GetExitCodeProcess() function to retrieve the exit code of the shelled
process, if any. 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
Start a new project in Visual Basic. Form1 is created by default.


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 String, 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 String, _
      lpStartupInfo As STARTUPINFO, lpProcessInformation As _
      PROCESS_INFORMATION) As Long

   Private Declare Function CloseHandle Lib "kernel32" _
      (ByVal hObject As Long) As Long

   Private Declare Function GetExitCodeProcess Lib "kernel32" _
      (ByVal hProcess As Long, lpExitCode As Long) As Long

   Private Const NORMAL_PRIORITY_CLASS = &H20&
   Private Const INFINITE = -1&

   Public Function 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(vbNullString, cmdline$, 0&, 0&, 1&, _
         NORMAL_PRIORITY_CLASS, 0&, vbNullString, start, proc)

      ' Wait for the shelled application to finish:
         ret& = WaitForSingleObject(proc.hProcess, INFINITE)
         Call GetExitCodeProcess(proc.hProcess, ret&)
         Call CloseHandle(proc.hThread)
         Call CloseHandle(proc.hProcess)
         ExecCmd = ret&
   End Function

   Sub Form_Click()
      Dim retval As Long
      retval = ExecCmd("notepad.exe")
      MsgBox "Process Finished, Exit Code " & retval
   End Sub
Press the F5 key to run the application.


Using the mouse, click the Form1 window. At this point the NotePad
application is started.


Terminate NotePad. A MsgBox appears indicating termination of the NotePad
application and an exit code of 0. To test this sample with an application
that returns an exit code, implement the following Knowledge Base article
and change the parameter passed to ExecCmd to "project1.exe":
Q178357 HOWTO: Set an Error Level from a Visual Basic Application
NOTE: The MsgBox statement following the ExecCmd() function 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).