using System;
using System.Diagnostics;
namespace DelphiPRAXIS.Samples
{
/// <summary>
/// <see cref="Delegate"/> für die beiden events <see cref="ThreadedProcess.Started"/> und <see cref="ThreadedProcess.Finished"/>.
/// </summary>
public delegate void ProcessStateHandler(object sender, EventArgs e);
/// <summary>
/// Summary description for ThreadedProcess.
/// </summary>
public class ThreadedProcess
{
#region Events
/// <summary>
/// Wird vor dem Ausführen (<see cref="Run"/>) durchlaufen.
/// </summary>
public event ProcessStateHandler Started;
/// <summary>
/// Wird nach dem Ausführen (<see cref="Run"/>) durchlaufen.
/// </summary>
public event ProcessStateHandler Finished;
void OnStarted(EventArgs e)
{
if (Started != null)
{
Started(this, e);
}
}
void OnFinished(EventArgs e)
{
if (Finished != null)
{
Finished(this, e);
}
}
#endregion
#region Fields
string[] arguments;
string executable;
#endregion
#region Properties
/// <summary>
/// Die Argumente, die der <see cref="Executable"/> übergeben werden. (optional)
/// </summary>
public string[] Arguments
{
get { return arguments; }
set
{
if (value == null)
{
arguments = new string[0];
} else
{
arguments = value;
}
}
}
/// <summary>
/// Die auszuführende Datei
/// </summary>
public string Executable
{
get { return executable; }
set { executable = value; }
}
#endregion
#region Constructors
/// <summary>
/// Constructor, der beide Felder initialisiert.
/// </summary>
/// <param name="executable"><see cref="Executable"/></param>
/// <param name="arguments"><see cref="Arguments"/></param>
public ThreadedProcess(string executable, params string[] arguments)
{
this.arguments = arguments;
this.executable = executable;
}
#endregion
/// <summary>
/// Der gekapselte <see cref="Process"/> wird in einem <see cref="System.Threading.Thread">Thread</see>
/// ausgeführt.
/// Gestartet wird <see cref="Executable"/> mit optionalen <see cref="Arguments">Argumenten</see>.
/// </summary>
/// <remarks>Vor dem Ausführen wird <see cref="Started"/> aufgerufen, nach dem Beenden <see cref="Finished"/>.</remarks>
/// <example>Kleines Beispiel zur Verwendung
/// <code>
///using System;
///
///namespace DelphiPRAXIS.Samples.Threading.TestConsole
///{
/// internal class Program
/// {
/// static void Main(string[] args)
/// {
/// Program program = new Program();
/// if (args.GetLength(0) > 0)
/// {
/// program.RunProcess("delphi32.exe", args);
/// }
/// }
///
/// void ProcessStarted(object sender, EventArgs e)
/// {
/// ThreadedProcess process = sender as ThreadedProcess;
/// Console.WriteLine("running \"{0}\" using {1}...",
/// process.Executable,
/// string.Join(", ", process.Arguments));
/// }
///
/// void ProcessFinished(object sender, EventArgs e)
/// {
/// ThreadedProcess process = sender as ThreadedProcess;
/// Console.WriteLine("finished running \"{0}\" using {1}...",
/// process.Executable,
/// string.Join(", ", process.Arguments));
/// Console.ReadLine();
/// }
///
/// void RunProcess(string executable, params string[] arguments)
/// {
/// ThreadedProcess process = new ThreadedProcess(executable, arguments);
/// process.Started += new ProcessStateHandler(ProcessStarted);
/// process.Finished += new ProcessStateHandler(ProcessFinished);
/// process.Run();
/// }
/// }
///}</code></example>
public void Run()
{
OnStarted(EventArgs.Empty);
Process process = new Process();
process.StartInfo.FileName = executable;
process.StartInfo.Arguments = string.Join(" ",
arguments);
process.Start();
process.WaitForExit();
OnFinished(EventArgs.Empty);
}
}
}