执行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();
}
}
}
}
}