执行cmd并返回程序结果

// Define the namespaces used by this sample.

using  System;

using  System.Text;

using  System.Globalization;

using  System.IO;

using  System.Diagnostics;

using  System.Threading;

using  System.ComponentModel;

 

 

namespace  ProcessAsyncStreamSamples

{

 

     class  ProcessNetStreamRedirection

     {

         // Define static variables shared by class methods.

         private  static  StreamWriter streamError = null ;

         private  static  String netErrorFile = "" ;

         private  static  StringBuilder netOutput = null ;

         private  static  bool  errorRedirect = false ;

         private  static  bool  errorsWritten = false ;

 

         public  static  void  RedirectNetCommandStreams()

         {

             String netArguments;

             Process netProcess;

 

             // Get the input computer name.

             Console.WriteLine( "Enter the computer name for the net view command:" );

             netArguments = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);

             if  (String.IsNullOrEmpty(netArguments))

             {

                 // Default to the help command if there is not an input argument.

                 netArguments = "/?" ;

             }

 

             // Check if errors should be redirected to a file.

             errorsWritten = false ;

             Console.WriteLine( "Enter a fully qualified path to an error log file" );

             Console.WriteLine( "  or just press Enter to write errors to console:" );

             netErrorFile = Console.ReadLine().ToUpper(CultureInfo.InvariantCulture);

             if  (!String.IsNullOrEmpty(netErrorFile))

             {

                 errorRedirect = true ;

             }

 

             // Note that at this point, netArguments and netErrorFile

             // are set with user input.  If the user did not specify

             // an error file, then errorRedirect is set to false.

 

             // Initialize the process and its StartInfo properties.

             netProcess = new  Process();

             netProcess.StartInfo.FileName = "Net.exe" ;

 

             // Build the net command argument list.

             netProcess.StartInfo.Arguments = String.Format( "view {0}" ,

                 netArguments);

 

             // Set UseShellExecute to false for redirection.

             netProcess.StartInfo.UseShellExecute = false ;

 

             // Redirect the standard output of the net command. 

             // This stream is read asynchronously using an event handler.

             netProcess.StartInfo.RedirectStandardOutput = true ;

             netProcess.OutputDataReceived += new  DataReceivedEventHandler(NetOutputDataHandler);

             netOutput = new  StringBuilder();

 

             if  (errorRedirect)

             {

                 // Redirect the error output of the net command.

                 netProcess.StartInfo.RedirectStandardError = true ;

                 netProcess.ErrorDataReceived += new  DataReceivedEventHandler(NetErrorDataHandler);

             }

             else

             {

                 // Do not redirect the error output.

                 netProcess.StartInfo.RedirectStandardError = false ;

             }

 

             Console.WriteLine( "\nStarting process: net {0}" ,

                 netProcess.StartInfo.Arguments);

             if  (errorRedirect)

             {

                 Console.WriteLine( "Errors will be written to the file {0}" ,

                     netErrorFile);

             }

 

             // Start the process.

             netProcess.Start();

 

             // Start the asynchronous read of the standard output stream.

             netProcess.BeginOutputReadLine();

 

             if  (errorRedirect)

             {

                 // Start the asynchronous read of the standard

                 // error stream.

                 netProcess.BeginErrorReadLine();

             }

 

             // Let the net command run, collecting the output.

             netProcess.WaitForExit();

 

             if  (streamError != null )

             {

                 // Close the error file.

                 streamError.Close();

             }

             else

             {

                 // Set errorsWritten to false if the stream is not

                 // open.   Either there are no errors, or the error

                 // file could not be opened.

                 errorsWritten = false ;

             }

 

             if  (netOutput.Length > 0)

             {

                 // If the process wrote more than just

                 // white space, write the output to the console.

                 Console.WriteLine( "\nPublic network shares from net view:\n{0}\n" ,

                     netOutput);

             }

 

             if  (errorsWritten)

             {

                 // Signal that the error file had something

                 // written to it.

                 String [] errorOutput = File.ReadAllLines(netErrorFile);

                 if  (errorOutput.Length > 0)

                 {

                     Console.WriteLine( "\nThe following error output was appended to {0}." ,

                         netErrorFile);

                     foreach  (String errLine in  errorOutput)

                     {

                         Console.WriteLine( "  {0}" , errLine);

                     }

                 }

                 Console.WriteLine();

             }

 

             netProcess.Close();

 

         }

 

         private  static  void  NetOutputDataHandler( object  sendingProcess,

             DataReceivedEventArgs outLine)

         {

             // Collect the net view command output.

             if  (!String.IsNullOrEmpty(outLine.Data))

             {

                 // Add the text to the collected output.

                 netOutput.Append(Environment.NewLine + "  "  + outLine.Data);

             }

         }

 

         private  static  void  NetErrorDataHandler( object  sendingProcess,

             DataReceivedEventArgs errLine)

         {

             // Write the error text to the file if there is something

             // to write and an error file has been specified.

 

             if  (!String.IsNullOrEmpty(errLine.Data))

             {

                 if  (!errorsWritten)

                 {

                     if  (streamError == null )

                     {

                         // Open the file.

                         try

                         {

                             streamError = new  StreamWriter(netErrorFile, true );

                         }

                         catch  (Exception e)

                         {

                             Console.WriteLine( "Could not open error file!" );

                             Console.WriteLine(e.Message.ToString());

                         }

                     }

 

                     if  (streamError != null )

                     {

                         // Write a header to the file if this is the first

                         // call to the error output handler.

                         streamError.WriteLine();

                         streamError.WriteLine(DateTime.Now.ToString());

                         streamError.WriteLine( "Net View error output:" );

                     }

                     errorsWritten = true ;

                 }

 

                 if  (streamError != null )

                 {

                     // Write redirected errors to the file.

                     streamError.WriteLine(errLine.Data);

                     streamError.Flush();

                 }

             }

         }

     }

}

转载于:https://www.cnblogs.com/zhangchenliang/archive/2012/09/16/2688031.html