C++/CLI Code Snippet - Execute Shell Commands from .Net

C++/CLI Code Snippet - Execute Shell Commands from .Net

This .Net C++/CLI code snippet executes a shell command. To use this function simply provide the file/command to execute, command line parameters (optional), string variable to store output and string variable to store errors occurred during execution.

The code creates a command process and then invokes the command that we want to execute. The result of the command and any errors occurred during execution is stored in a string variables, which can then be used for further reference. This is a great method to execute your DOS commands from .Net.

/// <summary>
/// Execute a shell command
/// </summary>
/// <param name="_FileToExecute">File/Command to execute</param>
/// <param name="_CommandLine">Command line parameters to pass</param> 
/// <param name="_outputMessage">returned string value after executing shell command</param> 
/// <param name="_errorMessage">Error messages generated during shell execution</param> 
void ExecuteShellCommand(System::String ^_FileToExecute, System::String ^_CommandLine, System::String ^%_outputMessage, System::String ^%_errorMessage)
{
    // Set process variable
    // Provides access to local and remote processes and enables you to start and stop local system processes.
    System::Diagnostics::Process ^_Process = nullptr;
    try
    {
        _Process = gcnew System::Diagnostics::Process();

        // invokes the cmd process specifying the command to be executed.
        System::String ^_CMDProcess = System::String::Format(System::Globalization::CultureInfo::InvariantCulture, "{0}\\cmd.exe", gcnew array<System::Object^> { Environment::SystemDirectory });

        // pass executing file to cmd (Windows command interpreter) as a arguments
        // /C tells cmd that we want it to execute the command that follows, and then exit.
        System::String ^_Arguments = System::String::Format(System::Globalization::CultureInfo::InvariantCulture, "/C {0}", gcnew array<System::Object^> { _FileToExecute });

        // pass any command line parameters for execution
        if (_CommandLine != nullptr && _CommandLine->Length > 0)
        {
            _Arguments += System::String::Format(System::Globalization::CultureInfo::InvariantCulture, " {0}", gcnew array<System::Object^> { _CommandLine, System::Globalization::CultureInfo::InvariantCulture });
        }

        // Specifies a set of values used when starting a process.
        System::Diagnostics::ProcessStartInfo ^_ProcessStartInfo = gcnew System::Diagnostics::ProcessStartInfo(_CMDProcess, _Arguments);
        // sets a value indicating not to start the process in a new window. 
        _ProcessStartInfo->CreateNoWindow = true;
        // sets a value indicating not to use the operating system shell to start the process. 
        _ProcessStartInfo->UseShellExecute = false;
        // sets a value that indicates the output/input/error of an application is written to the Process.
        _ProcessStartInfo->RedirectStandardOutput = true;
        _ProcessStartInfo->RedirectStandardInput = true;
        _ProcessStartInfo->RedirectStandardError = true;
        _Process->StartInfo = _ProcessStartInfo;

        // Starts a process resource and associates it with a Process component.
        _Process->Start();

        // Instructs the Process component to wait indefinitely for the associated process to exit.
        _errorMessage = _Process->StandardError->ReadToEnd();
        _Process->WaitForExit();

        // Instructs the Process component to wait indefinitely for the associated process to exit.
        _outputMessage = _Process->StandardOutput->ReadToEnd();
        _Process->WaitForExit();
    }
    catch (Win32Exception ^_Win32Exception)
    {
        // Error
        Console::WriteLine("Win32 Exception caught in process: {0}", _Win32Exception->ToString());
    }
    catch (Exception ^_Exception)
    {
        // Error
        Console::WriteLine("Exception caught in process: {0}", _Exception->ToString());
    }
    finally
    {
        // close process and do cleanup
        _Process->Close();
        delete _Process;
        _Process = nullptr;
    }
}

Here is a simple example showing how to use above function (ExecuteShellCommand) to execute a simple DOS dir command and show output result in a richtextbox.

System::String ^_Output = nullptr;
System::String ^_Error = nullptr;
	
ExecuteShellCommand("dir", "c:\\", _Output, _Error);

richTextBox1->Text = _Output;

This example shows how to use above method to execute DOS del command to delete all the ZIP files in c:\temp folder using .Net.
/F - Force deleting of read-only files.
/Q - Quiet mode, do not ask if ok to delete on global wildcard.

System::String ^_Output = nullptr;
System::String ^_Error = nullptr;

ExecuteShellCommand("del", "/F /Q c:\\temp\\*.zip", _Output, _Error);

C++/CLI Keywords Used:

• Process
• Format
• ProcessStartInfo
• Environment
• SystemDirectory
• InvariantCulture
• Win32Exception
• Exception

Code Snippet Information:

• Applies To: .Net, C++, CLI, Shell Execute from .Net, DOS, System Processes, Execute DOS Commands from .Net, Redirect Standard Output, Windows command interpreter
• Programming Language : C++/CLI

External Resources:

• Process Class
• ProcessStartInfo Class
• ProcessStartInfo.RedirectStandardOutput Property
• Environment Class
• Environment.SystemDirectory Property
• Win32Exception Class
• Exception Class

Leave a comment