How to wait for a shelled application to finish by using Visual C++

Article translations Article translations
Article ID: 307388 - View products that this article applies to.
This article was previously published under Q307388
Expand all | Collapse all

On This Page

Summary

This article demonstrates how to use the .NET Framework Process class to start another application from your code and have the code wait for the other application to close before it continues.

When the code waits for the application to finish, there are two options:
  • Wait indefinitely for the other application to either finish or be closed by the user. -or-

  • Specify a time-out period after which you can close the application from your code.
This article presents two code samples that demonstrate both approaches. In addition, the time-out example can recognize if the other application has stopped responding and will take the necessary steps to close the application.

Include DLLs

You must import the DLLs for both the Process and the MessageBox classes before you run the examples that follow. Place the following lines of code right after the #include lines:
#using <system.dll>
#using <System.Windows.Forms.dll>
				

Include Namespaces

You must also import the namespaces for both the Process and the MessageBox classes. Place the following lines of code after the #using statements:
using namespace System::Diagnostics;
using namespace System::Windows::Forms;
				

Option 1: Wait Indefinitely for the Shelled Application to Finish

This following code sample instructs the shell to open the EULA.txt file. The shell will open the program associated with the .txt file type (usually Microsoft Notepad). The program will wait indefinitely for the application to terminate.
//How to wait for a shelled application to finish
//Get the name of the system folder
String* sysFolder= 
 Environment::GetFolderPath(Environment::SpecialFolder::System);
//Create a new ProcessInfo structure
ProcessStartInfo * pInfo = new ProcessStartInfo();
//Set the file name member of the process info structure.
pInfo->FileName = String::Concat(sysFolder, S"\\eula.txt");
//Start the process.
Process* p = Process::Start(pInfo);
//Wait for the window to finish loading.
p->WaitForInputIdle();
//Wait for the process to end.
p->WaitForExit();
//Console::WriteLine(S"Code continuing...");
MessageBox::Show(S"Code continuing...");
				

Option 2: Provide a Time-out for the Shelled Application

The following code sample sets a time-out for the shelled application. The time-out for the example is set to 5 seconds. You may want to adjust this number (which is calculated in milliseconds) for your testing.
//Set a time-out value.
int timeOut=5000;
//Get path to system folder.
String* sysFolder= 
 Environment::GetFolderPath(Environment::SpecialFolder::System);
//Create a new process info structure.
ProcessStartInfo* pInfo = new ProcessStartInfo();
//Set file name to open.
pInfo->FileName = String::Concat(sysFolder, S"\\eula.txt");
//Start the process
Process* p = Process::Start(pInfo);
//Wait for window to finish loading.
p->WaitForInputIdle();
//Wait for the process to exit or time out.
p->WaitForExit(timeOut);
//Check to see if the process is still running.
if (p->HasExited == false)
    //Process is still running.
    //Test to see if the process is hung up.
    if (p->Responding)
  	    //Process was responding; close the main window.
   	    p->CloseMainWindow();
    else
       //Process was not responding; force the process to close.
       p->Kill();
MessageBox::Show("Code continuing..."); 
				

Choosing Between the Two Options

It may be difficult to choose between these two options. The primary purpose of a time-out is to avoid having your application stop responding ("hang") because the other application has stopped responding ("hung"). Time-outs are better suited for a shelled application that performs background processing, in which the user may not know that the other application has stalled or does not have a convenient way to close it.

References

For additional information about the Process class, see the following .NET Framework Class Library documentation:
http://msdn.microsoft.com/en-us/library/system.diagnostics.process.aspx
For additional information about the MessageBox class, see the following .NET Framework Class Library documentation:
http://msdn.microsoft.com/en-us/library/system.windows.forms.messagebox(VS.71).aspx
For additional information about how to determine when a shelled process ends, click the article number below to view the article in the Microsoft Knowledge Base:
307011 HOW TO: Determine When a Shelled Process Ends in Visual C++ .NET
 For more general information about Visual C++ .NET, visit the Visual C++ .NET Support Center: 

Visual C++ .NET (2002) Support Center

Properties

Article ID: 307388 - Last Review: November 30, 2012 - Revision: 3.0
Applies to
  • Microsoft Visual C++ .NET 2002 Standard Edition
  • Microsoft Visual C++ .NET 2003 Standard Edition
  • Microsoft Visual C++ 2005 Express Edition
Keywords: 
kbhowtomaster kbnewsgrouplink KB307388

Give Feedback

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com