├── DummyConsoleApplication
    ├── DummyConsoleApplication.csproj
    ├── Program.cs
    └── Options.cs
├── publish.bat
├── ConsoleAppLauncher.Samples
    ├── ConsoleAppLauncher.Samples.csproj
    ├── Program.cs
    ├── Samples.cs
    ├── SysInfo.cs
    ├── Samples.resx
    └── Samples.Designer.cs
├── ConsoleAppLauncher
    ├── ConsoleOutputEventArgs.cs
    ├── ConsoleAppLauncher.csproj
    ├── Win32.cs
    ├── IConsoleApp.cs
    └── ConsoleApp.cs
├── .gitattributes
├── ConsoleAppLauncher.Tests
    ├── ConsoleAppLauncher.Tests.csproj
    └── ConsoleAppTest.cs
├── license.txt
├── .gitignore
├── readme.md
└── ConsoleAppLauncher.sln


/DummyConsoleApplication/DummyConsoleApplication.csproj:
--------------------------------------------------------------------------------
1 | <Project Sdk="Microsoft.NET.Sdk">
2 | 
3 |   <PropertyGroup>
4 |     <OutputType>Exe</OutputType>
5 |     <TargetFramework>net45</TargetFramework>
6 |   </PropertyGroup>
7 | 
8 | </Project>
9 | 


--------------------------------------------------------------------------------
/publish.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | pushd %~dp0
 3 | 
 4 | echo Pushing NuGet package to nuget.org...
 5 | dotnet nuget push "ConsoleAppLauncher\bin\Release\ConsoleAppLauncher.2.0.0.nupkg" --source https://api.nuget.org/v3/index.json --api-key %1
 6 | 
 7 | :exit
 8 | echo Done.
 9 | popd
10 | 
11 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/ConsoleAppLauncher.Samples.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>WinExe</OutputType>
 5 |     <TargetFramework>netcoreapp3.1</TargetFramework>
 6 |     <UseWindowsForms>true</UseWindowsForms>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <ProjectReference Include="..\ConsoleAppLauncher\ConsoleAppLauncher.csproj" />
11 |   </ItemGroup>
12 | 
13 | </Project>


--------------------------------------------------------------------------------
/ConsoleAppLauncher/ConsoleOutputEventArgs.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace SlavaGu.ConsoleAppLauncher
 4 | {
 5 |     public class ConsoleOutputEventArgs : EventArgs
 6 |     {
 7 |         public ConsoleOutputEventArgs(string line, bool isError)
 8 |         {
 9 |             Line = line;
10 |             IsError = isError;
11 |         }
12 | 
13 |         public string Line { get; private set; }
14 |         public bool IsError { get; private set; }
15 |     }
16 | }


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Windows.Forms;
 4 | using SlavaGu.ConsoleAppLauncher.Samples;
 5 | 
 6 | namespace ConsoleAppLauncher.Samples
 7 | {
 8 |     static class Program
 9 |     {
10 |         /// <summary>
11 |         /// The main entry point for the application.
12 |         /// </summary>
13 |         [STAThread]
14 |         static void Main()
15 |         {
16 |             Application.SetHighDpiMode(HighDpiMode.SystemAware);
17 |             Application.EnableVisualStyles();
18 |             Application.SetCompatibleTextRenderingDefault(false);
19 |             Application.Run(new Form1());
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Tests/ConsoleAppLauncher.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net45</TargetFramework>
 5 |     <IsPackable>false</IsPackable>
 6 |   </PropertyGroup>
 7 | 
 8 |   <ItemGroup>
 9 |     <PackageReference Include="NUnit" Version="3.12.0" />
10 |     <PackageReference Include="NUnit3TestAdapter" Version="3.16.1" />
11 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
12 |   </ItemGroup>
13 | 
14 |   <ItemGroup>
15 |     <ProjectReference Include="..\ConsoleAppLauncher\ConsoleAppLauncher.csproj" />
16 |     <ProjectReference Include="..\DummyConsoleApplication\DummyConsoleApplication.csproj" />
17 |   </ItemGroup>
18 | 
19 | </Project>
20 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/Samples.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Forms;
 3 | 
 4 | namespace SlavaGu.ConsoleAppLauncher.Samples
 5 | {
 6 |     public partial class Form1 : Form
 7 |     {
 8 |         public Form1()
 9 |         {
10 |             InitializeComponent();
11 |         }
12 | 
13 |         private void buttonVer_Click(object sender, EventArgs e)
14 |         {
15 |             labelVer.Text = SysInfo.GetWindowsVersion();
16 |         }
17 | 
18 |         private void buttonGetIpAddress_Click(object sender, EventArgs e)
19 |         {
20 |             labelIpAddress.Text = SysInfo.GetIpAddress();
21 |         }
22 | 
23 |         private void buttonPing_Click(object sender, EventArgs e)
24 |         {
25 |             SysInfo.PingUrl("google.com", reply => BeginInvoke((MethodInvoker)delegate { labelPing.Text = reply; }));
26 |         }
27 | 
28 |         private void buttonSkype_Click(object sender, EventArgs e)
29 |         {
30 |             labelSkype.Text = SysInfo.GetFirewallRule("Skype");
31 |         }
32 | 
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) 2013 Slava Guzenko
3 | 
4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/ConsoleAppLauncher/ConsoleAppLauncher.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFrameworks>net4;net45;net5;netcoreapp3.1;netstandard21</TargetFrameworks>
 5 |     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 6 |     <PackageId>ConsoleAppLauncher</PackageId>
 7 |     <Authors>Slava Guzenko</Authors>
 8 |     <Description>
 9 |       Console Application wrapper for .NET. It captures all the output generated in the console and provides simple interface to start, show progress, and close console application.
10 |     </Description>
11 |     <PackageProjectUrl>https://github.com/slavagu/ConsoleAppLauncher</PackageProjectUrl>
12 |     <License>https://raw.githubusercontent.com/slavagu/ConsoleAppLauncher/master/license.txt</License>
13 |     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
14 |     <PackageTags>Console Wrapper ConsoleApp ConsoleApplication Process Ngen</PackageTags>
15 |  </PropertyGroup>
16 |   
17 |  <PropertyGroup>
18 |     <Version>2.0.0</Version>
19 |     <PackageReleaseNotes>Targeting multiple frameworks including .NET Core</PackageReleaseNotes>
20 |  </PropertyGroup>
21 | 
22 | </Project>
23 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/SysInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Text.RegularExpressions;
 3 | 
 4 | namespace SlavaGu.ConsoleAppLauncher.Samples
 5 | {
 6 |     public class SysInfo
 7 |     {
 8 |         /// <summary>
 9 |         /// Run simplest shell command and return its output.
10 |         /// </summary>
11 |         /// <returns></returns>
12 |         public static string GetWindowsVersion()
13 |         {
14 |             return ConsoleApp.Run("cmd", "/c ver").Output.Trim();
15 |         }
16 | 
17 |         /// <summary>
18 |         /// Run ipconfig.exe and return matching line.
19 |         /// </summary>
20 |         /// <returns></returns>
21 |         public static string GetIpAddress()
22 |         {
23 |             var output = ConsoleApp.Run("ipconfig").Output;
24 |             var match = Regex.Match(output, "IPv4 Address.*: (?<addr>.*)");
25 |             return match.Success ? match.Groups["addr"].Value : "<undefined>";
26 |         }
27 | 
28 |         /// <summary>
29 |         /// Run ping.exe asynchronously and return roundtrip times back to the caller in a callback
30 |         /// </summary>
31 |         /// <param name="url"></param>
32 |         /// <param name="replyHandler"></param>
33 |         public static void PingUrl(string url, Action<string> replyHandler)
34 |         {
35 |             var regex = new Regex("(time=|Average = )(?<time>.*?ms)", RegexOptions.Compiled);
36 |             var app = new ConsoleApp("ping", url);
37 |             app.ConsoleOutput += (o, args) =>
38 |             {
39 |                 var match = regex.Match(args.Line);
40 |                 if (match.Success)
41 |                 {
42 |                     var roundtripTime = match.Groups["time"].Value;
43 |                     replyHandler(roundtripTime);
44 |                 }
45 |             };
46 |             app.Run();
47 |         }
48 | 
49 |         /// <summary>
50 |         /// Get Windows firewall rule
51 |         /// </summary>
52 |         /// <param name="ruleName"></param>
53 |         /// <returns></returns>
54 |         public static string GetFirewallRule(string ruleName)
55 |         {
56 |             var cmdLine = string.Format("advfirewall firewall show rule \"{0}\" verbose", ruleName);
57 |             return ConsoleApp.Run("netsh", cmdLine).Output.Trim();
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher/Win32.cs:
--------------------------------------------------------------------------------
 1 | using System.Runtime.InteropServices;
 2 | 
 3 | namespace SlavaGu.ConsoleAppLauncher
 4 | {
 5 |     public static class Win32
 6 |     {
 7 |         public enum CtrlType
 8 |         {
 9 |             CtrlCEvent = 0,
10 |             CtrlBreakEvent = 1,
11 |             CtrlCloseEvent = 2,
12 |             CtrlLogoffEvent = 5,
13 |             CtrlShutdownEvent = 6
14 |         }
15 | 
16 |         public delegate bool ConsoleCtrlEventHandler(CtrlType ctrlType);
17 | 
18 |         [DllImport("kernel32.dll", SetLastError = true)]
19 |         public static extern bool SetConsoleCtrlHandler(ConsoleCtrlEventHandler handler, bool add);
20 | 
21 |         [DllImport("kernel32", SetLastError = true)]
22 |         public static extern bool GenerateConsoleCtrlEvent(CtrlType ctrlType, int dwProcessGroupId);
23 | 
24 |         /// <summary>
25 |         /// allocates a new console for the calling process.
26 |         /// </summary>
27 |         /// <returns>If the function succeeds, the return value is nonzero.
28 |         /// If the function fails, the return value is zero. 
29 |         /// To get extended error information, call Marshal.GetLastWin32Error.</returns>
30 |         [DllImport("kernel32", SetLastError = true)]
31 |         public static extern bool AllocConsole();
32 | 
33 |         /// <summary>
34 |         /// Detaches the calling process from its console
35 |         /// </summary>
36 |         /// <returns>If the function succeeds, the return value is nonzero.
37 |         /// If the function fails, the return value is zero. 
38 |         /// To get extended error information, call Marshal.GetLastWin32Error.</returns>
39 |         [DllImport("kernel32", SetLastError = true)]
40 |         public static extern bool FreeConsole();
41 | 
42 |         /// <summary>
43 |         /// Attaches the calling process to the console of the specified process.
44 |         /// </summary>
45 |         /// <param name="dwProcessId">[in] Identifier of the process, usually will be ATTACH_PARENT_PROCESS</param>
46 |         /// <returns>If the function succeeds, the return value is nonzero.
47 |         /// If the function fails, the return value is zero. 
48 |         /// To get extended error information, call Marshal.GetLastWin32Error.</returns>
49 |         [DllImport("kernel32.dll", SetLastError = true)]
50 |         public static extern bool AttachConsole(uint dwProcessId);
51 | 
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher/IConsoleApp.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading;
 3 | 
 4 | namespace SlavaGu.ConsoleAppLauncher
 5 | {
 6 |     public enum AppState
 7 |     {
 8 |         Undefined = 0,
 9 |         Running = 1,
10 |         Exiting = 2,
11 |         Exited = 3,
12 |     }
13 | 
14 |     /// <summary>
15 |     /// Defines an interface to a console app wrapper
16 |     /// </summary>
17 |     public interface IConsoleApp : IDisposable
18 |     {
19 |         /// <summary>
20 |         /// File name of the app, e.g. "cmd.exe"
21 |         /// </summary>
22 |         string FileName { get; }
23 | 
24 |         /// <summary>
25 |         /// Command line of the app, e.g. "/c dir"
26 |         /// </summary>
27 |         string CmdLine { get; }
28 | 
29 |         /// <summary>
30 |         /// Current state of the app.
31 |         /// </summary>
32 |         AppState State { get; }
33 | 
34 |         /// <summary>
35 |         /// Exit code of the app.
36 |         /// </summary>
37 |         int? ExitCode { get; }
38 | 
39 |         /// <summary>
40 |         /// Timestamp the app has exited.
41 |         /// </summary>
42 |         DateTime? ExitTime { get; }
43 | 
44 |         /// <summary>
45 |         /// Start the app.
46 |         /// </summary>
47 |         void Run();
48 | 
49 |         /// <summary>
50 |         /// Stop the app.
51 |         /// </summary>
52 |         /// <param name="closeKey">Special key to send to close the app [default=Ctrl-C]</param>
53 |         /// <param name="forceCloseMillisecondsTimeout">Timeout to wait before closing the app forcefully [default=infinite]</param>
54 |         void Stop(ConsoleSpecialKey closeKey = ConsoleSpecialKey.ControlC, int forceCloseMillisecondsTimeout = Timeout.Infinite);
55 | 
56 |         /// <summary>
57 |         /// Wait until the app exits.
58 |         /// </summary>
59 |         /// <param name="millisecondsTimeout">Timeout to wait until the app is exited [default=infinite]</param>
60 |         /// <returns>True if exited or False if timeout elapsed</returns>
61 |         bool WaitForExit(int millisecondsTimeout = Timeout.Infinite);
62 | 
63 |         /// <summary>
64 |         /// Writes a string to the console.
65 |         /// </summary>
66 |         void Write(string value);
67 | 
68 |         /// <summary>
69 |         /// Writes a string followed by a line terminator to the console.
70 |         /// </summary>
71 |         void WriteLine(string value);
72 | 
73 |         /// <summary>
74 |         /// Fires when the console outputs a new line or error.
75 |         /// </summary>
76 |         /// <remarks>The lines are queued and guaranteed to follow the output order</remarks>
77 |         event EventHandler<ConsoleOutputEventArgs> ConsoleOutput;
78 | 
79 |         /// <summary>
80 |         /// Fires when the app exits.
81 |         /// </summary>
82 |         event EventHandler<EventArgs> Exited;
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | #################
  2 | ## Eclipse
  3 | #################
  4 | 
  5 | *.pydevproject
  6 | .project
  7 | .metadata
  8 | bin/
  9 | tmp/
 10 | *.tmp
 11 | *.bak
 12 | *.swp
 13 | *~.nib
 14 | local.properties
 15 | .classpath
 16 | .settings/
 17 | .loadpath
 18 | .vs
 19 | PublishedPackages
 20 | 
 21 | # External tool builders
 22 | .externalToolBuilders/
 23 | 
 24 | # Locally stored "Eclipse launch configurations"
 25 | *.launch
 26 | 
 27 | # CDT-specific
 28 | .cproject
 29 | 
 30 | # PDT-specific
 31 | .buildpath
 32 | 
 33 | 
 34 | #################
 35 | ## Visual Studio
 36 | #################
 37 | 
 38 | ## Ignore Visual Studio temporary files, build results, and
 39 | ## files generated by popular Visual Studio add-ons.
 40 | 
 41 | # User-specific files
 42 | *.suo
 43 | *.user
 44 | *.sln.docstates
 45 | TestResult.xml
 46 | 
 47 | # Build results
 48 | [Dd]ebug/
 49 | [Rr]elease/
 50 | *_i.c
 51 | *_p.c
 52 | *.ilk
 53 | *.meta
 54 | *.obj
 55 | *.pch
 56 | *.pdb
 57 | *.pgc
 58 | *.pgd
 59 | *.rsp
 60 | *.sbr
 61 | *.tlb
 62 | *.tli
 63 | *.tlh
 64 | *.tmp
 65 | *.vspscc
 66 | .builds
 67 | *.dotCover
 68 | 
 69 | ## TODO: If you have NuGet Package Restore enabled, uncomment this
 70 | packages/
 71 | 
 72 | # Visual C++ cache files
 73 | ipch/
 74 | *.aps
 75 | *.ncb
 76 | *.opensdf
 77 | *.sdf
 78 | 
 79 | # Visual Studio profiler
 80 | *.psess
 81 | *.vsp
 82 | 
 83 | # ReSharper is a .NET coding add-in
 84 | _ReSharper*
 85 | 
 86 | # Installshield output folder
 87 | [Ee]xpress
 88 | 
 89 | # DocProject is a documentation generator add-in
 90 | DocProject/buildhelp/
 91 | DocProject/Help/*.HxT
 92 | DocProject/Help/*.HxC
 93 | DocProject/Help/*.hhc
 94 | DocProject/Help/*.hhk
 95 | DocProject/Help/*.hhp
 96 | DocProject/Help/Html2
 97 | DocProject/Help/html
 98 | 
 99 | # Click-Once directory
100 | publish
101 | 
102 | # Others
103 | [Bb]in
104 | [Oo]bj
105 | sql
106 | TestResults
107 | *.Cache
108 | ClientBin
109 | stylecop.*
110 | ~$*
111 | *.dbmdl
112 | Generated_Code #added for RIA/Silverlight projects
113 | 
114 | # Backup & report files from converting an old project file to a newer
115 | # Visual Studio version. Backup files are not needed, because we have git ;-)
116 | _UpgradeReport_Files/
117 | Backup*/
118 | UpgradeLog*.XML
119 | 
120 | 
121 | 
122 | ############
123 | ## Windows
124 | ############
125 | 
126 | # Windows image file caches
127 | Thumbs.db
128 | 
129 | # Folder config file
130 | Desktop.ini
131 | 
132 | 
133 | #############
134 | ## Python
135 | #############
136 | 
137 | *.py[co]
138 | 
139 | # Packages
140 | *.egg
141 | *.egg-info
142 | dist
143 | build
144 | eggs
145 | parts
146 | bin
147 | var
148 | sdist
149 | develop-eggs
150 | .installed.cfg
151 | 
152 | # Installer logs
153 | pip-log.txt
154 | 
155 | # Unit test / coverage reports
156 | .coverage
157 | .tox
158 | 
159 | #Translations
160 | *.mo
161 | 
162 | #Mr Developer
163 | .mr.developer.cfg
164 | 
165 | # Mac crap
166 | .DS_Store
167 | 
168 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Introduction
 2 | 
 3 | ConsoleAppLauncher is a Windows Console Application wrapper for .NET written in C#.
 4 | 
 5 | It captures all the output generated in the console and provides simple 
 6 | interface to start and close console application. The ConsoleOutput 
 7 | event is fired every time when a new line is written by the console to 
 8 | standard/error output. The lines are queued and guaranteed to follow the 
 9 | output order. 
10 | 
11 | For rationale [see this SO question](http://stackoverflow.com/questions/186822/capturing-console-output-from-a-net-application-c).
12 | 
13 | # Samples
14 | 
15 | Usage samples are available in the ConsoleAppLauncher.Samples project. 
16 | 
17 |         // Run simplest shell command and return its output.
18 |         public static string GetWindowsVersion()
19 |         {
20 |             return ConsoleApp.Run("cmd", "/c ver").Output.Trim();
21 |         }
22 | 
23 |         // Run ipconfig.exe and return matching line.
24 |         public static string GetIpAddress()
25 |         {
26 |             var output = ConsoleApp.Run("ipconfig").Output;
27 |             var match = Regex.Match(output, "IPv4 Address.*: (?<addr>.*)");
28 |             return match.Success ? match.Groups["addr"].Value : "<undefined>";
29 |         }
30 | 
31 |         // Run ping.exe asynchronously and return roundtrip times in a callback
32 | 	// sample call:
33 |         //    Action<string> action = Console.WriteLine;
34 |         //    PingUrl("google.com", action);         
35 |         public static void PingUrl(string url, Action<string> replyHandler)
36 |         {
37 |             var regex = new Regex("(time=|Average = )(?<time>.*?ms)", RegexOptions.Compiled);
38 |             var app = new ConsoleApp("ping", url);
39 |             app.ConsoleOutput += (o, args) =>
40 |             {
41 |                 var match = regex.Match(args.Line);
42 |                 if (match.Success)
43 |                 {
44 |                     var roundtripTime = match.Groups["time"].Value;
45 |                     replyHandler(roundtripTime);
46 |                 }
47 |             };
48 |             app.Run();
49 |             app.WaitForExit();
50 |         }
51 | 
52 |         // Get Windows firewall rule
53 |         public static string GetFirewallRule(string ruleName)
54 |         {
55 |             var cmdLine = string.Format("advfirewall firewall show rule \"{0}\" verbose", ruleName);
56 |             return ConsoleApp.Run("netsh", cmdLine).Output.Trim();
57 |         }
58 | 
59 | 
60 | # License
61 | 
62 | This library is released under The MIT License (MIT).
63 | 
64 | 	Copyright (c) 2013 Slava Guzenko 
65 | 
66 | 	Permission is hereby granted, free of charge, to any person obtaining a 
67 | 	copy of this software and associated documentation files (the 
68 | 	"Software"), to deal in the Software without restriction, including 
69 | 	without limitation the rights to use, copy, modify, merge, publish, 
70 | 	distribute, sublicense, and/or sell copies of the Software, and to 
71 | 	permit persons to whom the Software is furnished to do so, subject to 
72 | 	the following conditions: 
73 | 
74 | 	The above copyright notice and this permission notice shall be included 
75 | 	in all copies or substantial portions of the Software. 
76 | 
77 | 	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
78 | 	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
79 | 	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
80 | 	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
81 | 	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
82 | 	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
83 | 	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
84 | 


--------------------------------------------------------------------------------
/DummyConsoleApplication/Program.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Globalization;
  3 | using System.Threading;
  4 | using NDesk.Options;
  5 | 
  6 | namespace DummyConsoleApplication
  7 | {
  8 |     public class Program
  9 |     {
 10 |         public enum ExitCode
 11 |         {
 12 |             Success = 0,
 13 |             AbortedWithCtrlC = 1,
 14 |             AbortedWithCtrlBreak = 2,
 15 |             Unexpected = 3,
 16 |         }
 17 | 
 18 |         static void Main(string[] args)
 19 |         {
 20 |             string outputLine = null;
 21 |             int repeat = 10;
 22 |             int delay = 100;
 23 |             bool unstoppable = false;
 24 |             string prompt = null;
 25 | 
 26 |             var optionSet = new OptionSet
 27 |             {
 28 |                 { "o|output=", "[required] output line format, e.g. 'Line #', where # is replaced with line number.", s => outputLine = s },
 29 |                 { "r|repeat=", "number of {TIMES} to output the line.", (int v) => repeat = v },
 30 |                 { "d|delay=", "number of milliseconds to {DELAY} between lines.", (int v) => delay = v },
 31 |                 { "u|unstoppable=", "flag to ignore cancellation via Ctrl-Break.", (bool v) => unstoppable = v },
 32 |                 { "p|prompt=", "prompt to ask for user input.", s => prompt = s },
 33 |             };
 34 | 
 35 |             try
 36 |             {
 37 |                 optionSet.Parse(args);
 38 | 
 39 |                 if (outputLine == null)
 40 |                     throw new OptionException("Required parameter is missing", "output");
 41 |             }
 42 |             catch (OptionException e)
 43 |             {
 44 |                 Console.WriteLine("Invalid command line arguments: {0}; name: '{1}'", e.Message, e.OptionName);
 45 |                 Console.WriteLine();
 46 |                 Console.WriteLine("Supported arguments:");
 47 |                 optionSet.WriteOptionDescriptions(Console.Out);
 48 |                 return;
 49 |             }
 50 | 
 51 |             Console.CancelKeyPress += (sender, e) =>
 52 |             {
 53 |                 if (e.SpecialKey == ConsoleSpecialKey.ControlC)
 54 |                 {
 55 |                     if (unstoppable)
 56 |                     {
 57 |                         Console.WriteLine("Ctrl-C pressed, ignoring...");
 58 |                         e.Cancel = true;
 59 |                     }
 60 |                     else
 61 |                     {
 62 |                         Console.WriteLine("Ctrl-C pressed, exiting...");
 63 |                         Environment.Exit((int)ExitCode.AbortedWithCtrlC);
 64 |                     }
 65 |                 }
 66 |                 else if (e.SpecialKey == ConsoleSpecialKey.ControlBreak)
 67 |                 {
 68 |                     Console.WriteLine("Ctrl-Break pressed, can't avoid exiting...");
 69 |                     Environment.Exit((int)ExitCode.AbortedWithCtrlBreak);
 70 |                 }
 71 |                 else
 72 |                 {
 73 |                     Console.WriteLine("Unexpected signal {0} received, exiting...", e.SpecialKey.ToString());
 74 |                     Environment.Exit((int)ExitCode.Unexpected);
 75 |                 }
 76 |             };
 77 | 
 78 |             if (!string.IsNullOrEmpty(prompt))
 79 |             {
 80 |                 Console.WriteLine(prompt);
 81 |                 char ch = (char)Console.Read();
 82 |                 string str = Console.ReadLine();
 83 |                 Console.WriteLine("{0}{1}", ch, str);
 84 |             }
 85 | 
 86 |             for (int i = 1; i <= repeat; i++)
 87 |             {
 88 |                 Console.WriteLine(outputLine.Replace("#", i.ToString(CultureInfo.InvariantCulture)));
 89 |                 if (delay > 0)
 90 |                 {
 91 |                     Thread.Sleep(delay);
 92 |                 }
 93 |             }
 94 | 
 95 |             Environment.Exit((int)ExitCode.Success);
 96 |         }
 97 | 
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.31005.135
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleAppLauncher.Tests", "ConsoleAppLauncher.Tests\ConsoleAppLauncher.Tests.csproj", "{2C4C68E7-CAFF-45FF-81E0-998724E63E78}"
 7 | EndProject
 8 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{1DFE3034-7ABE-4AD1-ACFA-AEC9484A84F0}"
 9 | 	ProjectSection(SolutionItems) = preProject
10 | 		.gitattributes = .gitattributes
11 | 		.gitignore = .gitignore
12 | 		build.bat = build.bat
13 | 		license.txt = license.txt
14 | 		publish.bat = publish.bat
15 | 		readme.md = readme.md
16 | 	EndProjectSection
17 | EndProject
18 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DummyConsoleApplication", "DummyConsoleApplication\DummyConsoleApplication.csproj", "{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}"
19 | EndProject
20 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleAppLauncher.Samples", "ConsoleAppLauncher.Samples\ConsoleAppLauncher.Samples.csproj", "{E752D3D4-9A35-404F-9A03-308115D93A11}"
21 | EndProject
22 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleAppLauncher", "ConsoleAppLauncher\ConsoleAppLauncher.csproj", "{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}"
23 | EndProject
24 | Global
25 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
26 | 		Debug|Any CPU = Debug|Any CPU
27 | 		Debug|Mixed Platforms = Debug|Mixed Platforms
28 | 		Debug|x86 = Debug|x86
29 | 		Release|Any CPU = Release|Any CPU
30 | 		Release|Mixed Platforms = Release|Mixed Platforms
31 | 		Release|x86 = Release|x86
32 | 	EndGlobalSection
33 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
34 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
35 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Debug|Any CPU.Build.0 = Debug|Any CPU
36 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
37 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
38 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Debug|x86.ActiveCfg = Debug|Any CPU
39 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Release|Any CPU.ActiveCfg = Release|Any CPU
40 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Release|Any CPU.Build.0 = Release|Any CPU
41 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
42 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Release|Mixed Platforms.Build.0 = Release|Any CPU
43 | 		{2C4C68E7-CAFF-45FF-81E0-998724E63E78}.Release|x86.ActiveCfg = Release|Any CPU
44 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Debug|Any CPU.ActiveCfg = Debug|x86
45 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
46 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Debug|Mixed Platforms.Build.0 = Debug|x86
47 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Debug|x86.ActiveCfg = Debug|x86
48 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Debug|x86.Build.0 = Debug|x86
49 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Release|Any CPU.ActiveCfg = Release|x86
50 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Release|Mixed Platforms.ActiveCfg = Release|x86
51 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Release|Mixed Platforms.Build.0 = Release|x86
52 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Release|x86.ActiveCfg = Release|x86
53 | 		{D4694E4B-E8C9-42BA-9566-70CA8BE11F58}.Release|x86.Build.0 = Release|x86
54 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Debug|Any CPU.ActiveCfg = Debug|x86
55 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
56 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Debug|Mixed Platforms.Build.0 = Debug|x86
57 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Debug|x86.ActiveCfg = Debug|x86
58 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Debug|x86.Build.0 = Debug|x86
59 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Release|Any CPU.ActiveCfg = Release|x86
60 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Release|Mixed Platforms.ActiveCfg = Release|x86
61 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Release|Mixed Platforms.Build.0 = Release|x86
62 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Release|x86.ActiveCfg = Release|x86
63 | 		{E752D3D4-9A35-404F-9A03-308115D93A11}.Release|x86.Build.0 = Release|x86
64 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
65 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
66 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
67 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
68 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|x86.ActiveCfg = Debug|Any CPU
69 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Debug|x86.Build.0 = Debug|Any CPU
70 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
71 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|Any CPU.Build.0 = Release|Any CPU
72 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
73 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|Mixed Platforms.Build.0 = Release|Any CPU
74 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|x86.ActiveCfg = Release|Any CPU
75 | 		{5E94F4C6-DB44-423A-A4CC-2C6D9F3684A1}.Release|x86.Build.0 = Release|Any CPU
76 | 	EndGlobalSection
77 | 	GlobalSection(SolutionProperties) = preSolution
78 | 		HideSolutionNode = FALSE
79 | 	EndGlobalSection
80 | 	GlobalSection(ExtensibilityGlobals) = postSolution
81 | 		SolutionGuid = {1F618BE7-9E06-4B2F-AAEF-619779F0C8EF}
82 | 	EndGlobalSection
83 | 	GlobalSection(TestCaseManagementSettings) = postSolution
84 | 		CategoryFile = ConsoleAppLauncher.vsmdi
85 | 	EndGlobalSection
86 | EndGlobal
87 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/Samples.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 | </root>


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Tests/ConsoleAppTest.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Globalization;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using System.Reflection;
  7 | using System.Threading;
  8 | using NUnit.Framework;
  9 | using SlavaGu.ConsoleAppLauncher;
 10 | 
 11 | namespace ConsoleAppLauncher.Tests
 12 | {
 13 |     [TestFixture]
 14 |     public class ConsoleAppTest
 15 |     {
 16 |         private static IConsoleApp GetDummyApp(string outputLine, int repeat, int delay, bool unstoppable, string prompt = null)
 17 |         {
 18 |             var cmdLine = string.Format("-output=\"{0}\" -repeat={1} -delay={2} -unstoppable={3} -prompt=\"{4}\"", outputLine, repeat, delay, unstoppable, prompt);
 19 |             var currentDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
 20 |             return new ConsoleApp(Path.Combine(currentDirectory, "DummyConsoleApplication.exe"), cmdLine);
 21 |         }
 22 | 
 23 |         [Test]
 24 |         public void should_get_all_lines_with_slow_console_output()
 25 |         {
 26 |             // Arrange
 27 |             const int repeat = 10;
 28 |             const int delay = 100;
 29 |             const string outputLine = "Line #";
 30 |             const bool unstoppable = false;
 31 | 
 32 |             var app = GetDummyApp(outputLine, repeat, delay, unstoppable);
 33 |             var expected = Enumerable.Range(1, repeat).Select(i => outputLine.Replace("#", i.ToString(CultureInfo.InvariantCulture))).ToArray();
 34 |             var actual = new List<string>();
 35 |             app.ConsoleOutput += (sender, args) => actual.Add(args.Line);
 36 | 
 37 |             // Act
 38 |             app.Run();
 39 |             var exited = app.WaitForExit(10000);
 40 | 
 41 |             // Assert
 42 |             Assert.IsTrue(exited, "App hasn't exited within allowed timeout");
 43 |             Assert.AreEqual(0, app.ExitCode, "Unexpected exit code");
 44 |             Assert.IsTrue(expected.SequenceEqual(actual), "Captured output is not as expected");
 45 |         }
 46 | 
 47 |         [Test]
 48 |         public void should_get_all_lines_with_fast_console_output()
 49 |         {
 50 |             // Arrange
 51 |             const int repeat = 1000;
 52 |             const int delay = 0;
 53 |             const string outputLine = "Line #";
 54 |             const bool unstoppable = false;
 55 | 
 56 |             var app = GetDummyApp(outputLine, repeat, delay, unstoppable);
 57 |             var expected = Enumerable.Range(1, repeat).Select(i => outputLine.Replace("#", i.ToString(CultureInfo.InvariantCulture))).ToArray();
 58 |             var actual = new List<string>();
 59 |             app.ConsoleOutput += (sender, args) => actual.Add(args.Line);
 60 | 
 61 |             // Act
 62 |             app.Run();
 63 |             var exited = app.WaitForExit(10000);
 64 | 
 65 |             // Assert
 66 |             Assert.IsTrue(exited, "App hasn't exited within allowed timeout");
 67 |             Assert.AreEqual(0, app.ExitCode, "Unexpected exit code");
 68 |             Assert.IsTrue(expected.SequenceEqual(actual), "Captured output is not as expected");
 69 |         }
 70 | 
 71 |         [Test]
 72 |         public void should_stop_properly_while_running()
 73 |         {
 74 |             // Arrange
 75 |             const int repeat = 1000;
 76 |             const int delay = 100;
 77 |             const string outputLine = "Line #";
 78 |             const bool unstoppable = false;
 79 | 
 80 |             var app = GetDummyApp(outputLine, repeat, delay, unstoppable);
 81 |             var actual = new List<string>();
 82 |             app.ConsoleOutput += (sender, args) => actual.Add(args.Line);
 83 | 
 84 |             // Act
 85 |             app.Run();
 86 |             Thread.Sleep(500);
 87 |             app.Stop(ConsoleSpecialKey.ControlC, 500);
 88 |             var exited = app.WaitForExit(10000);
 89 | 
 90 |             // Assert
 91 |             Assert.IsTrue(exited, "App hasn't exited within allowed timeout");
 92 |             Assert.AreEqual(-1, app.ExitCode, "App should have been terminated by CTRL-C");
 93 |             Assert.IsTrue(actual.Any(), "No output captured");
 94 |             Assert.AreNotEqual(repeat, actual.Count(), "App hasn't been stopped");
 95 |         }
 96 | 
 97 |         [Test]
 98 |         public void should_abort_if_nonstoppable()
 99 |         {
100 |             // Arrange
101 |             const int repeat = 1000;
102 |             const int delay = 100;
103 |             const string outputLine = "Line #";
104 |             const bool unstoppable = true;
105 | 
106 |             var app = GetDummyApp(outputLine, repeat, delay, unstoppable);
107 |             var actual = new List<string>();
108 |             app.ConsoleOutput += (sender, args) => actual.Add(args.Line);
109 | 
110 |             // Act
111 |             app.Run();
112 |             Thread.Sleep(500);
113 |             app.Stop(ConsoleSpecialKey.ControlC, 500);
114 |             var exited = app.WaitForExit(10000);
115 | 
116 |             // Assert
117 |             Assert.IsTrue(exited, "App hasn't exited within allowed timeout");
118 |             Assert.AreEqual(-1, app.ExitCode, "App should have been terminated forcefully");
119 |             Assert.IsTrue(actual.Any(), "No output captured");
120 |             Assert.AreNotEqual(repeat, actual.Count(), "App hasn't been stopped");
121 |         }
122 | 
123 |         [Test]
124 |         public void should_get_input_redirect()
125 |         {
126 |             // Arrange
127 |             const int repeat = 0;
128 |             const int delay = 0;
129 |             const string outputLine = "Line #";
130 |             const bool unstoppable = false;
131 |             const string prompt = "Enter anything and press Enter...";
132 | 
133 |             var app = GetDummyApp(outputLine, repeat, delay, unstoppable, prompt);
134 |             var expected = new List<string> { prompt, "Hello, World!" };
135 |             var actual = new List<string>();
136 |             app.ConsoleOutput += (sender, args) => actual.Add(args.Line);
137 | 
138 |             // Act
139 |             app.Run();
140 |             app.Write("Hello, ");
141 |             app.WriteLine("World!");
142 |             var exited = app.WaitForExit(10000);
143 | 
144 |             // Assert
145 |             Assert.IsTrue(exited, "App hasn't exited within allowed timeout");
146 |             Assert.AreEqual(0, app.ExitCode, "Unexpected exit code");
147 |             Assert.IsTrue(expected.SequenceEqual(actual), "Captured output is not as expected");
148 |         }
149 | 
150 |     }
151 | }
152 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher.Samples/Samples.Designer.cs:
--------------------------------------------------------------------------------
  1 | namespace SlavaGu.ConsoleAppLauncher.Samples
  2 | {
  3 |     partial class Form1
  4 |     {
  5 |         /// <summary>
  6 |         /// Required designer variable.
  7 |         /// </summary>
  8 |         private System.ComponentModel.IContainer components = null;
  9 | 
 10 |         /// <summary>
 11 |         /// Clean up any resources being used.
 12 |         /// </summary>
 13 |         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
 14 |         protected override void Dispose(bool disposing)
 15 |         {
 16 |             if (disposing && (components != null))
 17 |             {
 18 |                 components.Dispose();
 19 |             }
 20 |             base.Dispose(disposing);
 21 |         }
 22 | 
 23 |         #region Windows Form Designer generated code
 24 | 
 25 |         /// <summary>
 26 |         /// Required method for Designer support - do not modify
 27 |         /// the contents of this method with the code editor.
 28 |         /// </summary>
 29 |         private void InitializeComponent()
 30 |         {
 31 |             this.buttonGetIpAddress = new System.Windows.Forms.Button();
 32 |             this.labelIpAddress = new System.Windows.Forms.Label();
 33 |             this.buttonPing = new System.Windows.Forms.Button();
 34 |             this.labelPing = new System.Windows.Forms.Label();
 35 |             this.buttonVer = new System.Windows.Forms.Button();
 36 |             this.labelVer = new System.Windows.Forms.Label();
 37 |             this.buttonSkype = new System.Windows.Forms.Button();
 38 |             this.labelSkype = new System.Windows.Forms.Label();
 39 |             this.SuspendLayout();
 40 |             // 
 41 |             // buttonGetIpAddress
 42 |             // 
 43 |             this.buttonGetIpAddress.Location = new System.Drawing.Point(12, 43);
 44 |             this.buttonGetIpAddress.Name = "buttonGetIpAddress";
 45 |             this.buttonGetIpAddress.Size = new System.Drawing.Size(130, 23);
 46 |             this.buttonGetIpAddress.TabIndex = 2;
 47 |             this.buttonGetIpAddress.Text = "Get local IP Address";
 48 |             this.buttonGetIpAddress.UseVisualStyleBackColor = true;
 49 |             this.buttonGetIpAddress.Click += new System.EventHandler(this.buttonGetIpAddress_Click);
 50 |             // 
 51 |             // labelIpAddress
 52 |             // 
 53 |             this.labelIpAddress.AutoSize = true;
 54 |             this.labelIpAddress.Location = new System.Drawing.Point(148, 48);
 55 |             this.labelIpAddress.Name = "labelIpAddress";
 56 |             this.labelIpAddress.Size = new System.Drawing.Size(67, 13);
 57 |             this.labelIpAddress.TabIndex = 3;
 58 |             this.labelIpAddress.Text = "<ip address>";
 59 |             // 
 60 |             // buttonPing
 61 |             // 
 62 |             this.buttonPing.Location = new System.Drawing.Point(12, 72);
 63 |             this.buttonPing.Name = "buttonPing";
 64 |             this.buttonPing.Size = new System.Drawing.Size(130, 23);
 65 |             this.buttonPing.TabIndex = 4;
 66 |             this.buttonPing.Text = "Ping google.com";
 67 |             this.buttonPing.UseVisualStyleBackColor = true;
 68 |             this.buttonPing.Click += new System.EventHandler(this.buttonPing_Click);
 69 |             // 
 70 |             // labelPing
 71 |             // 
 72 |             this.labelPing.AutoSize = true;
 73 |             this.labelPing.Location = new System.Drawing.Point(148, 77);
 74 |             this.labelPing.Name = "labelPing";
 75 |             this.labelPing.Size = new System.Drawing.Size(82, 13);
 76 |             this.labelPing.TabIndex = 5;
 77 |             this.labelPing.Text = "<roundtrip time>";
 78 |             // 
 79 |             // buttonVer
 80 |             // 
 81 |             this.buttonVer.Location = new System.Drawing.Point(12, 14);
 82 |             this.buttonVer.Name = "buttonVer";
 83 |             this.buttonVer.Size = new System.Drawing.Size(130, 23);
 84 |             this.buttonVer.TabIndex = 0;
 85 |             this.buttonVer.Text = "Get Windows Version";
 86 |             this.buttonVer.UseVisualStyleBackColor = true;
 87 |             this.buttonVer.Click += new System.EventHandler(this.buttonVer_Click);
 88 |             // 
 89 |             // labelVer
 90 |             // 
 91 |             this.labelVer.AutoSize = true;
 92 |             this.labelVer.Location = new System.Drawing.Point(148, 19);
 93 |             this.labelVer.Name = "labelVer";
 94 |             this.labelVer.Size = new System.Drawing.Size(97, 13);
 95 |             this.labelVer.TabIndex = 1;
 96 |             this.labelVer.Text = "<windows version>";
 97 |             // 
 98 |             // buttonSkype
 99 |             // 
100 |             this.buttonSkype.Location = new System.Drawing.Point(13, 102);
101 |             this.buttonSkype.Name = "buttonSkype";
102 |             this.buttonSkype.Size = new System.Drawing.Size(129, 23);
103 |             this.buttonSkype.TabIndex = 6;
104 |             this.buttonSkype.Text = "Get Skype Firewall rule";
105 |             this.buttonSkype.UseVisualStyleBackColor = true;
106 |             this.buttonSkype.Click += new System.EventHandler(this.buttonSkype_Click);
107 |             // 
108 |             // labelSkype
109 |             // 
110 |             this.labelSkype.AutoSize = true;
111 |             this.labelSkype.Location = new System.Drawing.Point(148, 107);
112 |             this.labelSkype.Name = "labelSkype";
113 |             this.labelSkype.Size = new System.Drawing.Size(102, 13);
114 |             this.labelSkype.TabIndex = 7;
115 |             this.labelSkype.Text = "<skype firewall rule>";
116 |             // 
117 |             // Form1
118 |             // 
119 |             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
120 |             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
121 |             this.ClientSize = new System.Drawing.Size(534, 332);
122 |             this.Controls.Add(this.labelSkype);
123 |             this.Controls.Add(this.buttonSkype);
124 |             this.Controls.Add(this.labelVer);
125 |             this.Controls.Add(this.buttonVer);
126 |             this.Controls.Add(this.labelPing);
127 |             this.Controls.Add(this.buttonPing);
128 |             this.Controls.Add(this.labelIpAddress);
129 |             this.Controls.Add(this.buttonGetIpAddress);
130 |             this.Name = "Form1";
131 |             this.Text = "ConsoleAppLauncher Samples";
132 |             this.ResumeLayout(false);
133 |             this.PerformLayout();
134 | 
135 |         }
136 | 
137 |         #endregion
138 | 
139 |         private System.Windows.Forms.Button buttonGetIpAddress;
140 |         private System.Windows.Forms.Label labelIpAddress;
141 |         private System.Windows.Forms.Button buttonPing;
142 |         private System.Windows.Forms.Label labelPing;
143 |         private System.Windows.Forms.Button buttonVer;
144 |         private System.Windows.Forms.Label labelVer;
145 |         private System.Windows.Forms.Button buttonSkype;
146 |         private System.Windows.Forms.Label labelSkype;
147 |     }
148 | }
149 | 
150 | 


--------------------------------------------------------------------------------
/ConsoleAppLauncher/ConsoleApp.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Concurrent;
  3 | using System.Diagnostics;
  4 | using System.Text;
  5 | using System.Threading;
  6 | using System.Threading.Tasks;
  7 | 
  8 | namespace SlavaGu.ConsoleAppLauncher
  9 | {
 10 |     public class ConsoleApp : IConsoleApp
 11 |     {
 12 |         private Process _process;
 13 |         private AutoResetEvent _processEvent;
 14 |         private ConcurrentQueue<ConsoleOutputEventArgs> _consoleOutputQueue;
 15 |         
 16 |         private Task _processMonitor;
 17 |         private CancellationTokenSource _cancellationTokenSource;
 18 |         
 19 |         private readonly object _stateLock = new object();
 20 |         private readonly Win32.ConsoleCtrlEventHandler _consoleCtrlEventHandler;
 21 | 
 22 |         /// <summary>
 23 |         /// ConsoleApp constructor
 24 |         /// </summary>
 25 |         /// <param name="fileName">File name or DOS command</param>
 26 |         /// <param name="cmdLine">Command-line arguments</param>
 27 |         public ConsoleApp(string fileName, string cmdLine)
 28 |         {
 29 |             FileName = fileName;
 30 |             CmdLine = cmdLine;
 31 |             
 32 |             _consoleCtrlEventHandler += ConsoleCtrlHandler;
 33 |         }
 34 | 
 35 |         /// <summary>
 36 |         /// File name of the app, e.g. "cmd.exe"
 37 |         /// </summary>
 38 |         public string FileName { get; private set; }
 39 | 
 40 |         /// <summary>
 41 |         /// Command line of the app, e.g. "/c dir"
 42 |         /// </summary>
 43 |         public string CmdLine { get; private set; }
 44 | 
 45 |         /// <summary>
 46 |         /// Current state of the app.
 47 |         /// </summary>
 48 |         public AppState State { get; private set; }
 49 | 
 50 |         /// <summary>
 51 |         /// Exit code of the app.
 52 |         /// </summary>
 53 |         public int? ExitCode { get; private set; }
 54 | 
 55 |         /// <summary>
 56 |         /// Time the app has exited.
 57 |         /// </summary>
 58 |         public DateTime? ExitTime { get; private set; }
 59 | 
 60 |         /// <summary>
 61 |         /// Start the app.
 62 |         /// </summary>
 63 |         public void Run()
 64 |         {
 65 |             ThrowIfDisposed();
 66 | 
 67 |             lock (_stateLock)
 68 |             {
 69 |                 if (State == AppState.Running)
 70 |                     throw new InvalidOperationException("App is already running.");
 71 | 
 72 |                 if (State == AppState.Exiting)
 73 |                     throw new InvalidOperationException("App is exiting.");
 74 | 
 75 |                 StartProcessAsync();
 76 | 
 77 |                 State = AppState.Running;
 78 |             }
 79 |         }
 80 | 
 81 |         /// <summary>
 82 |         /// Stop the app.
 83 |         /// </summary>
 84 |         /// <param name="closeKey">Special key to send to close the app [default=Ctrl-C]</param>
 85 |         /// <param name="forceCloseMillisecondsTimeout">Timeout to wait before closing the app forcefully [default=infinite]</param>
 86 |         public void Stop(ConsoleSpecialKey closeKey = ConsoleSpecialKey.ControlC, int forceCloseMillisecondsTimeout = Timeout.Infinite)
 87 |         {
 88 |             ThrowIfDisposed();
 89 | 
 90 |             lock (_stateLock)
 91 |             {
 92 |                 if (State == AppState.Undefined || State == AppState.Exited)
 93 |                     throw new InvalidOperationException("App is not running.");
 94 | 
 95 |                 if (State == AppState.Exiting)
 96 |                     throw new InvalidOperationException("App is already exiting.");
 97 | 
 98 |                 State = AppState.Exiting;
 99 | 
100 |                 Task.Factory.StartNew(() => CloseConsole(closeKey, forceCloseMillisecondsTimeout), 
101 |                     TaskCreationOptions.LongRunning);
102 |             }
103 |         }
104 | 
105 |         /// <summary>
106 |         /// Wait until the app exits.
107 |         /// </summary>
108 |         /// <param name="millisecondsTimeout">Timeout to wait until the app is exited [default=infinite]</param>
109 |         /// <returns>True if exited or False if timeout elapsed</returns>
110 |         public bool WaitForExit(int millisecondsTimeout = Timeout.Infinite)
111 |         {
112 |             ThrowIfDisposed();
113 | 
114 |             if (State == AppState.Undefined || _processMonitor == null)
115 |             {
116 |                 Trace.TraceWarning("App hasn't started yet");
117 |                 return true;
118 |             }
119 | 
120 |             if (_processMonitor.IsCompleted)
121 |                 return true;
122 | 
123 |             Trace.TraceInformation("Waiting for app exit: Timeout={0}", millisecondsTimeout);
124 |             return _processMonitor.Wait(millisecondsTimeout);
125 |         }
126 | 
127 |         /// <summary>
128 |         /// Writes a string to the console.
129 |         /// </summary>
130 |         public void Write(string value)
131 |         {
132 |             if (_process == null || _process.HasExited)
133 |                 return;
134 | 
135 |             Trace.TraceInformation("stdin< {0}", value);
136 |             _process.StandardInput.Write(value);
137 |         }
138 | 
139 |         /// <summary>
140 |         /// Writes a string followed by a line terminator to the console.
141 |         /// </summary>
142 |         public void WriteLine(string value)
143 |         {
144 |             if (_process == null || _process.HasExited)
145 |                 return;
146 | 
147 |             Trace.TraceInformation("stdin< {0} <eol", value);
148 |             _process.StandardInput.WriteLine(value);
149 |         }
150 | 
151 |         /// <summary>
152 |         /// Fires when the app exits.
153 |         /// </summary>
154 |         public event EventHandler<EventArgs> Exited;
155 | 
156 |         /// <summary>
157 |         /// Fires when the console outputs a new line or error.
158 |         /// </summary>
159 |         /// <remarks>The lines are queued and guaranteed to follow the output order</remarks>
160 |         public event EventHandler<ConsoleOutputEventArgs> ConsoleOutput;
161 | 
162 |         private void StartProcessAsync()
163 |         {
164 |             _process = new Process
165 |             {
166 |                 EnableRaisingEvents = true,
167 |                 StartInfo =
168 |                 {
169 |                     FileName = FileName,
170 |                     Arguments = CmdLine,
171 |                     CreateNoWindow = true,
172 |                     RedirectStandardError = true,
173 |                     RedirectStandardOutput = true,
174 |                     RedirectStandardInput = true,
175 |                     UseShellExecute = false,
176 |                 },
177 |             };
178 | 
179 |             try
180 |             {
181 |                 Trace.TraceInformation("Starting app: '{0} {1}'", FileName, CmdLine);
182 | 
183 |                 _processEvent = new AutoResetEvent(false);
184 |                 _consoleOutputQueue = new ConcurrentQueue<ConsoleOutputEventArgs>();
185 | 
186 |                 _cancellationTokenSource = new CancellationTokenSource();
187 |                 var cancellationToken = _cancellationTokenSource.Token;
188 |                 _processMonitor = new Task(MonitoringHandler, cancellationToken, TaskCreationOptions.LongRunning);
189 |                 _processMonitor.Start();
190 | 
191 |                 _process.OutputDataReceived += OnOutputLineReceived;
192 |                 _process.ErrorDataReceived += OnErrorLineReceived;
193 |                 _process.Exited += OnProcessExited;
194 | 
195 |                 _process.Start();
196 | 
197 |                 _process.BeginErrorReadLine();
198 |                 _process.BeginOutputReadLine();
199 |             }
200 |             catch (Exception ex)
201 |             {
202 |                 Trace.TraceError("Could not start app: '{0} {1}', Error={2}", FileName, CmdLine, ex);
203 | 
204 |                 FreeProcessResources();
205 |                 if (_cancellationTokenSource != null)
206 |                 {
207 |                     _cancellationTokenSource.Cancel();
208 |                     _processMonitor = null;
209 |                 }
210 |                 throw;
211 |             }
212 |         }
213 | 
214 |         private void MonitoringHandler(object obj)
215 |         {
216 |             var cancellationToken = (CancellationToken)obj;
217 |             var supportedEvents = new [] { _processEvent, cancellationToken.WaitHandle };
218 | 
219 |             while (!cancellationToken.IsCancellationRequested)
220 |             {
221 |                 WaitHandle.WaitAny(supportedEvents);
222 | 
223 |                 // always dispatch output is case more than one event becomes signaled
224 |                 DispatchProcessOutput();
225 |             }
226 | 
227 |             HandleProcessExit();
228 |         }
229 | 
230 |         private void DispatchProcessOutput()
231 |         {
232 |             ConsoleOutputEventArgs args;
233 |             while (_consoleOutputQueue.TryDequeue(out args))
234 |             {
235 |                 try
236 |                 {
237 |                     OnConsoleOutput(args);
238 |                 }
239 |                 catch (Exception ex)
240 |                 {
241 |                     Trace.TraceError("OnConsoleOutput exception ignored: Error={0}", ex.ToString());
242 |                 }
243 |             }
244 |         }
245 | 
246 |         private void HandleProcessExit()
247 |         {
248 |             if (_process == null)
249 |                 return;
250 | 
251 |             lock (_stateLock)
252 |             {
253 |                 ExitCode = _process.ExitCode;
254 |                 ExitTime = _process.ExitTime;
255 | 
256 |                 FreeProcessResources();
257 |                 State = AppState.Exited;
258 |             }
259 |             try
260 |             {
261 |                 OnExited(new EventArgs());
262 |             }
263 |             catch (Exception ex)
264 |             {
265 |                 Trace.TraceError("OnExited exception ignored: Error={0}", ex.ToString());
266 |             }
267 |         }
268 | 
269 |         private void CloseConsole(ConsoleSpecialKey closeKey, int forceCloseMillisecondsTimeout)
270 |         {
271 |             if (_process == null || _process.HasExited)
272 |                 return;
273 | 
274 |             Trace.TraceInformation("Closing app input by sending Ctrl-Z signal");
275 |             _process.StandardInput.Close();
276 | 
277 |             if (_process == null || _process.HasExited)
278 |                 return;
279 | 
280 |             Trace.TraceInformation("Trying to close the app gracefully by sending " + closeKey);
281 |             Win32.AttachConsole((uint)_process.Id);
282 |             Win32.SetConsoleCtrlHandler(_consoleCtrlEventHandler, true);
283 |             var ctrlType = closeKey == ConsoleSpecialKey.ControlC ? Win32.CtrlType.CtrlCEvent : Win32.CtrlType.CtrlBreakEvent;
284 |             Win32.GenerateConsoleCtrlEvent(ctrlType, 0);
285 | 
286 |             if (_process == null || _process.HasExited)
287 |                 return;
288 | 
289 |             // close console forcefully if not finished within allowed timeout
290 |             Trace.TraceInformation("Waiting for voluntary app exit: Timeout={0}", forceCloseMillisecondsTimeout);
291 |             var exited = _process.WaitForExit(forceCloseMillisecondsTimeout);
292 |             if (!exited)
293 |             {
294 |                 Trace.TraceWarning("Closing the app forcefully");
295 |                 _process.Kill();
296 |             }
297 |         }
298 | 
299 |         private static bool ConsoleCtrlHandler(Win32.CtrlType ctrlType)
300 |         {
301 |             const bool ignore = true;
302 |             return ignore;
303 |         }
304 | 
305 |         private void FreeProcessResources()
306 |         {
307 |             if (_process != null)
308 |             {
309 |                 _process.OutputDataReceived -= OnOutputLineReceived;
310 |                 _process.ErrorDataReceived -= OnErrorLineReceived;
311 |                 _process.Exited -= OnProcessExited;
312 | 
313 |                 _process.Close();
314 |                 _process.Dispose();
315 |                 _process = null;
316 |             }
317 |         }
318 | 
319 |         private void OnOutputLineReceived(object sender, DataReceivedEventArgs e)
320 |         {
321 |             _consoleOutputQueue.Enqueue(new ConsoleOutputEventArgs(e.Data, false));
322 |             _processEvent.Set();
323 |         }
324 | 
325 |         private void OnErrorLineReceived(object sender, DataReceivedEventArgs e)
326 |         {
327 |             _consoleOutputQueue.Enqueue(new ConsoleOutputEventArgs(e.Data, true));
328 |             _processEvent.Set();
329 |         }
330 | 
331 |         private void OnProcessExited(object sender, EventArgs e)
332 |         {
333 |             _cancellationTokenSource.Cancel();
334 |             _processEvent.Set();
335 |         }
336 | 
337 |         protected virtual void OnConsoleOutput(ConsoleOutputEventArgs e)
338 |         {
339 |             if (e.Line == null)
340 |                 return;
341 | 
342 |             Trace.TraceInformation("{0}> {1}", e.IsError ? "stderr" : "stdout", e.Line);
343 | 
344 |             var handler = ConsoleOutput;
345 |             if (handler != null)
346 |                 handler(this, e);
347 |         }
348 | 
349 |         protected virtual void OnExited(EventArgs e)
350 |         {
351 |             Trace.TraceInformation("App exited: '{0} {1}', ExitCode={2}, ExitTime='{3}'", 
352 |                 FileName, CmdLine, ExitCode, ExitTime);
353 |             
354 |             var handler = Exited;
355 |             if (handler != null)
356 |                 handler(this, e);
357 |         }
358 | 
359 | 
360 |         #region IDisposable
361 | 
362 |         private bool _disposed;
363 | 
364 |         public void Dispose()
365 |         {
366 |             Dispose(true);
367 |             GC.SuppressFinalize(this);
368 |         }
369 | 
370 |         protected virtual void Dispose(bool disposing)
371 |         {
372 |             if (!_disposed)
373 |             {
374 |                 if (disposing)
375 |                 {
376 |                     CloseConsole(ConsoleSpecialKey.ControlBreak, 500);
377 |                     WaitForExit(500);
378 |                     FreeProcessResources();
379 |                 }
380 | 
381 |                 _disposed = true;
382 |             }
383 |         }
384 | 
385 |         ~ConsoleApp()
386 |         {
387 |             Dispose(false);
388 |         }
389 | 
390 |         private void ThrowIfDisposed()
391 |         {
392 |             if (_disposed)
393 |                 throw new ObjectDisposedException("Object was disposed.");
394 |         }
395 | 
396 |         #endregion
397 | 
398 | 
399 |         #region Static utility methods
400 | 
401 |         public class Result
402 |         {
403 |             public int ExitCode;
404 |             public string Output;
405 |         }
406 | 
407 |         /// <summary>
408 |         /// Run console app synchronously and capture all its output including standard error stream.
409 |         /// </summary>
410 |         /// <param name="fileName">File name or DOS command</param>
411 |         /// <param name="cmdLine">Command-line arguments</param>
412 |         /// <returns>Execution result</returns>
413 |         public static Result Run(string fileName, string cmdLine = null)
414 |         {
415 |             using (var app = new ConsoleApp(fileName, cmdLine))
416 |             {
417 |                 var outputStringBuilder = new StringBuilder();
418 |                 app.ConsoleOutput += (o, args) => outputStringBuilder.AppendLine(args.Line);
419 |                 
420 |                 app.Run();
421 |                 app.WaitForExit();
422 |                 
423 |                 var result = new Result
424 |                 {
425 |                     ExitCode = app.ExitCode.GetValueOrDefault(), 
426 |                     Output = outputStringBuilder.ToString()
427 |                 };
428 | 
429 |                 return result;
430 |             }
431 |         }
432 | 
433 |         #endregion
434 |     }
435 | }


--------------------------------------------------------------------------------
/DummyConsoleApplication/Options.cs:
--------------------------------------------------------------------------------
   1 | //
   2 | // Options.cs
   3 | //
   4 | // Authors:
   5 | //  Jonathan Pryor <jpryor@novell.com>
   6 | //
   7 | // Copyright (C) 2008 Novell (http://www.novell.com)
   8 | //
   9 | // Permission is hereby granted, free of charge, to any person obtaining
  10 | // a copy of this software and associated documentation files (the
  11 | // "Software"), to deal in the Software without restriction, including
  12 | // without limitation the rights to use, copy, modify, merge, publish,
  13 | // distribute, sublicense, and/or sell copies of the Software, and to
  14 | // permit persons to whom the Software is furnished to do so, subject to
  15 | // the following conditions:
  16 | // 
  17 | // The above copyright notice and this permission notice shall be
  18 | // included in all copies or substantial portions of the Software.
  19 | // 
  20 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 | // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 | // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 | // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 | // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 | // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 | // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 | //
  28 | 
  29 | // Compile With:
  30 | //   gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll
  31 | //   gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll
  32 | //
  33 | // The LINQ version just changes the implementation of
  34 | // OptionSet.Parse(IEnumerable<string>), and confers no semantic changes.
  35 | 
  36 | //
  37 | // A Getopt::Long-inspired option parsing library for C#.
  38 | //
  39 | // NDesk.Options.OptionSet is built upon a key/value table, where the
  40 | // key is a option format string and the value is a delegate that is 
  41 | // invoked when the format string is matched.
  42 | //
  43 | // Option format strings:
  44 | //  Regex-like BNF Grammar: 
  45 | //    name: .+
  46 | //    type: [=:]
  47 | //    sep: ( [^{}]+ | '{' .+ '}' )?
  48 | //    aliases: ( name type sep ) ( '|' name type sep )*
  49 | // 
  50 | // Each '|'-delimited name is an alias for the associated action.  If the
  51 | // format string ends in a '=', it has a required value.  If the format
  52 | // string ends in a ':', it has an optional value.  If neither '=' or ':'
  53 | // is present, no value is supported.  `=' or `:' need only be defined on one
  54 | // alias, but if they are provided on more than one they must be consistent.
  55 | //
  56 | // Each alias portion may also end with a "key/value separator", which is used
  57 | // to split option values if the option accepts > 1 value.  If not specified,
  58 | // it defaults to '=' and ':'.  If specified, it can be any character except
  59 | // '{' and '}' OR the *string* between '{' and '}'.  If no separator should be
  60 | // used (i.e. the separate values should be distinct arguments), then "{}"
  61 | // should be used as the separator.
  62 | //
  63 | // Options are extracted either from the current option by looking for
  64 | // the option name followed by an '=' or ':', or is taken from the
  65 | // following option IFF:
  66 | //  - The current option does not contain a '=' or a ':'
  67 | //  - The current option requires a value (i.e. not a Option type of ':')
  68 | //
  69 | // The `name' used in the option format string does NOT include any leading
  70 | // option indicator, such as '-', '--', or '/'.  All three of these are
  71 | // permitted/required on any named option.
  72 | //
  73 | // Option bundling is permitted so long as:
  74 | //   - '-' is used to start the option group
  75 | //   - all of the bundled options are a single character
  76 | //   - at most one of the bundled options accepts a value, and the value
  77 | //     provided starts from the next character to the end of the string.
  78 | //
  79 | // This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value'
  80 | // as '-Dname=value'.
  81 | //
  82 | // Option processing is disabled by specifying "--".  All options after "--"
  83 | // are returned by OptionSet.Parse() unchanged and unprocessed.
  84 | //
  85 | // Unprocessed options are returned from OptionSet.Parse().
  86 | //
  87 | // Examples:
  88 | //  int verbose = 0;
  89 | //  OptionSet p = new OptionSet ()
  90 | //    .Add ("v", v => ++verbose)
  91 | //    .Add ("name=|value=", v => Console.WriteLine (v));
  92 | //  p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"});
  93 | //
  94 | // The above would parse the argument string array, and would invoke the
  95 | // lambda expression three times, setting `verbose' to 3 when complete.  
  96 | // It would also print out "A" and "B" to standard output.
  97 | // The returned array would contain the string "extra".
  98 | //
  99 | // C# 3.0 collection initializers are supported and encouraged:
 100 | //  var p = new OptionSet () {
 101 | //    { "h|?|help", v => ShowHelp () },
 102 | //  };
 103 | //
 104 | // System.ComponentModel.TypeConverter is also supported, allowing the use of
 105 | // custom data types in the callback type; TypeConverter.ConvertFromString()
 106 | // is used to convert the value option to an instance of the specified
 107 | // type:
 108 | //
 109 | //  var p = new OptionSet () {
 110 | //    { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) },
 111 | //  };
 112 | //
 113 | // Random other tidbits:
 114 | //  - Boolean options (those w/o '=' or ':' in the option format string)
 115 | //    are explicitly enabled if they are followed with '+', and explicitly
 116 | //    disabled if they are followed with '-':
 117 | //      string a = null;
 118 | //      var p = new OptionSet () {
 119 | //        { "a", s => a = s },
 120 | //      };
 121 | //      p.Parse (new string[]{"-a"});   // sets v != null
 122 | //      p.Parse (new string[]{"-a+"});  // sets v != null
 123 | //      p.Parse (new string[]{"-a-"});  // sets v == null
 124 | //
 125 | 
 126 | using System;
 127 | using System.Collections;
 128 | using System.Collections.Generic;
 129 | using System.Collections.ObjectModel;
 130 | using System.ComponentModel;
 131 | using System.Globalization;
 132 | using System.IO;
 133 | using System.Runtime.Serialization;
 134 | using System.Security.Permissions;
 135 | using System.Text;
 136 | using System.Text.RegularExpressions;
 137 | 
 138 | #if LINQ
 139 | using System.Linq;
 140 | #endif
 141 | 
 142 | #if TEST
 143 | using NDesk.Options;
 144 | #endif
 145 | 
 146 | namespace NDesk.Options {
 147 | 
 148 | 	public class OptionValueCollection : IList, IList<string> {
 149 | 
 150 | 		List<string> values = new List<string> ();
 151 | 		OptionContext c;
 152 | 
 153 | 		internal OptionValueCollection (OptionContext c)
 154 | 		{
 155 | 			this.c = c;
 156 | 		}
 157 | 
 158 | 		#region ICollection
 159 | 		void ICollection.CopyTo (Array array, int index)  {(values as ICollection).CopyTo (array, index);}
 160 | 		bool ICollection.IsSynchronized                   {get {return (values as ICollection).IsSynchronized;}}
 161 | 		object ICollection.SyncRoot                       {get {return (values as ICollection).SyncRoot;}}
 162 | 		#endregion
 163 | 
 164 | 		#region ICollection<T>
 165 | 		public void Add (string item)                       {values.Add (item);}
 166 | 		public void Clear ()                                {values.Clear ();}
 167 | 		public bool Contains (string item)                  {return values.Contains (item);}
 168 | 		public void CopyTo (string[] array, int arrayIndex) {values.CopyTo (array, arrayIndex);}
 169 | 		public bool Remove (string item)                    {return values.Remove (item);}
 170 | 		public int Count                                    {get {return values.Count;}}
 171 | 		public bool IsReadOnly                              {get {return false;}}
 172 | 		#endregion
 173 | 
 174 | 		#region IEnumerable
 175 | 		IEnumerator IEnumerable.GetEnumerator () {return values.GetEnumerator ();}
 176 | 		#endregion
 177 | 
 178 | 		#region IEnumerable<T>
 179 | 		public IEnumerator<string> GetEnumerator () {return values.GetEnumerator ();}
 180 | 		#endregion
 181 | 
 182 | 		#region IList
 183 | 		int IList.Add (object value)                {return (values as IList).Add (value);}
 184 | 		bool IList.Contains (object value)          {return (values as IList).Contains (value);}
 185 | 		int IList.IndexOf (object value)            {return (values as IList).IndexOf (value);}
 186 | 		void IList.Insert (int index, object value) {(values as IList).Insert (index, value);}
 187 | 		void IList.Remove (object value)            {(values as IList).Remove (value);}
 188 | 		void IList.RemoveAt (int index)             {(values as IList).RemoveAt (index);}
 189 | 		bool IList.IsFixedSize                      {get {return false;}}
 190 | 		object IList.this [int index]               {get {return this [index];} set {(values as IList)[index] = value;}}
 191 | 		#endregion
 192 | 
 193 | 		#region IList<T>
 194 | 		public int IndexOf (string item)            {return values.IndexOf (item);}
 195 | 		public void Insert (int index, string item) {values.Insert (index, item);}
 196 | 		public void RemoveAt (int index)            {values.RemoveAt (index);}
 197 | 
 198 | 		private void AssertValid (int index)
 199 | 		{
 200 | 			if (c.Option == null)
 201 | 				throw new InvalidOperationException ("OptionContext.Option is null.");
 202 | 			if (index >= c.Option.MaxValueCount)
 203 | 				throw new ArgumentOutOfRangeException ("index");
 204 | 			if (c.Option.OptionValueType == OptionValueType.Required &&
 205 | 					index >= values.Count)
 206 | 				throw new OptionException (string.Format (
 207 | 							c.OptionSet.MessageLocalizer ("Missing required value for option '{0}'."), c.OptionName), 
 208 | 						c.OptionName);
 209 | 		}
 210 | 
 211 | 		public string this [int index] {
 212 | 			get {
 213 | 				AssertValid (index);
 214 | 				return index >= values.Count ? null : values [index];
 215 | 			}
 216 | 			set {
 217 | 				values [index] = value;
 218 | 			}
 219 | 		}
 220 | 		#endregion
 221 | 
 222 | 		public List<string> ToList ()
 223 | 		{
 224 | 			return new List<string> (values);
 225 | 		}
 226 | 
 227 | 		public string[] ToArray ()
 228 | 		{
 229 | 			return values.ToArray ();
 230 | 		}
 231 | 
 232 | 		public override string ToString ()
 233 | 		{
 234 | 			return string.Join (", ", values.ToArray ());
 235 | 		}
 236 | 	}
 237 | 
 238 | 	public class OptionContext {
 239 | 		private Option                option;
 240 | 		private string                name;
 241 | 		private int                   index;
 242 | 		private OptionSet             set;
 243 | 		private OptionValueCollection c;
 244 | 
 245 | 		public OptionContext (OptionSet set)
 246 | 		{
 247 | 			this.set = set;
 248 | 			this.c   = new OptionValueCollection (this);
 249 | 		}
 250 | 
 251 | 		public Option Option {
 252 | 			get {return option;}
 253 | 			set {option = value;}
 254 | 		}
 255 | 
 256 | 		public string OptionName { 
 257 | 			get {return name;}
 258 | 			set {name = value;}
 259 | 		}
 260 | 
 261 | 		public int OptionIndex {
 262 | 			get {return index;}
 263 | 			set {index = value;}
 264 | 		}
 265 | 
 266 | 		public OptionSet OptionSet {
 267 | 			get {return set;}
 268 | 		}
 269 | 
 270 | 		public OptionValueCollection OptionValues {
 271 | 			get {return c;}
 272 | 		}
 273 | 	}
 274 | 
 275 | 	public enum OptionValueType {
 276 | 		None, 
 277 | 		Optional,
 278 | 		Required,
 279 | 	}
 280 | 
 281 | 	public abstract class Option {
 282 | 		string prototype, description;
 283 | 		string[] names;
 284 | 		OptionValueType type;
 285 | 		int count;
 286 | 		string[] separators;
 287 | 
 288 | 		protected Option (string prototype, string description)
 289 | 			: this (prototype, description, 1)
 290 | 		{
 291 | 		}
 292 | 
 293 | 		protected Option (string prototype, string description, int maxValueCount)
 294 | 		{
 295 | 			if (prototype == null)
 296 | 				throw new ArgumentNullException ("prototype");
 297 | 			if (prototype.Length == 0)
 298 | 				throw new ArgumentException ("Cannot be the empty string.", "prototype");
 299 | 			if (maxValueCount < 0)
 300 | 				throw new ArgumentOutOfRangeException ("maxValueCount");
 301 | 
 302 | 			this.prototype   = prototype;
 303 | 			this.names       = prototype.Split ('|');
 304 | 			this.description = description;
 305 | 			this.count       = maxValueCount;
 306 | 			this.type        = ParsePrototype ();
 307 | 
 308 | 			if (this.count == 0 && type != OptionValueType.None)
 309 | 				throw new ArgumentException (
 310 | 						"Cannot provide maxValueCount of 0 for OptionValueType.Required or " +
 311 | 							"OptionValueType.Optional.",
 312 | 						"maxValueCount");
 313 | 			if (this.type == OptionValueType.None && maxValueCount > 1)
 314 | 				throw new ArgumentException (
 315 | 						string.Format ("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount),
 316 | 						"maxValueCount");
 317 | 			if (Array.IndexOf (names, "<>") >= 0 && 
 318 | 					((names.Length == 1 && this.type != OptionValueType.None) ||
 319 | 					 (names.Length > 1 && this.MaxValueCount > 1)))
 320 | 				throw new ArgumentException (
 321 | 						"The default option handler '<>' cannot require values.",
 322 | 						"prototype");
 323 | 		}
 324 | 
 325 | 		public string           Prototype       {get {return prototype;}}
 326 | 		public string           Description     {get {return description;}}
 327 | 		public OptionValueType  OptionValueType {get {return type;}}
 328 | 		public int              MaxValueCount   {get {return count;}}
 329 | 
 330 | 		public string[] GetNames ()
 331 | 		{
 332 | 			return (string[]) names.Clone ();
 333 | 		}
 334 | 
 335 | 		public string[] GetValueSeparators ()
 336 | 		{
 337 | 			if (separators == null)
 338 | 				return new string [0];
 339 | 			return (string[]) separators.Clone ();
 340 | 		}
 341 | 
 342 | 		protected static T Parse<T> (string value, OptionContext c)
 343 | 		{
 344 | 			TypeConverter conv = TypeDescriptor.GetConverter (typeof (T));
 345 | 			T t = default (T);
 346 | 			try {
 347 | 				if (value != null)
 348 | 					t = (T) conv.ConvertFromString (value);
 349 | 			}
 350 | 			catch (Exception e) {
 351 | 				throw new OptionException (
 352 | 						string.Format (
 353 | 							c.OptionSet.MessageLocalizer ("Could not convert string `{0}' to type {1} for option `{2}'."),
 354 | 							value, typeof (T).Name, c.OptionName),
 355 | 						c.OptionName, e);
 356 | 			}
 357 | 			return t;
 358 | 		}
 359 | 
 360 | 		internal string[] Names           {get {return names;}}
 361 | 		internal string[] ValueSeparators {get {return separators;}}
 362 | 
 363 | 		static readonly char[] NameTerminator = new char[]{'=', ':'};
 364 | 
 365 | 		private OptionValueType ParsePrototype ()
 366 | 		{
 367 | 			char type = '\0';
 368 | 			List<string> seps = new List<string> ();
 369 | 			for (int i = 0; i < names.Length; ++i) {
 370 | 				string name = names [i];
 371 | 				if (name.Length == 0)
 372 | 					throw new ArgumentException ("Empty option names are not supported.", "prototype");
 373 | 
 374 | 				int end = name.IndexOfAny (NameTerminator);
 375 | 				if (end == -1)
 376 | 					continue;
 377 | 				names [i] = name.Substring (0, end);
 378 | 				if (type == '\0' || type == name [end])
 379 | 					type = name [end];
 380 | 				else 
 381 | 					throw new ArgumentException (
 382 | 							string.Format ("Conflicting option types: '{0}' vs. '{1}'.", type, name [end]),
 383 | 							"prototype");
 384 | 				AddSeparators (name, end, seps);
 385 | 			}
 386 | 
 387 | 			if (type == '\0')
 388 | 				return OptionValueType.None;
 389 | 
 390 | 			if (count <= 1 && seps.Count != 0)
 391 | 				throw new ArgumentException (
 392 | 						string.Format ("Cannot provide key/value separators for Options taking {0} value(s).", count),
 393 | 						"prototype");
 394 | 			if (count > 1) {
 395 | 				if (seps.Count == 0)
 396 | 					this.separators = new string[]{":", "="};
 397 | 				else if (seps.Count == 1 && seps [0].Length == 0)
 398 | 					this.separators = null;
 399 | 				else
 400 | 					this.separators = seps.ToArray ();
 401 | 			}
 402 | 
 403 | 			return type == '=' ? OptionValueType.Required : OptionValueType.Optional;
 404 | 		}
 405 | 
 406 | 		private static void AddSeparators (string name, int end, ICollection<string> seps)
 407 | 		{
 408 | 			int start = -1;
 409 | 			for (int i = end+1; i < name.Length; ++i) {
 410 | 				switch (name [i]) {
 411 | 					case '{':
 412 | 						if (start != -1)
 413 | 							throw new ArgumentException (
 414 | 									string.Format ("Ill-formed name/value separator found in \"{0}\".", name),
 415 | 									"prototype");
 416 | 						start = i+1;
 417 | 						break;
 418 | 					case '}':
 419 | 						if (start == -1)
 420 | 							throw new ArgumentException (
 421 | 									string.Format ("Ill-formed name/value separator found in \"{0}\".", name),
 422 | 									"prototype");
 423 | 						seps.Add (name.Substring (start, i-start));
 424 | 						start = -1;
 425 | 						break;
 426 | 					default:
 427 | 						if (start == -1)
 428 | 							seps.Add (name [i].ToString ());
 429 | 						break;
 430 | 				}
 431 | 			}
 432 | 			if (start != -1)
 433 | 				throw new ArgumentException (
 434 | 						string.Format ("Ill-formed name/value separator found in \"{0}\".", name),
 435 | 						"prototype");
 436 | 		}
 437 | 
 438 | 		public void Invoke (OptionContext c)
 439 | 		{
 440 | 			OnParseComplete (c);
 441 | 			c.OptionName  = null;
 442 | 			c.Option      = null;
 443 | 			c.OptionValues.Clear ();
 444 | 		}
 445 | 
 446 | 		protected abstract void OnParseComplete (OptionContext c);
 447 | 
 448 | 		public override string ToString ()
 449 | 		{
 450 | 			return Prototype;
 451 | 		}
 452 | 	}
 453 | 
 454 | 	[Serializable]
 455 | 	public class OptionException : Exception {
 456 | 		private string option;
 457 | 
 458 | 		public OptionException ()
 459 | 		{
 460 | 		}
 461 | 
 462 | 		public OptionException (string message, string optionName)
 463 | 			: base (message)
 464 | 		{
 465 | 			this.option = optionName;
 466 | 		}
 467 | 
 468 | 		public OptionException (string message, string optionName, Exception innerException)
 469 | 			: base (message, innerException)
 470 | 		{
 471 | 			this.option = optionName;
 472 | 		}
 473 | 
 474 | 		protected OptionException (SerializationInfo info, StreamingContext context)
 475 | 			: base (info, context)
 476 | 		{
 477 | 			this.option = info.GetString ("OptionName");
 478 | 		}
 479 | 
 480 | 		public string OptionName {
 481 | 			get {return this.option;}
 482 | 		}
 483 | 
 484 | 		[SecurityPermission (SecurityAction.LinkDemand, SerializationFormatter = true)]
 485 | 		public override void GetObjectData (SerializationInfo info, StreamingContext context)
 486 | 		{
 487 | 			base.GetObjectData (info, context);
 488 | 			info.AddValue ("OptionName", option);
 489 | 		}
 490 | 	}
 491 | 
 492 | 	public delegate void OptionAction<TKey, TValue> (TKey key, TValue value);
 493 | 
 494 | 	public class OptionSet : KeyedCollection<string, Option>
 495 | 	{
 496 | 		public OptionSet ()
 497 | 			: this (delegate (string f) {return f;})
 498 | 		{
 499 | 		}
 500 | 
 501 | 		public OptionSet (Converter<string, string> localizer)
 502 | 		{
 503 | 			this.localizer = localizer;
 504 | 		}
 505 | 
 506 | 		Converter<string, string> localizer;
 507 | 
 508 | 		public Converter<string, string> MessageLocalizer {
 509 | 			get {return localizer;}
 510 | 		}
 511 | 
 512 | 		protected override string GetKeyForItem (Option item)
 513 | 		{
 514 | 			if (item == null)
 515 | 				throw new ArgumentNullException ("option");
 516 | 			if (item.Names != null && item.Names.Length > 0)
 517 | 				return item.Names [0];
 518 | 			// This should never happen, as it's invalid for Option to be
 519 | 			// constructed w/o any names.
 520 | 			throw new InvalidOperationException ("Option has no names!");
 521 | 		}
 522 | 
 523 | 		[Obsolete ("Use KeyedCollection.this[string]")]
 524 | 		protected Option GetOptionForName (string option)
 525 | 		{
 526 | 			if (option == null)
 527 | 				throw new ArgumentNullException ("option");
 528 | 			try {
 529 | 				return base [option];
 530 | 			}
 531 | 			catch (KeyNotFoundException) {
 532 | 				return null;
 533 | 			}
 534 | 		}
 535 | 
 536 | 		protected override void InsertItem (int index, Option item)
 537 | 		{
 538 | 			base.InsertItem (index, item);
 539 | 			AddImpl (item);
 540 | 		}
 541 | 
 542 | 		protected override void RemoveItem (int index)
 543 | 		{
 544 | 			base.RemoveItem (index);
 545 | 			Option p = Items [index];
 546 | 			// KeyedCollection.RemoveItem() handles the 0th item
 547 | 			for (int i = 1; i < p.Names.Length; ++i) {
 548 | 				Dictionary.Remove (p.Names [i]);
 549 | 			}
 550 | 		}
 551 | 
 552 | 		protected override void SetItem (int index, Option item)
 553 | 		{
 554 | 			base.SetItem (index, item);
 555 | 			RemoveItem (index);
 556 | 			AddImpl (item);
 557 | 		}
 558 | 
 559 | 		private void AddImpl (Option option)
 560 | 		{
 561 | 			if (option == null)
 562 | 				throw new ArgumentNullException ("option");
 563 | 			List<string> added = new List<string> (option.Names.Length);
 564 | 			try {
 565 | 				// KeyedCollection.InsertItem/SetItem handle the 0th name.
 566 | 				for (int i = 1; i < option.Names.Length; ++i) {
 567 | 					Dictionary.Add (option.Names [i], option);
 568 | 					added.Add (option.Names [i]);
 569 | 				}
 570 | 			}
 571 | 			catch (Exception) {
 572 | 				foreach (string name in added)
 573 | 					Dictionary.Remove (name);
 574 | 				throw;
 575 | 			}
 576 | 		}
 577 | 
 578 | 		public new OptionSet Add (Option option)
 579 | 		{
 580 | 			base.Add (option);
 581 | 			return this;
 582 | 		}
 583 | 
 584 | 		sealed class ActionOption : Option {
 585 | 			Action<OptionValueCollection> action;
 586 | 
 587 | 			public ActionOption (string prototype, string description, int count, Action<OptionValueCollection> action)
 588 | 				: base (prototype, description, count)
 589 | 			{
 590 | 				if (action == null)
 591 | 					throw new ArgumentNullException ("action");
 592 | 				this.action = action;
 593 | 			}
 594 | 
 595 | 			protected override void OnParseComplete (OptionContext c)
 596 | 			{
 597 | 				action (c.OptionValues);
 598 | 			}
 599 | 		}
 600 | 
 601 | 		public OptionSet Add (string prototype, Action<string> action)
 602 | 		{
 603 | 			return Add (prototype, null, action);
 604 | 		}
 605 | 
 606 | 		public OptionSet Add (string prototype, string description, Action<string> action)
 607 | 		{
 608 | 			if (action == null)
 609 | 				throw new ArgumentNullException ("action");
 610 | 			Option p = new ActionOption (prototype, description, 1, 
 611 | 					delegate (OptionValueCollection v) { action (v [0]); });
 612 | 			base.Add (p);
 613 | 			return this;
 614 | 		}
 615 | 
 616 | 		public OptionSet Add (string prototype, OptionAction<string, string> action)
 617 | 		{
 618 | 			return Add (prototype, null, action);
 619 | 		}
 620 | 
 621 | 		public OptionSet Add (string prototype, string description, OptionAction<string, string> action)
 622 | 		{
 623 | 			if (action == null)
 624 | 				throw new ArgumentNullException ("action");
 625 | 			Option p = new ActionOption (prototype, description, 2, 
 626 | 					delegate (OptionValueCollection v) {action (v [0], v [1]);});
 627 | 			base.Add (p);
 628 | 			return this;
 629 | 		}
 630 | 
 631 | 		sealed class ActionOption<T> : Option {
 632 | 			Action<T> action;
 633 | 
 634 | 			public ActionOption (string prototype, string description, Action<T> action)
 635 | 				: base (prototype, description, 1)
 636 | 			{
 637 | 				if (action == null)
 638 | 					throw new ArgumentNullException ("action");
 639 | 				this.action = action;
 640 | 			}
 641 | 
 642 | 			protected override void OnParseComplete (OptionContext c)
 643 | 			{
 644 | 				action (Parse<T> (c.OptionValues [0], c));
 645 | 			}
 646 | 		}
 647 | 
 648 | 		sealed class ActionOption<TKey, TValue> : Option {
 649 | 			OptionAction<TKey, TValue> action;
 650 | 
 651 | 			public ActionOption (string prototype, string description, OptionAction<TKey, TValue> action)
 652 | 				: base (prototype, description, 2)
 653 | 			{
 654 | 				if (action == null)
 655 | 					throw new ArgumentNullException ("action");
 656 | 				this.action = action;
 657 | 			}
 658 | 
 659 | 			protected override void OnParseComplete (OptionContext c)
 660 | 			{
 661 | 				action (
 662 | 						Parse<TKey> (c.OptionValues [0], c),
 663 | 						Parse<TValue> (c.OptionValues [1], c));
 664 | 			}
 665 | 		}
 666 | 
 667 | 		public OptionSet Add<T> (string prototype, Action<T> action)
 668 | 		{
 669 | 			return Add (prototype, null, action);
 670 | 		}
 671 | 
 672 | 		public OptionSet Add<T> (string prototype, string description, Action<T> action)
 673 | 		{
 674 | 			return Add (new ActionOption<T> (prototype, description, action));
 675 | 		}
 676 | 
 677 | 		public OptionSet Add<TKey, TValue> (string prototype, OptionAction<TKey, TValue> action)
 678 | 		{
 679 | 			return Add (prototype, null, action);
 680 | 		}
 681 | 
 682 | 		public OptionSet Add<TKey, TValue> (string prototype, string description, OptionAction<TKey, TValue> action)
 683 | 		{
 684 | 			return Add (new ActionOption<TKey, TValue> (prototype, description, action));
 685 | 		}
 686 | 
 687 | 		protected virtual OptionContext CreateOptionContext ()
 688 | 		{
 689 | 			return new OptionContext (this);
 690 | 		}
 691 | 
 692 | #if LINQ
 693 | 		public List<string> Parse (IEnumerable<string> arguments)
 694 | 		{
 695 | 			bool process = true;
 696 | 			OptionContext c = CreateOptionContext ();
 697 | 			c.OptionIndex = -1;
 698 | 			var def = GetOptionForName ("<>");
 699 | 			var unprocessed = 
 700 | 				from argument in arguments
 701 | 				where ++c.OptionIndex >= 0 && (process || def != null)
 702 | 					? process
 703 | 						? argument == "--" 
 704 | 							? (process = false)
 705 | 							: !Parse (argument, c)
 706 | 								? def != null 
 707 | 									? Unprocessed (null, def, c, argument) 
 708 | 									: true
 709 | 								: false
 710 | 						: def != null 
 711 | 							? Unprocessed (null, def, c, argument)
 712 | 							: true
 713 | 					: true
 714 | 				select argument;
 715 | 			List<string> r = unprocessed.ToList ();
 716 | 			if (c.Option != null)
 717 | 				c.Option.Invoke (c);
 718 | 			return r;
 719 | 		}
 720 | #else
 721 | 		public List<string> Parse (IEnumerable<string> arguments)
 722 | 		{
 723 | 			OptionContext c = CreateOptionContext ();
 724 | 			c.OptionIndex = -1;
 725 | 			bool process = true;
 726 | 			List<string> unprocessed = new List<string> ();
 727 | 			Option def = Contains ("<>") ? this ["<>"] : null;
 728 | 			foreach (string argument in arguments) {
 729 | 				++c.OptionIndex;
 730 | 				if (argument == "--") {
 731 | 					process = false;
 732 | 					continue;
 733 | 				}
 734 | 				if (!process) {
 735 | 					Unprocessed (unprocessed, def, c, argument);
 736 | 					continue;
 737 | 				}
 738 | 				if (!Parse (argument, c))
 739 | 					Unprocessed (unprocessed, def, c, argument);
 740 | 			}
 741 | 			if (c.Option != null)
 742 | 				c.Option.Invoke (c);
 743 | 			return unprocessed;
 744 | 		}
 745 | #endif
 746 | 
 747 | 		private static bool Unprocessed (ICollection<string> extra, Option def, OptionContext c, string argument)
 748 | 		{
 749 | 			if (def == null) {
 750 | 				extra.Add (argument);
 751 | 				return false;
 752 | 			}
 753 | 			c.OptionValues.Add (argument);
 754 | 			c.Option = def;
 755 | 			c.Option.Invoke (c);
 756 | 			return false;
 757 | 		}
 758 | 
 759 | 		private readonly Regex ValueOption = new Regex (
 760 | 			@"^(?<flag>--|-|/)(?<name>[^:=]+)((?<sep>[:=])(?<value>.*))?$");
 761 | 
 762 | 		protected bool GetOptionParts (string argument, out string flag, out string name, out string sep, out string value)
 763 | 		{
 764 | 			if (argument == null)
 765 | 				throw new ArgumentNullException ("argument");
 766 | 
 767 | 			flag = name = sep = value = null;
 768 | 			Match m = ValueOption.Match (argument);
 769 | 			if (!m.Success) {
 770 | 				return false;
 771 | 			}
 772 | 			flag  = m.Groups ["flag"].Value;
 773 | 			name  = m.Groups ["name"].Value;
 774 | 			if (m.Groups ["sep"].Success && m.Groups ["value"].Success) {
 775 | 				sep   = m.Groups ["sep"].Value;
 776 | 				value = m.Groups ["value"].Value;
 777 | 			}
 778 | 			return true;
 779 | 		}
 780 | 
 781 | 		protected virtual bool Parse (string argument, OptionContext c)
 782 | 		{
 783 | 			if (c.Option != null) {
 784 | 				ParseValue (argument, c);
 785 | 				return true;
 786 | 			}
 787 | 
 788 | 			string f, n, s, v;
 789 | 			if (!GetOptionParts (argument, out f, out n, out s, out v))
 790 | 				return false;
 791 | 
 792 | 			Option p;
 793 | 			if (Contains (n)) {
 794 | 				p = this [n];
 795 | 				c.OptionName = f + n;
 796 | 				c.Option     = p;
 797 | 				switch (p.OptionValueType) {
 798 | 					case OptionValueType.None:
 799 | 						c.OptionValues.Add (n);
 800 | 						c.Option.Invoke (c);
 801 | 						break;
 802 | 					case OptionValueType.Optional:
 803 | 					case OptionValueType.Required: 
 804 | 						ParseValue (v, c);
 805 | 						break;
 806 | 				}
 807 | 				return true;
 808 | 			}
 809 | 			// no match; is it a bool option?
 810 | 			if (ParseBool (argument, n, c))
 811 | 				return true;
 812 | 			// is it a bundled option?
 813 | 			if (ParseBundledValue (f, string.Concat (n + s + v), c))
 814 | 				return true;
 815 | 
 816 | 			return false;
 817 | 		}
 818 | 
 819 | 		private void ParseValue (string option, OptionContext c)
 820 | 		{
 821 | 			if (option != null)
 822 | 				foreach (string o in c.Option.ValueSeparators != null 
 823 | 						? option.Split (c.Option.ValueSeparators, StringSplitOptions.None)
 824 | 						: new string[]{option}) {
 825 | 					c.OptionValues.Add (o);
 826 | 				}
 827 | 			if (c.OptionValues.Count == c.Option.MaxValueCount || 
 828 | 					c.Option.OptionValueType == OptionValueType.Optional)
 829 | 				c.Option.Invoke (c);
 830 | 			else if (c.OptionValues.Count > c.Option.MaxValueCount) {
 831 | 				throw new OptionException (localizer (string.Format (
 832 | 								"Error: Found {0} option values when expecting {1}.", 
 833 | 								c.OptionValues.Count, c.Option.MaxValueCount)),
 834 | 						c.OptionName);
 835 | 			}
 836 | 		}
 837 | 
 838 | 		private bool ParseBool (string option, string n, OptionContext c)
 839 | 		{
 840 | 			Option p;
 841 | 			string rn;
 842 | 			if (n.Length >= 1 && (n [n.Length-1] == '+' || n [n.Length-1] == '-') &&
 843 | 					Contains ((rn = n.Substring (0, n.Length-1)))) {
 844 | 				p = this [rn];
 845 | 				string v = n [n.Length-1] == '+' ? option : null;
 846 | 				c.OptionName  = option;
 847 | 				c.Option      = p;
 848 | 				c.OptionValues.Add (v);
 849 | 				p.Invoke (c);
 850 | 				return true;
 851 | 			}
 852 | 			return false;
 853 | 		}
 854 | 
 855 | 		private bool ParseBundledValue (string f, string n, OptionContext c)
 856 | 		{
 857 | 			if (f != "-")
 858 | 				return false;
 859 | 			for (int i = 0; i < n.Length; ++i) {
 860 | 				Option p;
 861 | 				string opt = f + n [i].ToString ();
 862 | 				string rn = n [i].ToString ();
 863 | 				if (!Contains (rn)) {
 864 | 					if (i == 0)
 865 | 						return false;
 866 | 					throw new OptionException (string.Format (localizer (
 867 | 									"Cannot bundle unregistered option '{0}'."), opt), opt);
 868 | 				}
 869 | 				p = this [rn];
 870 | 				switch (p.OptionValueType) {
 871 | 					case OptionValueType.None:
 872 | 						Invoke (c, opt, n, p);
 873 | 						break;
 874 | 					case OptionValueType.Optional:
 875 | 					case OptionValueType.Required: {
 876 | 						string v     = n.Substring (i+1);
 877 | 						c.Option     = p;
 878 | 						c.OptionName = opt;
 879 | 						ParseValue (v.Length != 0 ? v : null, c);
 880 | 						return true;
 881 | 					}
 882 | 					default:
 883 | 						throw new InvalidOperationException ("Unknown OptionValueType: " + p.OptionValueType);
 884 | 				}
 885 | 			}
 886 | 			return true;
 887 | 		}
 888 | 
 889 | 		private static void Invoke (OptionContext c, string name, string value, Option option)
 890 | 		{
 891 | 			c.OptionName  = name;
 892 | 			c.Option      = option;
 893 | 			c.OptionValues.Add (value);
 894 | 			option.Invoke (c);
 895 | 		}
 896 | 
 897 | 		private const int OptionWidth = 29;
 898 | 
 899 | 		public void WriteOptionDescriptions (TextWriter o)
 900 | 		{
 901 | 			foreach (Option p in this) {
 902 | 				int written = 0;
 903 | 				if (!WriteOptionPrototype (o, p, ref written))
 904 | 					continue;
 905 | 
 906 | 				if (written < OptionWidth)
 907 | 					o.Write (new string (' ', OptionWidth - written));
 908 | 				else {
 909 | 					o.WriteLine ();
 910 | 					o.Write (new string (' ', OptionWidth));
 911 | 				}
 912 | 
 913 | 				List<string> lines = GetLines (localizer (GetDescription (p.Description)));
 914 | 				o.WriteLine (lines [0]);
 915 | 				string prefix = new string (' ', OptionWidth+2);
 916 | 				for (int i = 1; i < lines.Count; ++i) {
 917 | 					o.Write (prefix);
 918 | 					o.WriteLine (lines [i]);
 919 | 				}
 920 | 			}
 921 | 		}
 922 | 
 923 | 		bool WriteOptionPrototype (TextWriter o, Option p, ref int written)
 924 | 		{
 925 | 			string[] names = p.Names;
 926 | 
 927 | 			int i = GetNextOptionIndex (names, 0);
 928 | 			if (i == names.Length)
 929 | 				return false;
 930 | 
 931 | 			if (names [i].Length == 1) {
 932 | 				Write (o, ref written, "  -");
 933 | 				Write (o, ref written, names [0]);
 934 | 			}
 935 | 			else {
 936 | 				Write (o, ref written, "      --");
 937 | 				Write (o, ref written, names [0]);
 938 | 			}
 939 | 
 940 | 			for ( i = GetNextOptionIndex (names, i+1); 
 941 | 					i < names.Length; i = GetNextOptionIndex (names, i+1)) {
 942 | 				Write (o, ref written, ", ");
 943 | 				Write (o, ref written, names [i].Length == 1 ? "-" : "--");
 944 | 				Write (o, ref written, names [i]);
 945 | 			}
 946 | 
 947 | 			if (p.OptionValueType == OptionValueType.Optional ||
 948 | 					p.OptionValueType == OptionValueType.Required) {
 949 | 				if (p.OptionValueType == OptionValueType.Optional) {
 950 | 					Write (o, ref written, localizer ("["));
 951 | 				}
 952 | 				Write (o, ref written, localizer ("=" + GetArgumentName (0, p.MaxValueCount, p.Description)));
 953 | 				string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 
 954 | 					? p.ValueSeparators [0]
 955 | 					: " ";
 956 | 				for (int c = 1; c < p.MaxValueCount; ++c) {
 957 | 					Write (o, ref written, localizer (sep + GetArgumentName (c, p.MaxValueCount, p.Description)));
 958 | 				}
 959 | 				if (p.OptionValueType == OptionValueType.Optional) {
 960 | 					Write (o, ref written, localizer ("]"));
 961 | 				}
 962 | 			}
 963 | 			return true;
 964 | 		}
 965 | 
 966 | 		static int GetNextOptionIndex (string[] names, int i)
 967 | 		{
 968 | 			while (i < names.Length && names [i] == "<>") {
 969 | 				++i;
 970 | 			}
 971 | 			return i;
 972 | 		}
 973 | 
 974 | 		static void Write (TextWriter o, ref int n, string s)
 975 | 		{
 976 | 			n += s.Length;
 977 | 			o.Write (s);
 978 | 		}
 979 | 
 980 | 		private static string GetArgumentName (int index, int maxIndex, string description)
 981 | 		{
 982 | 			if (description == null)
 983 | 				return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
 984 | 			string[] nameStart;
 985 | 			if (maxIndex == 1)
 986 | 				nameStart = new string[]{"{0:", "{"};
 987 | 			else
 988 | 				nameStart = new string[]{"{" + index + ":"};
 989 | 			for (int i = 0; i < nameStart.Length; ++i) {
 990 | 				int start, j = 0;
 991 | 				do {
 992 | 					start = description.IndexOf (nameStart [i], j);
 993 | 				} while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false);
 994 | 				if (start == -1)
 995 | 					continue;
 996 | 				int end = description.IndexOf ("}", start);
 997 | 				if (end == -1)
 998 | 					continue;
 999 | 				return description.Substring (start + nameStart [i].Length, end - start - nameStart [i].Length);
1000 | 			}
1001 | 			return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
1002 | 		}
1003 | 
1004 | 		private static string GetDescription (string description)
1005 | 		{
1006 | 			if (description == null)
1007 | 				return string.Empty;
1008 | 			StringBuilder sb = new StringBuilder (description.Length);
1009 | 			int start = -1;
1010 | 			for (int i = 0; i < description.Length; ++i) {
1011 | 				switch (description [i]) {
1012 | 					case '{':
1013 | 						if (i == start) {
1014 | 							sb.Append ('{');
1015 | 							start = -1;
1016 | 						}
1017 | 						else if (start < 0)
1018 | 							start = i + 1;
1019 | 						break;
1020 | 					case '}':
1021 | 						if (start < 0) {
1022 | 							if ((i+1) == description.Length || description [i+1] != '}')
1023 | 								throw new InvalidOperationException ("Invalid option description: " + description);
1024 | 							++i;
1025 | 							sb.Append ("}");
1026 | 						}
1027 | 						else {
1028 | 							sb.Append (description.Substring (start, i - start));
1029 | 							start = -1;
1030 | 						}
1031 | 						break;
1032 | 					case ':':
1033 | 						if (start < 0)
1034 | 							goto default;
1035 | 						start = i + 1;
1036 | 						break;
1037 | 					default:
1038 | 						if (start < 0)
1039 | 							sb.Append (description [i]);
1040 | 						break;
1041 | 				}
1042 | 			}
1043 | 			return sb.ToString ();
1044 | 		}
1045 | 
1046 | 		private static List<string> GetLines (string description)
1047 | 		{
1048 | 			List<string> lines = new List<string> ();
1049 | 			if (string.IsNullOrEmpty (description)) {
1050 | 				lines.Add (string.Empty);
1051 | 				return lines;
1052 | 			}
1053 | 			int length = 80 - OptionWidth - 2;
1054 | 			int start = 0, end;
1055 | 			do {
1056 | 				end = GetLineEnd (start, length, description);
1057 | 				bool cont = false;
1058 | 				if (end < description.Length) {
1059 | 					char c = description [end];
1060 | 					if (c == '-' || (char.IsWhiteSpace (c) && c != '\n'))
1061 | 						++end;
1062 | 					else if (c != '\n') {
1063 | 						cont = true;
1064 | 						--end;
1065 | 					}
1066 | 				}
1067 | 				lines.Add (description.Substring (start, end - start));
1068 | 				if (cont) {
1069 | 					lines [lines.Count-1] += "-";
1070 | 				}
1071 | 				start = end;
1072 | 				if (start < description.Length && description [start] == '\n')
1073 | 					++start;
1074 | 			} while (end < description.Length);
1075 | 			return lines;
1076 | 		}
1077 | 
1078 | 		private static int GetLineEnd (int start, int length, string description)
1079 | 		{
1080 | 			int end = Math.Min (start + length, description.Length);
1081 | 			int sep = -1;
1082 | 			for (int i = start; i < end; ++i) {
1083 | 				switch (description [i]) {
1084 | 					case ' ':
1085 | 					case '\t':
1086 | 					case '\v':
1087 | 					case '-':
1088 | 					case ',':
1089 | 					case '.':
1090 | 					case ';':
1091 | 						sep = i;
1092 | 						break;
1093 | 					case '\n':
1094 | 						return i;
1095 | 				}
1096 | 			}
1097 | 			if (sep == -1 || end == description.Length)
1098 | 				return end;
1099 | 			return sep;
1100 | 		}
1101 | 	}
1102 | }
1103 | 
1104 | 


--------------------------------------------------------------------------------