Update version

Allow dashes to appear in parameter values
Revert help text changes in the command section
2025-10-25 15:19:17 +00:00 · 2020-12-06 18:42:58 +02:00 · 2020-12-06 18:39:03 +02:00 · 2020-12-06 18:24:30 +02:00 · 2020-12-06 17:58:02 +02:00 · 2020-11-29 17:14:23 +02:00
112 changed files with 4996 additions and 3547 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,63 +0,0 @@
-###############################################################################
-# Set default behavior to automatically normalize line endings.
-###############################################################################
-* text=auto
-
-###############################################################################
-# Set default behavior for command prompt diff.
-#
-# This is need for earlier builds of msysgit that does not have it on by
-# default for csharp files.
-# Note: This is only used by command line
-###############################################################################
-#*.cs     diff=csharp
-
-###############################################################################
-# Set the merge driver for project and solution files
-#
-# Merging from the command prompt will add diff markers to the files if there
-# are conflicts (Merging from VS is not affected by the settings below, in VS
-# the diff markers are never inserted). Diff markers may cause the following 
-# file extensions to fail to load in VS. An alternative would be to treat
-# these files as binary and thus will always conflict and require user
-# intervention with every merge. To do so, just uncomment the entries below
-###############################################################################
-#*.sln       merge=binary
-#*.csproj    merge=binary
-#*.vbproj    merge=binary
-#*.vcxproj   merge=binary
-#*.vcproj    merge=binary
-#*.dbproj    merge=binary
-#*.fsproj    merge=binary
-#*.lsproj    merge=binary
-#*.wixproj   merge=binary
-#*.modelproj merge=binary
-#*.sqlproj   merge=binary
-#*.wwaproj   merge=binary
-
-###############################################################################
-# behavior for image files
-#
-# image files are treated as binary by default.
-###############################################################################
-#*.jpg   binary
-#*.png   binary
-#*.gif   binary
-
-###############################################################################
-# diff behavior for common document formats
-# 
-# Convert binary document formats to text before diffing them. This feature
-# is only available from the command line. Turn it on by uncommenting the 
-# entries below.
-###############################################################################
-#*.doc   diff=astextplain
-#*.DOC   diff=astextplain
-#*.docx  diff=astextplain
-#*.DOCX  diff=astextplain
-#*.dot   diff=astextplain
-#*.DOT   diff=astextplain
-#*.pdf   diff=astextplain
-#*.PDF   diff=astextplain
-#*.rtf   diff=astextplain
-#*.RTF   diff=astextplain
--- a/.github/workflows/CD.yml
+++ b/.github/workflows/CD.yml
@@ -3,23 +3,23 @@ name: CD
 on:
  push:
    tags:
-    - '*'
+      - "*"

 jobs:
  build:
    runs-on: ubuntu-latest

    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2.3.3

-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1.4.0
-      with:
-        dotnet-version: 3.1.100
+      - name: Install .NET
+        uses: actions/setup-dotnet@v1.7.2
+        with:
+          dotnet-version: 5.0.100

-    - name: Pack
-      run: dotnet pack CliFx --configuration Release
+      - name: Pack
+        run: dotnet pack CliFx --configuration Release

-    - name: Deploy
-      run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}
+      - name: Deploy
+        run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -11,25 +11,18 @@ jobs:
        os: [ubuntu-latest, windows-latest, macos-latest]

    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
+      - name: Checkout
+        uses: actions/checkout@v2.3.3

-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1.4.0
-      with:
-        dotnet-version: 3.1.100
+      - name: Install .NET
+        uses: actions/setup-dotnet@v1.7.2
+        with:
+          dotnet-version: 5.0.100

-    - name: Build & test
-      run: dotnet test --configuration Release --logger GitHubActions
+      - name: Build & test
+        run: dotnet test --configuration Release --logger GitHubActions

-    - name: Upload coverage
-      uses: codecov/codecov-action@v1.0.5
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        file: CliFx.Tests/bin/Release/Coverage.xml
-
-    - name: Upload coverage (analyzers)
-      uses: codecov/codecov-action@v1.0.5
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        file: CliFx.Analyzers.Tests/bin/Release/Coverage.xml
+      - name: Upload coverage
+        uses: codecov/codecov-action@v1.0.5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,341 +1,21 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
 # User-specific files
-*.rsuser
 *.suo
 *.user
 *.userosscache
 *.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
+.idea/

 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
 [Rr]elease/
 [Rr]eleases/
-x64/
-x86/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
+[Xx]64/
+[Xx]86/
+[Bb]uild/
 bld/
 [Bb]in/
 [Oo]bj/
-[Ll]og/

-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUNIT
-*.VisualState.xml
-TestResult.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# JustCode is a .NET coding add-in
-.JustCode
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-.ncrunchsolution
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- Backup*.rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# JetBrains Rider
-.idea/
-*.sln.iml
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
+# Coverage
+*.opencover.xml
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,25 @@
+### v1.6 (06-Dec-2020)
+
+- Added support for custom value validators. You can now create a type that inherits from `CliFx.ArgumentValueValidator<T>` to implement reusable validation logic for command arguments. To use a validator, include it in the `Validators` property on the `CommandOption` or `CommandParameter` attribute. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
+- Added `CliFx.ArgumentValueConverter<T>` class that you can inherit from to implement custom value converters. `CliFx.IArgumentValueConverter` interface is still available, but it is recommended to inherit from the generic class instead, due to the type safety it provides. The interface may become internal or get removed in one of the future major versions.
+- Updated requirements for option names and short names: short names now must be letter characters (lowercase or uppercase), while names must now start with a letter character. This means option names can no longer start with a digit or a special character. This change makes it possible to pass negative number values without the need to quote them, i.e. `--my-number -5`.
+
+### v1.5 (23-Oct-2020)
+
+- Added pretty-printing for unhandled exceptions thrown from within the application. This makes the errors easier to parse visually and should help in troubleshooting. This change does not affect `CommandException`, as it already has special treatment. (Thanks [@Mårten Åsberg](https://github.com/89netraM))
+- Added support for custom value converters. You can now create a type that implements `CliFx.IArgumentValueConverter` and specify it as a converter for your parameters or options via the `Converter` named property. This should enable conversion between raw argument values and custom types which are not string-initializable. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
+- Improved help text so that it also shows minimal usage examples for child and descendant commands, besides the actual command it was requested on. This should improve user experience for applications with many nested commands. (Thanks [@Nikiforov Alexey](https://github.com/NikiforovAll))
+
+### v1.4 (20-Aug-2020)
+
+- Added `VirtualConsole.CreateBuffered()` method to simplify test setup when using in-memory backing stores for output and error streams. Please refer to the readme for updated recommendations on how to test applications built with CliFx.
+- Added generic `CliApplicationBuilder.AddCommand<TCommand>()`. This overload simplifies adding commands one-by-one as it also checks that the type implements `ICommand`.
+
+### v1.3.2 (31-Jul-2020)
+
+- Fixed an issue where a command was incorrectly allowed to execute when the user did not specify any value for a non-scalar parameter. Since they are always required, a parameter needs to be bound to (at least) one value. (Thanks [@Daniel Hix](https://github.com/ADustyOldMuffin))
+- Fixed an issue where `CliApplication.RunAsync(...)` threw `ArgumentException` if there were two environment variables, whose names differed only in case. Environment variable names are now treated case-sensitively. (Thanks [@Ron Myers](https://github.com/ron-myers))
+
 ### v1.3.1 (19-Jul-2020)

 - Running the application with the debug directive (`myapp [debug]`) will now also try to launch a debugger instance. In most cases it will save time as you won't need to attach the debugger manually. (Thanks [@Volodymyr Shkolka](https://github.com/BlackGad))
--- a/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
+++ b/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
@@ -2,23 +2,22 @@
  <Import Project="../CliFx.props" />

  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <CollectCoverage>true</CollectCoverage>
    <CoverletOutputFormat>opencover</CoverletOutputFormat>
-    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Gu.Roslyn.Asserts" Version="3.3.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.0.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="Gu.Roslyn.Asserts" Version="3.3.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.1.2" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.4.0" />
-    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.msbuild" Version="2.9.0" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup>
--- a/CliFx.Analyzers.Tests/CommandSchemaAnalyzerTests.cs
+++ b/CliFx.Analyzers.Tests/CommandSchemaAnalyzerTests.cs
@@ -140,6 +140,54 @@ public class MyCommand : ICommand
    [CommandParameter(2)]
    public IReadOnlyList<string> ParamB { get; set; }

+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameter with valid converter",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public class MyConverter : ArgumentValueConverter<string>
+{
+    public string ConvertFrom(string value) => value;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Param { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameter with valid validator",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public class MyValidator : ArgumentValueValidator<string>
+{
+    public ValidationResult Validate(string value) => ValidationResult.Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Param { get; set; }
+    
    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
                )
@@ -157,7 +205,7 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption(""foo"")]
-    public string Param { get; set; }
+    public string Option { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -176,7 +224,7 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption(""foo"", 'f')]
-    public string Param { get; set; }
+    public string Option { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -195,10 +243,10 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption(""foo"")]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption(""bar"")]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -217,10 +265,10 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption('f')]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption('x')]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -239,10 +287,58 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption('a', EnvironmentVariableName = ""env_var_a"")]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption('b', EnvironmentVariableName = ""env_var_b"")]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with valid converter",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public class MyConverter : ArgumentValueConverter<string>
+{
+    public string ConvertFrom(string value) => value;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('o', Converter = typeof(MyConverter))]
+    public string Option { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with valid validator",
+                    Analyzer.SupportedDiagnostics,
+
+                    // language=cs
+                    @"
+public class MyValidator : ArgumentValueValidator<string>
+{
+    public ValidationResult Validate(string value) => ValidationResult.Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('o', Validators = new[] {typeof(MyValidator)})]
+    public string Option { get; set; }
    
    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -366,6 +462,54 @@ public class MyCommand : ICommand
    [CommandParameter(2)]
    public string ParamB { get; set; }

+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameter with invalid converter",
+                    DiagnosticDescriptors.CliFx0025,
+
+                    // language=cs
+                    @"
+public class MyConverter
+{
+    public object ConvertFrom(string value) => value;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Param { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Parameter with invalid validator",
+                    DiagnosticDescriptors.CliFx0026,
+
+                    // language=cs
+                    @"
+public class MyValidator
+{
+    public ValidationResult Validate(string value) => ValidationResult.Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Param { get; set; }
+    
    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
                )
@@ -383,7 +527,7 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption("""")]
-    public string Param { get; set; }
+    public string Option { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -402,7 +546,7 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption(""a"")]
-    public string Param { get; set; }
+    public string Option { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -421,10 +565,10 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption(""foo"")]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption(""foo"")]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -443,10 +587,10 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption('f')]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption('f')]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
@@ -465,10 +609,96 @@ public class MyCommand : ICommand
 public class MyCommand : ICommand
 {
    [CommandOption('a', EnvironmentVariableName = ""env_var"")]
-    public string ParamA { get; set; }
+    public string OptionA { get; set; }
    
    [CommandOption('b', EnvironmentVariableName = ""env_var"")]
-    public string ParamB { get; set; }
+    public string OptionB { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with invalid converter",
+                    DiagnosticDescriptors.CliFx0046,
+
+                    // language=cs
+                    @"
+public class MyConverter
+{
+    public object ConvertFrom(string value) => value;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('o', Converter = typeof(MyConverter))]
+    public string Option { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with invalid validator",
+                    DiagnosticDescriptors.CliFx0047,
+
+                    // language=cs
+                    @"
+public class MyValidator
+{
+    public ValidationResult Validate(string value) => ValidationResult.Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('o', Validators = new[] {typeof(MyValidator)})]
+    public string Option { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with a name that doesn't start with a letter character",
+                    DiagnosticDescriptors.CliFx0048,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""0foo"")]
+    public string Option { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}"
+                )
+            };
+
+            yield return new object[]
+            {
+                new AnalyzerTestCase(
+                    "Option with a short name that isn't a letter character",
+                    DiagnosticDescriptors.CliFx0049,
+
+                    // language=cs
+                    @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('0')]
+    public string Option { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }"
--- a/CliFx.Analyzers/CommandSchemaAnalyzer.cs
+++ b/CliFx.Analyzers/CommandSchemaAnalyzer.cs
@@ -7,6 +7,7 @@ using Microsoft.CodeAnalysis.Diagnostics;

 namespace CliFx.Analyzers
 {
+    // TODO: split into multiple analyzers
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class CommandSchemaAnalyzer : DiagnosticAnalyzer
    {
@@ -17,16 +18,23 @@ namespace CliFx.Analyzers
            DiagnosticDescriptors.CliFx0022,
            DiagnosticDescriptors.CliFx0023,
            DiagnosticDescriptors.CliFx0024,
+            DiagnosticDescriptors.CliFx0025,
+            DiagnosticDescriptors.CliFx0026,
            DiagnosticDescriptors.CliFx0041,
            DiagnosticDescriptors.CliFx0042,
            DiagnosticDescriptors.CliFx0043,
            DiagnosticDescriptors.CliFx0044,
-            DiagnosticDescriptors.CliFx0045
+            DiagnosticDescriptors.CliFx0045,
+            DiagnosticDescriptors.CliFx0046,
+            DiagnosticDescriptors.CliFx0047,
+            DiagnosticDescriptors.CliFx0048,
+            DiagnosticDescriptors.CliFx0049
        );

        private static bool IsScalarType(ITypeSymbol typeSymbol) =>
            KnownSymbols.IsSystemString(typeSymbol) ||
-            !typeSymbol.AllInterfaces.Select(i => i.ConstructedFrom).Any(KnownSymbols.IsSystemCollectionsGenericIEnumerable);
+            !typeSymbol.AllInterfaces.Select(i => i.ConstructedFrom)
+                .Any(KnownSymbols.IsSystemCollectionsGenericIEnumerable);

        private static void CheckCommandParameterProperties(
            SymbolAnalysisContext context,
@@ -50,11 +58,28 @@ namespace CliFx.Analyzers
                        .Select(a => a.Value.Value)
                        .FirstOrDefault() as string;

+                    var converter = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "Converter")
+                        .Select(a => a.Value.Value)
+                        .Cast<ITypeSymbol?>()
+                        .FirstOrDefault();
+
+                    var validators = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "Validators")
+                        .SelectMany(a => a.Value.Values)
+                        .Select(c => c.Value)
+                        .Cast<ITypeSymbol>()
+                        .ToArray();
+
                    return new
                    {
                        Property = p,
                        Order = order,
-                        Name = name
+                        Name = name,
+                        Converter = converter,
+                        Validators = validators
                    };
                })
                .ToArray();
@@ -69,8 +94,9 @@ namespace CliFx.Analyzers

            foreach (var parameter in duplicateOrderParameters)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0021, parameter.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0021, parameter.Property.Locations.First()
+                ));
            }

            // Duplicate name
@@ -83,8 +109,9 @@ namespace CliFx.Analyzers

            foreach (var parameter in duplicateNameParameters)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0022, parameter.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0022, parameter.Property.Locations.First()
+                ));
            }

            // Multiple non-scalar
@@ -96,8 +123,9 @@ namespace CliFx.Analyzers
            {
                foreach (var parameter in nonScalarParameters)
                {
-                    context.ReportDiagnostic(
-                        Diagnostic.Create(DiagnosticDescriptors.CliFx0023, parameter.Property.Locations.First()));
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        DiagnosticDescriptors.CliFx0023, parameter.Property.Locations.First()
+                    ));
                }
            }

@@ -109,8 +137,35 @@ namespace CliFx.Analyzers

            if (nonLastNonScalarParameter != null)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0024, nonLastNonScalarParameter.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0024, nonLastNonScalarParameter.Property.Locations.First()
+                ));
+            }
+
+            // Invalid converter
+            var invalidConverterParameters = parameters
+                .Where(p =>
+                    p.Converter != null &&
+                    !p.Converter.AllInterfaces.Any(KnownSymbols.IsArgumentValueConverterInterface))
+                .ToArray();
+
+            foreach (var parameter in invalidConverterParameters)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0025, parameter.Property.Locations.First()
+                ));
+            }
+
+            // Invalid validators
+            var invalidValidatorsParameters = parameters
+                .Where(p => !p.Validators.All(v => v.AllInterfaces.Any(KnownSymbols.IsArgumentValueValidatorInterface)))
+                .ToArray();
+
+            foreach (var parameter in invalidValidatorsParameters)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0026, parameter.Property.Locations.First()
+                ));
            }
        }

@@ -143,12 +198,29 @@ namespace CliFx.Analyzers
                        .Select(a => a.Value.Value)
                        .FirstOrDefault() as string;

+                    var converter = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "Converter")
+                        .Select(a => a.Value.Value)
+                        .Cast<ITypeSymbol>()
+                        .FirstOrDefault();
+
+                    var validators = attribute
+                        .NamedArguments
+                        .Where(a => a.Key == "Validators")
+                        .SelectMany(a => a.Value.Values)
+                        .Select(c => c.Value)
+                        .Cast<ITypeSymbol>()
+                        .ToArray();
+
                    return new
                    {
                        Property = p,
                        Name = name,
                        ShortName = shortName,
-                        EnvironmentVariableName = envVarName
+                        EnvironmentVariableName = envVarName,
+                        Converter = converter,
+                        Validators = validators
                    };
                })
                .ToArray();
@@ -160,8 +232,9 @@ namespace CliFx.Analyzers

            foreach (var option in noNameOptions)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0041, option.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0041, option.Property.Locations.First()
+                ));
            }

            // Too short name
@@ -171,8 +244,9 @@ namespace CliFx.Analyzers

            foreach (var option in invalidNameLengthOptions)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0042, option.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0042, option.Property.Locations.First()
+                ));
            }

            // Duplicate name
@@ -185,8 +259,9 @@ namespace CliFx.Analyzers

            foreach (var option in duplicateNameOptions)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0043, option.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0043, option.Property.Locations.First()
+                ));
            }

            // Duplicate name
@@ -199,33 +274,82 @@ namespace CliFx.Analyzers

            foreach (var option in duplicateShortNameOptions)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0044, option.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0044, option.Property.Locations.First()
+                ));
            }

            // Duplicate environment variable name
            var duplicateEnvironmentVariableNameOptions = options
                .Where(p => !string.IsNullOrWhiteSpace(p.EnvironmentVariableName))
-                .GroupBy(p => p.EnvironmentVariableName, StringComparer.OrdinalIgnoreCase)
+                .GroupBy(p => p.EnvironmentVariableName, StringComparer.Ordinal)
                .Where(g => g.Count() > 1)
                .SelectMany(g => g.AsEnumerable())
                .ToArray();

            foreach (var option in duplicateEnvironmentVariableNameOptions)
            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0045, option.Property.Locations.First()));
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0045, option.Property.Locations.First()
+                ));
+            }
+
+            // Invalid converter
+            var invalidConverterOptions = options
+                .Where(o =>
+                    o.Converter != null &&
+                    !o.Converter.AllInterfaces.Any(KnownSymbols.IsArgumentValueConverterInterface))
+                .ToArray();
+
+            foreach (var option in invalidConverterOptions)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0046, option.Property.Locations.First()
+                ));
+            }
+
+            // Invalid validators
+            var invalidValidatorsOptions = options
+                .Where(o => !o.Validators.All(v => v.AllInterfaces.Any(KnownSymbols.IsArgumentValueValidatorInterface)))
+                .ToArray();
+
+            foreach (var option in invalidValidatorsOptions)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0047, option.Property.Locations.First()
+                ));
+            }
+
+            // Non-letter first character in name
+            var nonLetterFirstCharacterInNameOptions = options
+                .Where(o => !string.IsNullOrWhiteSpace(o.Name) && !char.IsLetter(o.Name[0]))
+                .ToArray();
+
+            foreach (var option in nonLetterFirstCharacterInNameOptions)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0048, option.Property.Locations.First()
+                ));
+            }
+
+            // Non-letter short name
+            var nonLetterShortNameOptions = options
+                .Where(o => o.ShortName != null && !char.IsLetter(o.ShortName.Value))
+                .ToArray();
+
+            foreach (var option in nonLetterShortNameOptions)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    DiagnosticDescriptors.CliFx0049, option.Property.Locations.First()
+                ));
            }
        }

        private static void CheckCommandType(SymbolAnalysisContext context)
        {
            // Named type: MyCommand
-            if (!(context.Symbol is INamedTypeSymbol namedTypeSymbol))
-                return;
-
-            // Only classes
-            if (namedTypeSymbol.TypeKind != TypeKind.Class)
+            if (!(context.Symbol is INamedTypeSymbol namedTypeSymbol) ||
+                namedTypeSymbol.TypeKind != TypeKind.Class)
                return;

            // Implements ICommand?
@@ -252,10 +376,12 @@ namespace CliFx.Analyzers
                var isAlmostValidCommandType = implementsCommandInterface ^ hasCommandAttribute;

                if (isAlmostValidCommandType && !implementsCommandInterface)
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0001, namedTypeSymbol.Locations.First()));
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0001,
+                        namedTypeSymbol.Locations.First()));

                if (isAlmostValidCommandType && !hasCommandAttribute)
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0002, namedTypeSymbol.Locations.First()));
+                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0002,
+                        namedTypeSymbol.Locations.First()));

                return;
            }
--- a/CliFx.Analyzers/ConsoleUsageAnalyzer.cs
+++ b/CliFx.Analyzers/ConsoleUsageAnalyzer.cs
@@ -18,55 +18,49 @@ namespace CliFx.Analyzers
            SyntaxNodeAnalysisContext context,
            InvocationExpressionSyntax invocationSyntax)
        {
-            // Get the method member access (Console.WriteLine or Console.Error.WriteLine)
-            if (!(invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccessSyntax))
-                return false;
+            if (invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccessSyntax &&
+                context.SemanticModel.GetSymbolInfo(memberAccessSyntax).Symbol is IMethodSymbol methodSymbol)
+            {
+                // Direct call to System.Console (e.g. System.Console.WriteLine())
+                if (KnownSymbols.IsSystemConsole(methodSymbol.ContainingType))
+                {
+                    return true;
+                }

-            // Get the semantic model for the invoked method
-            if (!(context.SemanticModel.GetSymbolInfo(memberAccessSyntax).Symbol is IMethodSymbol methodSymbol))
-                return false;
-
-            // Check if contained within System.Console
-            if (KnownSymbols.IsSystemConsole(methodSymbol.ContainingType))
-                return true;
-
-            // In case with Console.Error.WriteLine that wouldn't work, we need to check parent member access too
-            if (!(memberAccessSyntax.Expression is MemberAccessExpressionSyntax parentMemberAccessSyntax))
-                return false;
-
-            // Get the semantic model for the parent member
-            if (!(context.SemanticModel.GetSymbolInfo(parentMemberAccessSyntax).Symbol is IPropertySymbol propertySymbol))
-                return false;
-
-            // Check if contained within System.Console
-            if (KnownSymbols.IsSystemConsole(propertySymbol.ContainingType))
-                return true;
+                // Indirect call to System.Console (e.g. System.Console.Error.WriteLine())
+                if (memberAccessSyntax.Expression is MemberAccessExpressionSyntax parentMemberAccessSyntax &&
+                    context.SemanticModel.GetSymbolInfo(parentMemberAccessSyntax).Symbol is IPropertySymbol propertySymbol)
+                {
+                    return KnownSymbols.IsSystemConsole(propertySymbol.ContainingType);
+                }
+            }

            return false;
        }

        private static void CheckSystemConsoleUsage(SyntaxNodeAnalysisContext context)
        {
-            if (!(context.Node is InvocationExpressionSyntax invocationSyntax))
-                return;
+            if (context.Node is InvocationExpressionSyntax invocationSyntax &&
+                IsSystemConsoleInvocation(context, invocationSyntax))
+            {
+                // Check if IConsole is available in scope as alternative to System.Console
+                var isConsoleInterfaceAvailable = invocationSyntax
+                    .Ancestors()
+                    .OfType<MethodDeclarationSyntax>()
+                    .SelectMany(m => m.ParameterList.Parameters)
+                    .Select(p => p.Type)
+                    .Select(t => context.SemanticModel.GetSymbolInfo(t).Symbol)
+                    .Where(s => s != null)
+                    .Any(KnownSymbols.IsConsoleInterface!);

-            if (!IsSystemConsoleInvocation(context, invocationSyntax))
-                return;
-
-            // Check if IConsole is available in the scope as a viable alternative
-            var isConsoleInterfaceAvailable = invocationSyntax
-                .Ancestors()
-                .OfType<MethodDeclarationSyntax>()
-                .SelectMany(m => m.ParameterList.Parameters)
-                .Select(p => p.Type)
-                .Select(t => context.SemanticModel.GetSymbolInfo(t).Symbol)
-                .Where(s => s != null)
-                .Any(KnownSymbols.IsConsoleInterface!);
-
-            if (!isConsoleInterfaceAvailable)
-                return;
-
-            context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0100, invocationSyntax.GetLocation()));
+                if (isConsoleInterfaceAvailable)
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        DiagnosticDescriptors.CliFx0100,
+                        invocationSyntax.GetLocation()
+                    ));
+                }
+            }
        }

        public override void Initialize(AnalysisContext context)
--- a/CliFx.Analyzers/DiagnosticDescriptors.cs
+++ b/CliFx.Analyzers/DiagnosticDescriptors.cs
@@ -8,72 +8,126 @@ namespace CliFx.Analyzers
            new DiagnosticDescriptor(nameof(CliFx0001),
                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0002 =
            new DiagnosticDescriptor(nameof(CliFx0002),
                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0021 =
            new DiagnosticDescriptor(nameof(CliFx0021),
                "Parameter order must be unique within its command",
                "Parameter order must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0022 =
            new DiagnosticDescriptor(nameof(CliFx0022),
                "Parameter order must have unique name within its command",
                "Parameter order must have unique name within its command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0023 =
            new DiagnosticDescriptor(nameof(CliFx0023),
                "Only one non-scalar parameter per command is allowed",
                "Only one non-scalar parameter per command is allowed",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0024 =
            new DiagnosticDescriptor(nameof(CliFx0024),
                "Non-scalar parameter must be last in order",
                "Non-scalar parameter must be last in order",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0025 =
+            new DiagnosticDescriptor(nameof(CliFx0025),
+                "Parameter converter must implement 'CliFx.IArgumentValueConverter'",
+                "Parameter converter must implement 'CliFx.IArgumentValueConverter'",
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0026 =
+            new DiagnosticDescriptor(nameof(CliFx0026),
+                "Parameter validator must implement 'CliFx.ArgumentValueValidator<T>'",
+                "Parameter validator must implement 'CliFx.ArgumentValueValidator<T>'",
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0041 =
            new DiagnosticDescriptor(nameof(CliFx0041),
                "Option must have a name or short name specified",
                "Option must have a name or short name specified",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0042 =
            new DiagnosticDescriptor(nameof(CliFx0042),
                "Option name must be at least 2 characters long",
                "Option name must be at least 2 characters long",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0043 =
            new DiagnosticDescriptor(nameof(CliFx0043),
                "Option name must be unique within its command",
                "Option name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0044 =
            new DiagnosticDescriptor(nameof(CliFx0044),
                "Option short name must be unique within its command",
                "Option short name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0045 =
            new DiagnosticDescriptor(nameof(CliFx0045),
                "Option environment variable name must be unique within its command",
                "Option environment variable name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0046 =
+            new DiagnosticDescriptor(nameof(CliFx0046),
+                "Option converter must implement 'CliFx.IArgumentValueConverter'",
+                "Option converter must implement 'CliFx.IArgumentValueConverter'",
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0047 =
+            new DiagnosticDescriptor(nameof(CliFx0047),
+                "Option validator must implement 'CliFx.ArgumentValueValidator<T>'",
+                "Option validator must implement 'CliFx.ArgumentValueValidator<T>'",
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0048 =
+            new DiagnosticDescriptor(nameof(CliFx0048),
+                "Option name must begin with a letter character.",
+                "Option name must begin with a letter character.",
+                "Usage", DiagnosticSeverity.Error, true
+            );
+
+        public static readonly DiagnosticDescriptor CliFx0049 =
+            new DiagnosticDescriptor(nameof(CliFx0049),
+                "Option short name must be a letter character.",
+                "Option short name must be a letter character.",
+                "Usage", DiagnosticSeverity.Error, true
+            );

        public static readonly DiagnosticDescriptor CliFx0100 =
            new DiagnosticDescriptor(nameof(CliFx0100),
                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
-                "Usage", DiagnosticSeverity.Warning, true);
+                "Usage", DiagnosticSeverity.Warning, true
+            );
    }
 }
--- a/CliFx.Analyzers/KnownSymbols.cs
+++ b/CliFx.Analyzers/KnownSymbols.cs
@@ -3,7 +3,7 @@ using Microsoft.CodeAnalysis;

 namespace CliFx.Analyzers
 {
-    public static class KnownSymbols
+    internal static class KnownSymbols
    {
        public static bool IsSystemString(ISymbol symbol) =>
            symbol.DisplayNameMatches("string") ||
@@ -25,6 +25,12 @@ namespace CliFx.Analyzers
        public static bool IsCommandInterface(ISymbol symbol) =>
            symbol.DisplayNameMatches("CliFx.ICommand");

+        public static bool IsArgumentValueConverterInterface(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.IArgumentValueConverter");
+
+        public static bool IsArgumentValueValidatorInterface(ISymbol symbol) =>
+            symbol.DisplayNameMatches("CliFx.IArgumentValueValidator");
+
        public static bool IsCommandAttribute(ISymbol symbol) =>
            symbol.DisplayNameMatches("CliFx.Attributes.CommandAttribute");

--- a/CliFx.Benchmarks/Benchmarks.cs
+++ b/CliFx.Benchmarks/Benchmarks.cs
@@ -18,7 +18,7 @@ namespace CliFx.Benchmarks

        [Benchmark(Description = "CliFx", Baseline = true)]
        public async ValueTask<int> ExecuteWithCliFx() =>
-            await new CliApplicationBuilder().AddCommand(typeof(CliFxCommand)).Build().RunAsync(Arguments, new Dictionary<string, string>());
+            await new CliApplicationBuilder().AddCommand<CliFxCommand>().Build().RunAsync(Arguments, new Dictionary<string, string>());

        [Benchmark(Description = "System.CommandLine")]
        public async Task<int> ExecuteWithSystemCommandLine() =>
--- a/CliFx.Benchmarks/CliFx.Benchmarks.csproj
+++ b/CliFx.Benchmarks/CliFx.Benchmarks.csproj
@@ -3,15 +3,15 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
    <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.3.0" />
-    <PackageReference Include="CommandLineParser" Version="2.7.82" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.6.0" />
+    <PackageReference Include="Cocona" Version="1.5.0" />
+    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.0.0" />
    <PackageReference Include="PowerArgs" Version="3.6.0" />
    <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19317.1" />
  </ItemGroup>
--- a/CliFx.Demo/CliFx.Demo.csproj
+++ b/CliFx.Demo/CliFx.Demo.csproj
@@ -3,11 +3,11 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.2" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.9" />
    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
  </ItemGroup>

--- a/CliFx.Demo/Program.cs
+++ b/CliFx.Demo/Program.cs
@@ -28,7 +28,7 @@ namespace CliFx.Demo
        public static async Task<int> Main() =>
            await new CliApplicationBuilder()
                .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetService)
+                .UseTypeActivator(GetServiceProvider().GetRequiredService)
                .Build()
                .RunAsync();
    }
--- a/CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj
+++ b/CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj
@@ -3,7 +3,7 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
--- a/CliFx.Tests/ApplicationSpecs.Commands.cs
+++ b/CliFx.Tests/ApplicationSpecs.Commands.cs
@@ -1,179 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class ApplicationSpecs
-    {
-        [Command]
-        private class DefaultCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class AnotherDefaultCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class NonImplementedCommand
-        {
-        }
-
-        private class NonAnnotatedCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("dup")]
-        private class DuplicateNameCommandA : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("dup")]
-        private class DuplicateNameCommandB : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class DuplicateParameterOrderCommand : ICommand
-        {
-            [CommandParameter(13)]
-            public string? ParameterA { get; set; }
-
-            [CommandParameter(13)]
-            public string? ParameterB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class DuplicateParameterNameCommand : ICommand
-        {
-            [CommandParameter(0, Name = "param")]
-            public string? ParameterA { get; set; }
-
-            [CommandParameter(1, Name = "param")]
-            public string? ParameterB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class MultipleNonScalarParametersCommand : ICommand
-        {
-            [CommandParameter(0)]
-            public IReadOnlyList<string>? ParameterA { get; set; }
-
-            [CommandParameter(1)]
-            public IReadOnlyList<string>? ParameterB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class NonLastNonScalarParameterCommand : ICommand
-        {
-            [CommandParameter(0)]
-            public IReadOnlyList<string>? ParameterA { get; set; }
-
-            [CommandParameter(1)]
-            public string? ParameterB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class EmptyOptionNameCommand : ICommand
-        {
-            [CommandOption("")]
-            public string? Apples { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class SingleCharacterOptionNameCommand : ICommand
-        {
-            [CommandOption("a")]
-            public string? Apples { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class DuplicateOptionNamesCommand : ICommand
-        {
-            [CommandOption("fruits")]
-            public string? Apples { get; set; }
-
-            [CommandOption("fruits")]
-            public string? Oranges { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class DuplicateOptionShortNamesCommand : ICommand
-        {
-            [CommandOption('x')]
-            public string? OptionA { get; set; }
-
-            [CommandOption('x')]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class ConflictWithHelpOptionCommand : ICommand
-        {
-            [CommandOption("option-h", 'h')]
-            public string? OptionH { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class ConflictWithVersionOptionCommand : ICommand
-        {
-            [CommandOption("version")]
-            public string? Version { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class DuplicateOptionEnvironmentVariableNamesCommand : ICommand
-        {
-            [CommandOption("option-a", EnvironmentVariableName = "ENV_VAR")]
-            public string? OptionA { get; set; }
-
-            [CommandOption("option-b", EnvironmentVariableName = "ENV_VAR")]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("hidden", Description = "Description")]
-        private class HiddenPropertiesCommand : ICommand
-        {
-            [CommandParameter(13, Name = "param", Description = "Param description")]
-            public string? Parameter { get; set; }
-
-            [CommandOption("option", 'o', Description = "Option description", EnvironmentVariableName = "ENV")]
-            public string? Option { get; set; }
-
-            public string? HiddenA { get; set; }
-
-            public bool? HiddenB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/ApplicationSpecs.cs
+++ b/CliFx.Tests/ApplicationSpecs.cs
@@ -1,14 +1,15 @@
 using System;
 using System.IO;
-using CliFx.Domain;
-using CliFx.Exceptions;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
+using CliFx.Tests.Commands.Invalid;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class ApplicationSpecs
+    public class ApplicationSpecs
    {
        private readonly ITestOutputHelper _output;

@@ -31,7 +32,7 @@ namespace CliFx.Tests
        {
            // Act
            var app = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
+                .AddCommand<DefaultCommand>()
                .AddCommandsFrom(typeof(DefaultCommand).Assembly)
                .AddCommands(new[] {typeof(DefaultCommand)})
                .AddCommandsFrom(new[] {typeof(DefaultCommand).Assembly})
@@ -51,219 +52,444 @@ namespace CliFx.Tests
        }

        [Fact]
-        public void At_least_one_command_must_be_defined_in_an_application()
+        public async Task At_least_one_command_must_be_defined_in_an_application()
        {
-            // Arrange
-            var commandTypes = Array.Empty<Type>();
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();

-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Commands_must_implement_the_corresponding_interface()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(NonImplementedCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Commands_must_be_annotated_by_an_attribute()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(NonAnnotatedCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Commands_must_have_unique_names()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateNameCommandA), typeof(DuplicateNameCommandB)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_can_be_default_but_only_if_it_is_the_only_such_command()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DefaultCommand), typeof(AnotherDefaultCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_parameters_must_have_unique_order()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateParameterOrderCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_parameters_must_have_unique_names()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateParameterNameCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_parameter_can_be_non_scalar_only_if_no_other_such_parameter_is_present()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(MultipleNonScalarParametersCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_parameter_can_be_non_scalar_only_if_it_is_the_last_in_order()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(NonLastNonScalarParameterCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_have_names_that_are_not_empty()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(EmptyOptionNameCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_have_names_that_are_longer_than_one_character()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(SingleCharacterOptionNameCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_have_unique_names()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateOptionNamesCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_have_unique_short_names()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateOptionShortNamesCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_not_have_conflicts_with_the_implicit_help_option()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(ConflictWithHelpOptionCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_not_have_conflicts_with_the_implicit_version_option()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(ConflictWithVersionOptionCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_must_have_unique_environment_variable_names()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(DuplicateOptionEnvironmentVariableNamesCommand)};
-
-            // Act & assert
-            var ex = Assert.Throws<CliFxException>(() => RootSchema.Resolve(commandTypes));
-            _output.WriteLine(ex.Message);
-        }
-
-        [Fact]
-        public void Command_options_and_parameters_must_be_annotated_by_corresponding_attributes()
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(HiddenPropertiesCommand)};
+            var application = new CliApplicationBuilder()
+                .UseConsole(console)
+                .Build();

            // Act
-            var schema = RootSchema.Resolve(commandTypes);
+            var exitCode = await application.RunAsync(Array.Empty<string>());

            // Assert
-            schema.Should().BeEquivalentTo(new RootSchema(new[]
-            {
-                new CommandSchema(
-                    typeof(HiddenPropertiesCommand),
-                    "hidden",
-                    "Description",
-                    new[]
-                    {
-                        new CommandParameterSchema(
-                            typeof(HiddenPropertiesCommand).GetProperty(nameof(HiddenPropertiesCommand.Parameter))!,
-                            13,
-                            "param",
-                            "Param description")
-                    },
-                    new[]
-                    {
-                        new CommandOptionSchema(
-                            typeof(HiddenPropertiesCommand).GetProperty(nameof(HiddenPropertiesCommand.Option))!,
-                            "option",
-                            'o',
-                            "ENV",
-                            false,
-                            "Option description"),
-                        CommandOptionSchema.HelpOption
-                    })
-            }));
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();

-            schema.ToString().Should().NotBeNullOrWhiteSpace(); // this is only for coverage, I'm sorry
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(NonImplementedCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_be_annotated_by_an_attribute()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonAnnotatedCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Commands_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<GenericExceptionCommand>()
+                .AddCommand<CommandExceptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_can_be_default_but_only_if_it_is_the_only_such_command()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<OtherDefaultCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameters_must_have_unique_order()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateParameterOrderCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameters_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateParameterNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_can_be_non_scalar_only_if_no_other_such_parameter_is_present()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<MultipleNonScalarParametersCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_can_be_non_scalar_only_if_it_is_the_last_in_order()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonLastNonScalarParameterCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_custom_converter_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<InvalidCustomConverterParameterCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_parameter_custom_validator_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<InvalidCustomValidatorParameterCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_names_that_are_not_empty()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<EmptyOptionNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_names_that_are_longer_than_one_character()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<SingleCharacterOptionNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_short_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionShortNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_unique_environment_variable_names()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DuplicateOptionEnvironmentVariableNamesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_not_have_conflicts_with_the_implicit_help_option()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<ConflictWithHelpOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_not_have_conflicts_with_the_implicit_version_option()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<ConflictWithVersionOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_option_custom_converter_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<InvalidCustomConverterOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_option_custom_validator_must_implement_the_corresponding_interface()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<InvalidCustomValidatorOptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_names_that_start_with_a_letter_character()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonLetterCharacterNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_options_must_have_short_names_that_are_letter_characters()
+        {
+            var (console, _, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NonLetterCharacterShortNameCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();
+
+            _output.WriteLine(stdErr.GetString());
        }
    }
 }
--- a/CliFx.Tests/ArgumentBindingSpecs.Commands.cs
+++ b/CliFx.Tests/ArgumentBindingSpecs.Commands.cs
@@ -1,191 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class ArgumentBindingSpecs
-    {
-        [Command]
-        private class AllSupportedTypesCommand : ICommand
-        {
-            [CommandOption(nameof(Object))]
-            public object? Object { get; set; } = 42;
-
-            [CommandOption(nameof(String))]
-            public string? String { get; set; } = "foo bar";
-
-            [CommandOption(nameof(Bool))]
-            public bool Bool { get; set; }
-
-            [CommandOption(nameof(Char))]
-            public char Char { get; set; }
-
-            [CommandOption(nameof(Sbyte))]
-            public sbyte Sbyte { get; set; }
-
-            [CommandOption(nameof(Byte))]
-            public byte Byte { get; set; }
-
-            [CommandOption(nameof(Short))]
-            public short Short { get; set; }
-
-            [CommandOption(nameof(Ushort))]
-            public ushort Ushort { get; set; }
-
-            [CommandOption(nameof(Int))]
-            public int Int { get; set; }
-
-            [CommandOption(nameof(Uint))]
-            public uint Uint { get; set; }
-
-            [CommandOption(nameof(Long))]
-            public long Long { get; set; }
-
-            [CommandOption(nameof(Ulong))]
-            public ulong Ulong { get; set; }
-
-            [CommandOption(nameof(Float))]
-            public float Float { get; set; }
-
-            [CommandOption(nameof(Double))]
-            public double Double { get; set; }
-
-            [CommandOption(nameof(Decimal))]
-            public decimal Decimal { get; set; }
-
-            [CommandOption(nameof(DateTime))]
-            public DateTime DateTime { get; set; }
-
-            [CommandOption(nameof(DateTimeOffset))]
-            public DateTimeOffset DateTimeOffset { get; set; }
-
-            [CommandOption(nameof(TimeSpan))]
-            public TimeSpan TimeSpan { get; set; }
-
-            [CommandOption(nameof(CustomEnum))]
-            public CustomEnum CustomEnum { get; set; }
-
-            [CommandOption(nameof(IntNullable))]
-            public int? IntNullable { get; set; }
-
-            [CommandOption(nameof(CustomEnumNullable))]
-            public CustomEnum? CustomEnumNullable { get; set; }
-
-            [CommandOption(nameof(TimeSpanNullable))]
-            public TimeSpan? TimeSpanNullable { get; set; }
-
-            [CommandOption(nameof(TestStringConstructable))]
-            public StringConstructable? TestStringConstructable { get; set; }
-
-            [CommandOption(nameof(TestStringParseable))]
-            public StringParseable? TestStringParseable { get; set; }
-
-            [CommandOption(nameof(TestStringParseableWithFormatProvider))]
-            public StringParseableWithFormatProvider? TestStringParseableWithFormatProvider { get; set; }
-
-            [CommandOption(nameof(ObjectArray))]
-            public object[]? ObjectArray { get; set; }
-
-            [CommandOption(nameof(StringArray))]
-            public string[]? StringArray { get; set; }
-
-            [CommandOption(nameof(IntArray))]
-            public int[]? IntArray { get; set; }
-
-            [CommandOption(nameof(CustomEnumArray))]
-            public CustomEnum[]? CustomEnumArray { get; set; }
-
-            [CommandOption(nameof(IntNullableArray))]
-            public int?[]? IntNullableArray { get; set; }
-
-            [CommandOption(nameof(TestStringConstructableArray))]
-            public StringConstructable[]? TestStringConstructableArray { get; set; }
-
-            [CommandOption(nameof(Enumerable))]
-            public IEnumerable? Enumerable { get; set; }
-
-            [CommandOption(nameof(StringEnumerable))]
-            public IEnumerable<string>? StringEnumerable { get; set; }
-
-            [CommandOption(nameof(StringReadOnlyList))]
-            public IReadOnlyList<string>? StringReadOnlyList { get; set; }
-
-            [CommandOption(nameof(StringList))]
-            public List<string>? StringList { get; set; }
-
-            [CommandOption(nameof(StringHashSet))]
-            public HashSet<string>? StringHashSet { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class ArrayOptionCommand : ICommand
-        {
-            [CommandOption("option", 'o')]
-            public IReadOnlyList<string>? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class RequiredOptionCommand : ICommand
-        {
-            [CommandOption(nameof(OptionA))]
-            public string? OptionA { get; set; }
-
-            [CommandOption(nameof(OptionB), IsRequired = true)]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class ParametersCommand : ICommand
-        {
-            [CommandParameter(0)]
-            public string? ParameterA { get; set; }
-
-            [CommandParameter(1)]
-            public string? ParameterB { get; set; }
-
-            [CommandParameter(2)]
-            public IReadOnlyList<string>? ParameterC { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class UnsupportedPropertyTypeCommand : ICommand
-        {
-            [CommandOption(nameof(Option))]
-            public DummyType? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class UnsupportedEnumerablePropertyTypeCommand : ICommand
-        {
-            [CommandOption(nameof(Option))]
-            public CustomEnumerable<string>? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class NoParameterCommand : ICommand
-        {
-            [CommandOption(nameof(OptionA))]
-            public string? OptionA { get; set; }
-
-            [CommandOption(nameof(OptionB))]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/ArgumentBindingSpecs.Types.cs
+++ b/CliFx.Tests/ArgumentBindingSpecs.Types.cs
@@ -1,53 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace CliFx.Tests
-{
-    public partial class ArgumentBindingSpecs
-    {
-        private enum CustomEnum
-        {
-            Value1 = 1,
-            Value2 = 2,
-            Value3 = 3
-        }
-
-        private class StringConstructable
-        {
-            public string Value { get; }
-
-            public StringConstructable(string value) => Value = value;
-        }
-
-        private class StringParseable
-        {
-            public string Value { get; }
-
-            private StringParseable(string value) => Value = value;
-
-            public static StringParseable Parse(string value) => new StringParseable(value);
-        }
-
-        private class StringParseableWithFormatProvider
-        {
-            public string Value { get; }
-
-            private StringParseableWithFormatProvider(string value) => Value = value;
-
-            public static StringParseableWithFormatProvider Parse(string value, IFormatProvider formatProvider) =>
-                new StringParseableWithFormatProvider(value + " " + formatProvider);
-        }
-
-        private class DummyType
-        {
-        }
-
-        public class CustomEnumerable<T> : IEnumerable<T>
-        {
-            public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>) Array.Empty<T>()).GetEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-        }
-    }
-}
--- a/CliFx.Tests/ArgumentBindingSpecs.cs
+++ b/CliFx.Tests/ArgumentBindingSpecs.cs
--- a/CliFx.Tests/ArgumentConversionSpecs.cs
+++ b/CliFx.Tests/ArgumentConversionSpecs.cs
--- a/CliFx.Tests/ArgumentSyntaxSpecs.cs
+++ b/CliFx.Tests/ArgumentSyntaxSpecs.cs
@@ -1,378 +0,0 @@
-using System;
-using System.Collections.Generic;
-using CliFx.Domain;
-using CliFx.Tests.Internal;
-using FluentAssertions;
-using Xunit;
-
-namespace CliFx.Tests
-{
-    public class ArgumentSyntaxSpecs
-    {
-        [Fact]
-        public void Input_is_empty_if_no_arguments_are_provided()
-        {
-            // Arrange
-            var arguments = Array.Empty<string>();
-            var commandNames = Array.Empty<string>();
-
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(CommandInput.Empty);
-        }
-
-        public static object[][] DirectivesTestData => new[]
-        {
-            new object[]
-            {
-                new[] {"[preview]"},
-                new CommandInputBuilder()
-                    .AddDirective("preview")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"[preview]", "[debug]"},
-                new CommandInputBuilder()
-                    .AddDirective("preview")
-                    .AddDirective("debug")
-                    .Build()
-            }
-        };
-
-        [Theory]
-        [MemberData(nameof(DirectivesTestData))]
-        internal void Directive_can_be_enabled_by_specifying_its_name_in_square_brackets(IReadOnlyList<string> arguments, CommandInput expectedInput)
-        {
-            // Arrange
-            var commandNames = Array.Empty<string>();
-
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(expectedInput);
-        }
-
-        public static object[][] OptionsTestData => new[]
-        {
-            new object[]
-            {
-                new[] {"--option"},
-                new CommandInputBuilder()
-                    .AddOption("option")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option", "value"},
-                new CommandInputBuilder()
-                    .AddOption("option", "value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option", "value1", "value2"},
-                new CommandInputBuilder()
-                    .AddOption("option", "value1", "value2")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option", "same value"},
-                new CommandInputBuilder()
-                    .AddOption("option", "same value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option1", "--option2"},
-                new CommandInputBuilder()
-                    .AddOption("option1")
-                    .AddOption("option2")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option1", "value1", "--option2", "value2"},
-                new CommandInputBuilder()
-                    .AddOption("option1", "value1")
-                    .AddOption("option2", "value2")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option1", "value1", "value2", "--option2", "value3", "value4"},
-                new CommandInputBuilder()
-                    .AddOption("option1", "value1", "value2")
-                    .AddOption("option2", "value3", "value4")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"--option1", "value1", "value2", "--option2"},
-                new CommandInputBuilder()
-                    .AddOption("option1", "value1", "value2")
-                    .AddOption("option2")
-                    .Build()
-            }
-        };
-
-        [Theory]
-        [MemberData(nameof(OptionsTestData))]
-        internal void Option_can_be_set_by_specifying_its_name_after_two_dashes(IReadOnlyList<string> arguments, CommandInput expectedInput)
-        {
-            // Arrange
-            var commandNames = Array.Empty<string>();
-
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(expectedInput);
-        }
-
-        public static object[][] ShortOptionsTestData => new[]
-        {
-            new object[]
-            {
-                new[] {"-o"},
-                new CommandInputBuilder()
-                    .AddOption("o")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-o", "value"},
-                new CommandInputBuilder()
-                    .AddOption("o", "value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-o", "value1", "value2"},
-                new CommandInputBuilder()
-                    .AddOption("o", "value1", "value2")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-o", "same value"},
-                new CommandInputBuilder()
-                    .AddOption("o", "same value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-a", "-b"},
-                new CommandInputBuilder()
-                    .AddOption("a")
-                    .AddOption("b")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-a", "value1", "-b", "value2"},
-                new CommandInputBuilder()
-                    .AddOption("a", "value1")
-                    .AddOption("b", "value2")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-a", "value1", "value2", "-b", "value3", "value4"},
-                new CommandInputBuilder()
-                    .AddOption("a", "value1", "value2")
-                    .AddOption("b", "value3", "value4")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-a", "value1", "value2", "-b"},
-                new CommandInputBuilder()
-                    .AddOption("a", "value1", "value2")
-                    .AddOption("b")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-abc"},
-                new CommandInputBuilder()
-                    .AddOption("a")
-                    .AddOption("b")
-                    .AddOption("c")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-abc", "value"},
-                new CommandInputBuilder()
-                    .AddOption("a")
-                    .AddOption("b")
-                    .AddOption("c", "value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"-abc", "value1", "value2"},
-                new CommandInputBuilder()
-                    .AddOption("a")
-                    .AddOption("b")
-                    .AddOption("c", "value1", "value2")
-                    .Build()
-            }
-        };
-
-        [Theory]
-        [MemberData(nameof(ShortOptionsTestData))]
-        internal void Option_can_be_set_by_specifying_its_short_name_after_a_single_dash(IReadOnlyList<string> arguments, CommandInput expectedInput)
-        {
-            // Arrange
-            var commandNames = Array.Empty<string>();
-
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(expectedInput);
-        }
-
-        public static object[][] ParametersTestData => new[]
-        {
-            new object[]
-            {
-                new[] {"foo"},
-                new CommandInputBuilder()
-                    .AddParameter("foo")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"foo", "bar"},
-                new CommandInputBuilder()
-                    .AddParameter("foo")
-                    .AddParameter("bar")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"[preview]", "foo"},
-                new CommandInputBuilder()
-                    .AddDirective("preview")
-                    .AddParameter("foo")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"foo", "--option", "value", "-abc"},
-                new CommandInputBuilder()
-                    .AddParameter("foo")
-                    .AddOption("option", "value")
-                    .AddOption("a")
-                    .AddOption("b")
-                    .AddOption("c")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"[preview]", "[debug]", "foo", "bar", "--option", "value", "-abc"},
-                new CommandInputBuilder()
-                    .AddDirective("preview")
-                    .AddDirective("debug")
-                    .AddParameter("foo")
-                    .AddParameter("bar")
-                    .AddOption("option", "value")
-                    .AddOption("a")
-                    .AddOption("b")
-                    .AddOption("c")
-                    .Build()
-            }
-        };
-
-        [Theory]
-        [MemberData(nameof(ParametersTestData))]
-        internal void Parameter_can_be_set_by_specifying_the_value_directly(IReadOnlyList<string> arguments, CommandInput expectedInput)
-        {
-            // Arrange
-            var commandNames = Array.Empty<string>();
-
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(expectedInput);
-        }
-
-        public static object[][] CommandNameTestData => new[]
-        {
-            new object[]
-            {
-                new[] {"cmd"},
-                new[] {"cmd"},
-                new CommandInputBuilder()
-                    .SetCommandName("cmd")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"cmd"},
-                new[] {"cmd", "foo", "bar", "-o", "value"},
-                new CommandInputBuilder()
-                    .SetCommandName("cmd")
-                    .AddParameter("foo")
-                    .AddParameter("bar")
-                    .AddOption("o", "value")
-                    .Build()
-            },
-
-            new object[]
-            {
-                new[] {"cmd", "cmd sub"},
-                new[] {"cmd", "sub", "foo"},
-                new CommandInputBuilder()
-                    .SetCommandName("cmd sub")
-                    .AddParameter("foo")
-                    .Build()
-            }
-        };
-
-        [Theory]
-        [MemberData(nameof(CommandNameTestData))]
-        internal void Command_name_is_matched_from_arguments_that_come_before_parameters(
-            IReadOnlyList<string> commandNames,
-            IReadOnlyList<string> arguments,
-            CommandInput expectedInput)
-        {
-            // Act
-            var input = CommandInput.Parse(arguments, commandNames);
-
-            // Assert
-            input.Should().BeEquivalentTo(expectedInput);
-        }
-    }
-}
--- a/CliFx.Tests/CancellationSpecs.Commands.cs
+++ b/CliFx.Tests/CancellationSpecs.Commands.cs
@@ -1,27 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class CancellationSpecs
-    {
-        [Command("cancel")]
-        private class CancellableCommand : ICommand
-        {
-            public async ValueTask ExecuteAsync(IConsole console)
-            {
-                try
-                {
-                    await Task.Delay(TimeSpan.FromSeconds(3), console.GetCancellationToken());
-                    console.Output.WriteLine("Never printed");
-                }
-                catch (OperationCanceledException)
-                {
-                    console.Output.WriteLine("Cancellation requested");
-                    throw;
-                }
-            }
-        }
-    }
-}
--- a/CliFx.Tests/CancellationSpecs.cs
+++ b/CliFx.Tests/CancellationSpecs.cs
@@ -1,14 +1,13 @@
 using System;
-using System.Collections.Generic;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;

 namespace CliFx.Tests
 {
-    public partial class CancellationSpecs
+    public class CancellationSpecs
    {
        [Fact]
        public async Task Command_can_perform_additional_cleanup_if_cancellation_is_requested()
@@ -17,27 +16,21 @@ namespace CliFx.Tests

            // Arrange
            using var cts = new CancellationTokenSource();
-
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut, cancellationToken: cts.Token);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered(cts.Token);

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CancellableCommand))
+                .AddCommand<CancellableCommand>()
                .UseConsole(console)
                .Build();

            // Act
            cts.CancelAfter(TimeSpan.FromSeconds(0.2));

-            var exitCode = await application.RunAsync(
-                new[] {"cancel"},
-                new Dictionary<string, string>());
-
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd"});

            // Assert
            exitCode.Should().NotBe(0);
-            stdOutData.Should().Be("Cancellation requested");
+            stdOut.GetString().Trim().Should().Be(CancellableCommand.CancellationOutputText);
        }
    }
 }
--- a/CliFx.Tests/CliFx.Tests.csproj
+++ b/CliFx.Tests/CliFx.Tests.csproj
@@ -2,12 +2,11 @@
  <Import Project="../CliFx.props" />

  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <CollectCoverage>true</CollectCoverage>
    <CoverletOutputFormat>opencover</CoverletOutputFormat>
-    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
  </PropertyGroup>

  <ItemGroup>
@@ -15,13 +14,14 @@
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="CliWrap" Version="3.0.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="CliWrap" Version="3.2.2" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.1.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.msbuild" Version="2.9.0" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup>
--- a/CliFx.Tests/Commands/CancellableCommand.cs
+++ b/CliFx.Tests/Commands/CancellableCommand.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class CancellableCommand : ICommand
+    {
+        public const string CompletionOutputText = "Finished";
+        public const string CancellationOutputText = "Canceled";
+
+        public async ValueTask ExecuteAsync(IConsole console)
+        {
+            try
+            {
+                await Task.Delay(
+                    TimeSpan.FromSeconds(3),
+                    console.GetCancellationToken()
+                );
+
+                console.Output.WriteLine(CompletionOutputText);
+            }
+            catch (OperationCanceledException)
+            {
+                console.Output.WriteLine(CancellationOutputText);
+                throw;
+            }
+        }
+    }
+}
--- a/CliFx.Tests/Commands/CommandExceptionCommand.cs
+++ b/CliFx.Tests/Commands/CommandExceptionCommand.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Exceptions;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class CommandExceptionCommand : ICommand
+    {
+        [CommandOption("code", 'c')]
+        public int ExitCode { get; set; } = 133;
+
+        [CommandOption("msg", 'm')]
+        public string? Message { get; set; }
+
+        [CommandOption("show-help")]
+        public bool ShowHelp { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) => throw new CommandException(Message, ExitCode, ShowHelp);
+    }
+}
--- a/CliFx.Tests/Commands/DefaultCommand.cs
+++ b/CliFx.Tests/Commands/DefaultCommand.cs
@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command(Description = "Default command description")]
+    public class DefaultCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(DefaultCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/GenericExceptionCommand.cs
+++ b/CliFx.Tests/Commands/GenericExceptionCommand.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class GenericExceptionCommand : ICommand
+    {
+        [CommandOption("msg", 'm')]
+        public string? Message { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) => throw new Exception(Message);
+    }
+}
--- a/CliFx.Tests/Commands/GenericInnerExceptionCommand.cs
+++ b/CliFx.Tests/Commands/GenericInnerExceptionCommand.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class GenericInnerExceptionCommand : ICommand
+    {
+        [CommandOption("msg", 'm')]
+        public string? Message { get; set; }
+
+        [CommandOption("inner-msg", 'i')]
+        public string? InnerMessage { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) =>
+            throw new Exception(Message, new Exception(InnerMessage));
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/ConflictWithHelpOptionCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/ConflictWithHelpOptionCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class ConflictWithHelpOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("option-h", 'h')]
+        public string? OptionH { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/ConflictWithVersionOptionCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/ConflictWithVersionOptionCommand.cs
@@ -0,0 +1,12 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    // Must be default because version option is available only on default commands
+    [Command]
+    public class ConflictWithVersionOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("version")]
+        public string? Version { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/DuplicateOptionEnvironmentVariableNamesCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/DuplicateOptionEnvironmentVariableNamesCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionEnvironmentVariableNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("option-a", EnvironmentVariableName = "ENV_VAR")]
+        public string? OptionA { get; set; }
+
+        [CommandOption("option-b", EnvironmentVariableName = "ENV_VAR")]
+        public string? OptionB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/DuplicateOptionNamesCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/DuplicateOptionNamesCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("fruits")]
+        public string? Apples { get; set; }
+
+        [CommandOption("fruits")]
+        public string? Oranges { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/DuplicateOptionShortNamesCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/DuplicateOptionShortNamesCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateOptionShortNamesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption('x')]
+        public string? OptionA { get; set; }
+
+        [CommandOption('x')]
+        public string? OptionB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/DuplicateParameterNameCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/DuplicateParameterNameCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateParameterNameCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0, Name = "param")]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(1, Name = "param")]
+        public string? ParamB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/DuplicateParameterOrderCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/DuplicateParameterOrderCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class DuplicateParameterOrderCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(13)]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(13)]
+        public string? ParamB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/EmptyOptionNameCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/EmptyOptionNameCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class EmptyOptionNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("")]
+        public string? Apples { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/InvalidCustomConverterOptionCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/InvalidCustomConverterOptionCommand.cs
@@ -0,0 +1,16 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class InvalidCustomConverterOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption('f', Converter = typeof(Converter))]
+        public string? Option { get; set; }
+
+        public class Converter
+        {
+            public object ConvertFrom(string value) => value;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/InvalidCustomConverterParameterCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/InvalidCustomConverterParameterCommand.cs
@@ -0,0 +1,16 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class InvalidCustomConverterParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0, Converter = typeof(Converter))]
+        public string? Param { get; set; }
+
+        public class Converter
+        {
+            public object ConvertFrom(string value) => value;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/InvalidCustomValidatorOptionCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/InvalidCustomValidatorOptionCommand.cs
@@ -0,0 +1,16 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class InvalidCustomValidatorOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption('f', Validators = new[] { typeof(Validator) })]
+        public string? Option { get; set; }
+
+        public class Validator
+        {
+            public ValidationResult Validate(string value) => ValidationResult.Ok();
+        }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/InvalidCustomValidatorParameterCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/InvalidCustomValidatorParameterCommand.cs
@@ -0,0 +1,16 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class InvalidCustomValidatorParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0, Validators = new[] { typeof(Validator) })]
+        public string? Param { get; set; }
+
+        public class Validator
+        {
+            public ValidationResult Validate(string value) => ValidationResult.Ok();
+        }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/MultipleNonScalarParametersCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/MultipleNonScalarParametersCommand.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class MultipleNonScalarParametersCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public IReadOnlyList<string>? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public IReadOnlyList<string>? ParamB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/NonAnnotatedCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/NonAnnotatedCommand.cs
@@ -0,0 +1,6 @@
+namespace CliFx.Tests.Commands.Invalid
+{
+    public class NonAnnotatedCommand : SelfSerializeCommandBase
+    {
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/NonImplementedCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/NonImplementedCommand.cs
@@ -0,0 +1,9 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class NonImplementedCommand
+    {
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/NonLastNonScalarParameterCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/NonLastNonScalarParameterCommand.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class NonLastNonScalarParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public IReadOnlyList<string>? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public string? ParamB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/NonLetterCharacterNameCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/NonLetterCharacterNameCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class NonLetterCharacterNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("0foo")]
+        public string? Apples { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/NonLetterCharacterShortNameCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/NonLetterCharacterShortNameCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class NonLetterCharacterShortNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption('0')]
+        public string? Apples { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/OtherDefaultCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/OtherDefaultCommand.cs
@@ -0,0 +1,9 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command]
+    public class OtherDefaultCommand : SelfSerializeCommandBase
+    {
+    }
+}
--- a/CliFx.Tests/Commands/Invalid/SingleCharacterOptionNameCommand.cs
+++ b/CliFx.Tests/Commands/Invalid/SingleCharacterOptionNameCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands.Invalid
+{
+    [Command("cmd")]
+    public class SingleCharacterOptionNameCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("a")]
+        public string? Apples { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/NamedCommand.cs
+++ b/CliFx.Tests/Commands/NamedCommand.cs
@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("named", Description = "Named command description")]
+    public class NamedCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(NamedCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/NamedSubCommand.cs
+++ b/CliFx.Tests/Commands/NamedSubCommand.cs
@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("named sub", Description = "Named sub command description")]
+    public class NamedSubCommand : ICommand
+    {
+        public const string ExpectedOutputText = nameof(NamedSubCommand);
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(ExpectedOutputText);
+            return default;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/SelfSerializeCommandBase.cs
+++ b/CliFx.Tests/Commands/SelfSerializeCommandBase.cs
@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+
+namespace CliFx.Tests.Commands
+{
+    public abstract class SelfSerializeCommandBase : ICommand
+    {
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine(JsonConvert.SerializeObject(this));
+            return default;
+        }
+    }
+}
--- a/CliFx.Tests/Commands/SupportedArgumentTypesCommand.cs
+++ b/CliFx.Tests/Commands/SupportedArgumentTypesCommand.cs
@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using CliFx.Attributes;
+using Newtonsoft.Json;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public partial class SupportedArgumentTypesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("obj")]
+        public object? Object { get; set; } = 42;
+
+        [CommandOption("str")]
+        public string? String { get; set; } = "foo bar";
+
+        [CommandOption("bool")]
+        public bool Bool { get; set; }
+
+        [CommandOption("char")]
+        public char Char { get; set; }
+
+        [CommandOption("sbyte")]
+        public sbyte Sbyte { get; set; }
+
+        [CommandOption("byte")]
+        public byte Byte { get; set; }
+
+        [CommandOption("short")]
+        public short Short { get; set; }
+
+        [CommandOption("ushort")]
+        public ushort Ushort { get; set; }
+
+        [CommandOption("int")]
+        public int Int { get; set; }
+
+        [CommandOption("uint")]
+        public uint Uint { get; set; }
+
+        [CommandOption("long")]
+        public long Long { get; set; }
+
+        [CommandOption("ulong")]
+        public ulong Ulong { get; set; }
+
+        [CommandOption("float")]
+        public float Float { get; set; }
+
+        [CommandOption("double")]
+        public double Double { get; set; }
+
+        [CommandOption("decimal")]
+        public decimal Decimal { get; set; }
+
+        [CommandOption("datetime")]
+        public DateTime DateTime { get; set; }
+
+        [CommandOption("datetime-offset")]
+        public DateTimeOffset DateTimeOffset { get; set; }
+
+        [CommandOption("timespan")]
+        public TimeSpan TimeSpan { get; set; }
+
+        [CommandOption("enum")]
+        public CustomEnum Enum { get; set; }
+
+        [CommandOption("int-nullable")]
+        public int? IntNullable { get; set; }
+
+        [CommandOption("enum-nullable")]
+        public CustomEnum? EnumNullable { get; set; }
+
+        [CommandOption("timespan-nullable")]
+        public TimeSpan? TimeSpanNullable { get; set; }
+
+        [CommandOption("str-constructible")]
+        public CustomStringConstructible? StringConstructible { get; set; }
+
+        [CommandOption("str-parseable")]
+        public CustomStringParseable? StringParseable { get; set; }
+
+        [CommandOption("str-parseable-format")]
+        public CustomStringParseableWithFormatProvider? StringParseableWithFormatProvider { get; set; }
+
+        [CommandOption("convertible", Converter = typeof(CustomConvertibleConverter))]
+        public CustomConvertible? Convertible { get; set; }
+
+        [CommandOption("obj-array")]
+        public object[]? ObjectArray { get; set; }
+
+        [CommandOption("str-array")]
+        public string[]? StringArray { get; set; }
+
+        [CommandOption("int-array")]
+        public int[]? IntArray { get; set; }
+
+        [CommandOption("enum-array")]
+        public CustomEnum[]? EnumArray { get; set; }
+
+        [CommandOption("int-nullable-array")]
+        public int?[]? IntNullableArray { get; set; }
+
+        [CommandOption("str-constructible-array")]
+        public CustomStringConstructible[]? StringConstructibleArray { get; set; }
+
+        [CommandOption("convertible-array", Converter = typeof(CustomConvertibleConverter))]
+        public CustomConvertible[]? ConvertibleArray { get; set; }
+
+        [CommandOption("str-enumerable")]
+        public IEnumerable<string>? StringEnumerable { get; set; }
+
+        [CommandOption("str-read-only-list")]
+        public IReadOnlyList<string>? StringReadOnlyList { get; set; }
+
+        [CommandOption("str-list")]
+        public List<string>? StringList { get; set; }
+
+        [CommandOption("str-set")]
+        public HashSet<string>? StringHashSet { get; set; }
+    }
+
+    public partial class SupportedArgumentTypesCommand
+    {
+        public enum CustomEnum
+        {
+            Value1 = 1,
+            Value2 = 2,
+            Value3 = 3
+        }
+
+        public class CustomStringConstructible
+        {
+            public string Value { get; }
+
+            public CustomStringConstructible(string value) => Value = value;
+        }
+
+        public class CustomStringParseable
+        {
+            public string Value { get; }
+
+            [JsonConstructor]
+            private CustomStringParseable(string value) => Value = value;
+
+            public static CustomStringParseable Parse(string value) => new CustomStringParseable(value);
+        }
+
+        public class CustomStringParseableWithFormatProvider
+        {
+            public string Value { get; }
+
+            [JsonConstructor]
+            private CustomStringParseableWithFormatProvider(string value) => Value = value;
+
+            public static CustomStringParseableWithFormatProvider Parse(string value, IFormatProvider formatProvider) =>
+                new CustomStringParseableWithFormatProvider(value + " " + formatProvider);
+        }
+
+        public class CustomConvertible
+        {
+            public int Value { get; }
+
+            public CustomConvertible(int value) => Value = value;
+        }
+
+        public class CustomConvertibleConverter : ArgumentValueConverter<CustomConvertible>
+        {
+            public override CustomConvertible ConvertFrom(string value) =>
+                new CustomConvertible(int.Parse(value, CultureInfo.InvariantCulture));
+        }
+    }
+}
--- a/CliFx.Tests/Commands/UnsupportedArgumentTypesCommand.cs
+++ b/CliFx.Tests/Commands/UnsupportedArgumentTypesCommand.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public partial class UnsupportedArgumentTypesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("custom")]
+        public CustomType? CustomNonConvertible { get; set; }
+
+        [CommandOption("custom-enumerable")]
+        public CustomEnumerable<string>? CustomEnumerableNonConvertible { get; set; }
+    }
+
+    public partial class UnsupportedArgumentTypesCommand
+    {
+        public class CustomType
+        {
+        }
+
+        public class CustomEnumerable<T> : IEnumerable<T>
+        {
+            public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>) Array.Empty<T>()).GetEnumerator();
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+    }
+}
--- a/CliFx.Tests/Commands/WithDefaultValuesCommand.cs
+++ b/CliFx.Tests/Commands/WithDefaultValuesCommand.cs
@@ -0,0 +1,44 @@
+using System;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithDefaultValuesCommand : SelfSerializeCommandBase
+    {
+        public enum CustomEnum { Value1, Value2, Value3 };
+
+        [CommandOption("obj")]
+        public object? Object { get; set; } = 42;
+
+        [CommandOption("str")]
+        public string? String { get; set; } = "foo";
+
+        [CommandOption("str-empty")]
+        public string StringEmpty { get; set; } = "";
+
+        [CommandOption("str-array")]
+        public string[]? StringArray { get; set; } = { "foo", "bar", "baz" };
+
+        [CommandOption("bool")]
+        public bool Bool { get; set; } = true;
+
+        [CommandOption("char")]
+        public char Char { get; set; } = 't';
+
+        [CommandOption("int")]
+        public int Int { get; set; } = 1337;
+
+        [CommandOption("int-nullable")]
+        public int? IntNullable { get; set; } = 1337;
+
+        [CommandOption("int-array")]
+        public int[]? IntArray { get; set; } = { 1, 2, 3 };
+
+        [CommandOption("timespan")]
+        public TimeSpan TimeSpan { get; set; } = TimeSpan.FromMinutes(123);
+
+        [CommandOption("enum")]
+        public CustomEnum Enum { get; set; } = CustomEnum.Value2;
+    }
+}
--- a/CliFx.Tests/Commands/WithDependenciesCommand.cs
+++ b/CliFx.Tests/Commands/WithDependenciesCommand.cs
@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithDependenciesCommand : ICommand
+    {
+        public class DependencyA
+        {
+        }
+
+        public class DependencyB
+        {
+        }
+
+        private readonly DependencyA _dependencyA;
+        private readonly DependencyB _dependencyB;
+
+        public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB)
+        {
+            _dependencyA = dependencyA;
+            _dependencyB = dependencyB;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console) => default;
+    }
+}
--- a/CliFx.Tests/Commands/WithEnumArgumentsCommand.cs
+++ b/CliFx.Tests/Commands/WithEnumArgumentsCommand.cs
@@ -0,0 +1,19 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithEnumArgumentsCommand : SelfSerializeCommandBase
+    {
+        public enum CustomEnum { Value1, Value2, Value3 };
+
+        [CommandParameter(0, Name = "enum")]
+        public CustomEnum EnumParameter { get; set; }
+
+        [CommandOption("enum")]
+        public CustomEnum? EnumOption { get; set; }
+
+        [CommandOption("required-enum", IsRequired = true)]
+        public CustomEnum RequiredEnumOption { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithEnvironmentVariablesCommand.cs
+++ b/CliFx.Tests/Commands/WithEnvironmentVariablesCommand.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithEnvironmentVariablesCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a", 'a', EnvironmentVariableName = "ENV_OPT_A")]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", 'b', EnvironmentVariableName = "ENV_OPT_B")]
+        public IReadOnlyList<string>? OptB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithParametersCommand.cs
+++ b/CliFx.Tests/Commands/WithParametersCommand.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithParametersCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public string? ParamA { get; set; }
+
+        [CommandParameter(1)]
+        public int? ParamB { get; set; }
+
+        [CommandParameter(2)]
+        public IReadOnlyList<string>? ParamC { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithRequiredOptionsCommand.cs
+++ b/CliFx.Tests/Commands/WithRequiredOptionsCommand.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithRequiredOptionsCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a", 'a', IsRequired = true)]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", 'b')]
+        public int? OptB { get; set; }
+
+        [CommandOption("opt-c", 'c', IsRequired = true)]
+        public IReadOnlyList<char>? OptC { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithSingleParameterCommand.cs
+++ b/CliFx.Tests/Commands/WithSingleParameterCommand.cs
@@ -0,0 +1,11 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithSingleParameterCommand : SelfSerializeCommandBase
+    {
+        [CommandParameter(0)]
+        public string? ParamA { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithSingleRequiredOptionCommand.cs
+++ b/CliFx.Tests/Commands/WithSingleRequiredOptionCommand.cs
@@ -0,0 +1,14 @@
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithSingleRequiredOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt-a")]
+        public string? OptA { get; set; }
+
+        [CommandOption("opt-b", IsRequired = true)]
+        public string? OptB { get; set; }
+    }
+}
--- a/CliFx.Tests/Commands/WithStringArrayOptionCommand.cs
+++ b/CliFx.Tests/Commands/WithStringArrayOptionCommand.cs
@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Commands
+{
+    [Command("cmd")]
+    public class WithStringArrayOptionCommand : SelfSerializeCommandBase
+    {
+        [CommandOption("opt", 'o')]
+        public IReadOnlyList<string>? Opt { get; set; }
+    }
+}
--- a/CliFx.Tests/ConsoleSpecs.cs
+++ b/CliFx.Tests/ConsoleSpecs.cs
@@ -38,7 +38,8 @@ namespace CliFx.Tests
            var console = new VirtualConsole(
                input: stdIn,
                output: stdOut,
-                error: stdErr);
+                error: stdErr
+            );

            // Act
            console.Output.Write("output");
--- a/CliFx.Tests/DependencyInjectionSpecs.Commands.cs
+++ b/CliFx.Tests/DependencyInjectionSpecs.Commands.cs
@@ -1,37 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class DependencyInjectionSpecs
-    {
-        [Command]
-        private class WithoutDependenciesCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        private class DependencyA
-        {
-        }
-
-        private class DependencyB
-        {
-        }
-
-        [Command]
-        private class WithDependenciesCommand : ICommand
-        {
-            private readonly DependencyA _dependencyA;
-            private readonly DependencyB _dependencyB;
-
-            public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB)
-            {
-                _dependencyA = dependencyA;
-                _dependencyB = dependencyB;
-            }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/DependencyInjectionSpecs.cs
+++ b/CliFx.Tests/DependencyInjectionSpecs.cs
@@ -1,11 +1,12 @@
 using CliFx.Exceptions;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class DependencyInjectionSpecs
+    public class DependencyInjectionSpecs
    {
        private readonly ITestOutputHelper _output;

@@ -18,10 +19,10 @@ namespace CliFx.Tests
            var activator = new DefaultTypeActivator();

            // Act
-            var obj = activator.CreateInstance(typeof(WithoutDependenciesCommand));
+            var obj = activator.CreateInstance(typeof(DefaultCommand));

            // Assert
-            obj.Should().BeOfType<WithoutDependenciesCommand>();
+            obj.Should().BeOfType<DefaultCommand>();
        }

        [Fact]
@@ -40,7 +41,10 @@ namespace CliFx.Tests
        {
            // Arrange
            var activator = new DelegateTypeActivator(_ =>
-                new WithDependenciesCommand(new DependencyA(), new DependencyB()));
+                new WithDependenciesCommand(
+                    new WithDependenciesCommand.DependencyA(),
+                    new WithDependenciesCommand.DependencyB())
+            );

            // Act
            var obj = activator.CreateInstance(typeof(WithDependenciesCommand));
--- a/CliFx.Tests/DirectivesSpecs.Commands.cs
+++ b/CliFx.Tests/DirectivesSpecs.Commands.cs
@@ -1,14 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class DirectivesSpecs
-    {
-        [Command("cmd")]
-        private class NamedCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/DirectivesSpecs.cs
+++ b/CliFx.Tests/DirectivesSpecs.cs
@@ -1,36 +1,44 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;
+using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class DirectivesSpecs
+    public class DirectivesSpecs
    {
+        private readonly ITestOutputHelper _output;
+
+        public DirectivesSpecs(ITestOutputHelper output) => _output = output;
+
        [Fact]
        public async Task Preview_directive_can_be_specified_to_print_provided_arguments_as_they_were_parsed()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(NamedCommand))
+                .AddCommand<NamedCommand>()
                .UseConsole(console)
                .AllowPreviewMode()
                .Build();

            // Act
            var exitCode = await application.RunAsync(
-                new[] {"[preview]", "cmd", "param", "-abc", "--option", "foo"},
-                new Dictionary<string, string>());
-
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+                new[] {"[preview]", "named", "param", "-abc", "--option", "foo"},
+                new Dictionary<string, string>()
+            );

            // Assert
            exitCode.Should().Be(0);
-            stdOutData.Should().ContainAll("cmd", "<param>", "[-a]", "[-b]", "[-c]", "[--option \"foo\"]");
+            stdOut.GetString().Should().ContainAll(
+                "named", "<param>", "[-a]", "[-b]", "[-c]", "[--option \"foo\"]"
+            );
+
+            _output.WriteLine(stdOut.GetString());
        }
    }
 }
--- a/CliFx.Tests/EnvironmentVariablesSpecs.Commands.cs
+++ b/CliFx.Tests/EnvironmentVariablesSpecs.Commands.cs
@@ -1,27 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class EnvironmentVariablesSpecs
-    {
-        [Command]
-        private class EnvironmentVariableCollectionCommand : ICommand
-        {
-            [CommandOption("opt", EnvironmentVariableName = "ENV_OPT")]
-            public IReadOnlyList<string>? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command]
-        private class EnvironmentVariableCommand : ICommand
-        {
-            [CommandOption("opt", EnvironmentVariableName = "ENV_OPT")]
-            public string? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/EnvironmentVariablesSpecs.cs
+++ b/CliFx.Tests/EnvironmentVariablesSpecs.cs
@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
-using CliFx.Domain;
+using CliFx.Tests.Commands;
 using CliFx.Tests.Internal;
 using CliWrap;
 using CliWrap.Buffered;
@@ -10,11 +10,11 @@ using Xunit;

 namespace CliFx.Tests
 {
-    public partial class EnvironmentVariablesSpecs
+    public class EnvironmentVariablesSpecs
    {
        // This test uses a real application to make sure environment variables are actually read correctly
        [Fact]
-        public async Task Option_can_use_a_specific_environment_variable_as_fallback()
+        public async Task Option_can_use_an_environment_variable_as_fallback()
        {
            // Arrange
            var command = Cli.Wrap("dotnet")
@@ -27,12 +27,12 @@ namespace CliFx.Tests
            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);

            // Assert
-            stdOut.TrimEnd().Should().Be("Hello Mars!");
+            stdOut.Trim().Should().Be("Hello Mars!");
        }

        // This test uses a real application to make sure environment variables are actually read correctly
        [Fact]
-        public async Task Option_only_uses_environment_variable_as_fallback_if_the_value_was_not_directly_provided()
+        public async Task Option_only_uses_an_environment_variable_as_fallback_if_the_value_is_not_directly_provided()
        {
            // Arrange
            var command = Cli.Wrap("dotnet")
@@ -47,46 +47,94 @@ namespace CliFx.Tests
            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);

            // Assert
-            stdOut.TrimEnd().Should().Be("Hello Jupiter!");
+            stdOut.Trim().Should().Be("Hello Jupiter!");
        }

        [Fact]
-        public void Option_of_non_scalar_type_can_take_multiple_separated_values_from_an_environment_variable()
+        public async Task Option_only_uses_an_environment_variable_as_fallback_if_the_name_matches_case_sensitively()
        {
-            // Arrange
-            var input = CommandInput.Empty;
-            var envVars = new Dictionary<string, string>
-            {
-                ["ENV_OPT"] = $"foo{Path.PathSeparator}bar"
-            };
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();

            // Act
-            var instance = CommandHelper.ResolveCommand<EnvironmentVariableCollectionCommand>(input, envVars);
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_opt_A"] = "incorrect",
+                    ["ENV_OPT_A"] = "correct"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();

            // Assert
-            instance.Should().BeEquivalentTo(new EnvironmentVariableCollectionCommand
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
            {
-                Option = new[] {"foo", "bar"}
+                OptA = "correct"
            });
        }

        [Fact]
-        public void Option_of_scalar_type_can_only_take_a_single_value_from_an_environment_variable_even_if_it_contains_separators()
+        public async Task Option_of_non_scalar_type_can_use_an_environment_variable_as_fallback_and_extract_multiple_values()
        {
-            // Arrange
-            var input = CommandInput.Empty;
-            var envVars = new Dictionary<string, string>
-            {
-                ["ENV_OPT"] = $"foo{Path.PathSeparator}bar"
-            };
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();

            // Act
-            var instance = CommandHelper.ResolveCommand<EnvironmentVariableCommand>(input, envVars);
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_OPT_B"] = $"foo{Path.PathSeparator}bar"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();

            // Assert
-            instance.Should().BeEquivalentTo(new EnvironmentVariableCommand
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
            {
-                Option = $"foo{Path.PathSeparator}bar"
+                OptB = new[] {"foo", "bar"}
+            });
+        }
+
+        [Fact]
+        public async Task Option_of_scalar_type_can_use_an_environment_variable_as_fallback_regardless_of_separators()
+        {
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnvironmentVariablesCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"cmd"},
+                new Dictionary<string, string>
+                {
+                    ["ENV_OPT_A"] = $"foo{Path.PathSeparator}bar"
+                }
+            );
+
+            var commandInstance = stdOut.GetString().DeserializeJson<WithEnvironmentVariablesCommand>();
+
+            // Assert
+            exitCode.Should().Be(0);
+            commandInstance.Should().BeEquivalentTo(new WithEnvironmentVariablesCommand
+            {
+                OptA = $"foo{Path.PathSeparator}bar"
            });
        }
    }
--- a/CliFx.Tests/ErrorReportingSpecs.Commands.cs
+++ b/CliFx.Tests/ErrorReportingSpecs.Commands.cs
@@ -1,34 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-using CliFx.Exceptions;
-
-namespace CliFx.Tests
-{
-    public partial class ErrorReportingSpecs
-    {
-        [Command("exc")]
-        private class GenericExceptionCommand : ICommand
-        {
-            [CommandOption("msg", 'm')]
-            public string? Message { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => throw new Exception(Message);
-        }
-
-        [Command("exc")]
-        private class CommandExceptionCommand : ICommand
-        {
-            [CommandOption("code", 'c')]
-            public int ExitCode { get; set; } = 133;
-
-            [CommandOption("msg", 'm')]
-            public string? Message { get; set; }
-
-            [CommandOption("show-help")]
-            public bool ShowHelp { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => throw new CommandException(Message, ExitCode, ShowHelp);
-        }
-    }
-}
--- a/CliFx.Tests/ErrorReportingSpecs.cs
+++ b/CliFx.Tests/ErrorReportingSpecs.cs
@@ -1,13 +1,12 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class ErrorReportingSpecs
+    public class ErrorReportingSpecs
    {
        private readonly ITestOutputHelper _output;

@@ -17,156 +16,159 @@ namespace CliFx.Tests
        public async Task Command_may_throw_a_generic_exception_which_exits_and_prints_error_message_and_stack_trace()
        {
            // Arrange
-            await using var stdErr = new MemoryStream();
-            var console = new VirtualConsole(error: stdErr);
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(GenericExceptionCommand))
+                .AddCommand<GenericExceptionCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"exc", "-m", "Kaput"},
-                new Dictionary<string, string>());
-
-            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "-m", "Kaput"});

            // Assert
            exitCode.Should().NotBe(0);
-            stdErrData.Should().ContainAll(
+            stdOut.GetString().Should().BeEmpty();
+            stdErr.GetString().Should().ContainAll(
                "System.Exception:",
                "Kaput", "at",
-                "CliFx.Tests");
+                "CliFx.Tests"
+            );

-            _output.WriteLine(stdErrData);
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
+        }
+
+        [Fact]
+        public async Task Command_may_throw_a_generic_exception_with_inner_exception_which_exits_and_prints_error_message_and_stack_trace()
+        {
+            // Arrange
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<GenericInnerExceptionCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"cmd", "-m", "Kaput", "-i", "FooBar"});
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdOut.GetString().Should().BeEmpty();
+            stdErr.GetString().Should().ContainAll(
+                "System.Exception:",
+                "FooBar",
+                "Kaput", "at",
+                "CliFx.Tests"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
        }

        [Fact]
        public async Task Command_may_throw_a_specialized_exception_which_exits_with_custom_code_and_prints_minimal_error_details()
        {
            // Arrange
-            await using var stdErr = new MemoryStream();
-            var console = new VirtualConsole(error: stdErr);
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CommandExceptionCommand))
+                .AddCommand<CommandExceptionCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"exc", "-m", "Kaput", "-c", "69"},
-                new Dictionary<string, string>());
-
-            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "-m", "Kaput", "-c", "69"});

            // Assert
            exitCode.Should().Be(69);
-            stdErrData.Should().Be("Kaput");
+            stdOut.GetString().Should().BeEmpty();
+            stdErr.GetString().Trim().Should().Be("Kaput");

-            _output.WriteLine(stdErrData);
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
        }

        [Fact]
        public async Task Command_may_throw_a_specialized_exception_without_error_message_which_exits_and_prints_full_error_details()
        {
            // Arrange
-            await using var stdErr = new MemoryStream();
-            var console = new VirtualConsole(error: stdErr);
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CommandExceptionCommand))
+                .AddCommand<CommandExceptionCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"exc"},
-                new Dictionary<string, string>());
-
-            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd"});

            // Assert
            exitCode.Should().NotBe(0);
-            stdErrData.Should().ContainAll(
+            stdOut.GetString().Should().BeEmpty();
+            stdErr.GetString().Should().ContainAll(
                "CliFx.Exceptions.CommandException:",
                "at",
-                "CliFx.Tests");
+                "CliFx.Tests"
+            );

-            _output.WriteLine(stdErrData);
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
        }

        [Fact]
        public async Task Command_may_throw_a_specialized_exception_which_exits_and_prints_help_text()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            await using var stdErr = new MemoryStream();
-
-            var console = new VirtualConsole(output: stdOut, error: stdErr);
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CommandExceptionCommand))
+                .AddCommand<CommandExceptionCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"exc", "-m", "Kaput", "--show-help"},
-                new Dictionary<string, string>());
-
-            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "-m", "Kaput", "--show-help"});

            // Assert
            exitCode.Should().NotBe(0);
-            stdErrData.Should().Be("Kaput");
-
-            stdOutData.Should().ContainAll(
+            stdOut.GetString().Should().ContainAll(
                "Usage",
                "Options",
-                "-h|--help", "Shows help text."
+                "-h|--help"
            );
+            stdErr.GetString().Trim().Should().Be("Kaput");

-            _output.WriteLine(stdErrData);
-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
        }

        [Fact]
        public async Task Command_shows_help_text_on_invalid_user_input()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            await using var stdErr = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut, error: stdErr);
+            var (console, stdOut, stdErr) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CommandExceptionCommand))
+                .AddCommand<DefaultCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"not-a-valid-command", "-r", "foo"},
-                new Dictionary<string, string>());
-
-            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"not-a-valid-command", "-r", "foo"});

            // Assert
            exitCode.Should().NotBe(0);
-            stdErrData.Should().NotBeNullOrWhiteSpace();
-
-            stdOutData.Should().ContainAll(
+            stdOut.GetString().Should().ContainAll(
                "Usage",
-                "[command]",
                "Options",
-                "-h|--help", "Shows help text."
+                "-h|--help"
            );
+            stdErr.GetString().Should().NotBeNullOrWhiteSpace();

-            _output.WriteLine(stdErrData);
-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
+            _output.WriteLine(stdErr.GetString());
        }
    }
 }
--- a/CliFx.Tests/HelpTextSpecs.Commands.cs
+++ b/CliFx.Tests/HelpTextSpecs.Commands.cs
@@ -1,155 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class HelpTextSpecs
-    {
-        [Command(Description = "DefaultCommand description.")]
-        private class DefaultCommand : ICommand
-        {
-            [CommandOption("option-a", 'a', Description = "OptionA description.")]
-            public string? OptionA { get; set; }
-
-            [CommandOption("option-b", 'b', Description = "OptionB description.")]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd", Description = "NamedCommand description.")]
-        private class NamedCommand : ICommand
-        {
-            [CommandParameter(0, Name = "param-a", Description = "ParameterA description.")]
-            public string? ParameterA { get; set; }
-
-            [CommandOption("option-c", 'c', Description = "OptionC description.")]
-            public string? OptionC { get; set; }
-
-            [CommandOption("option-d", 'd', Description = "OptionD description.")]
-            public string? OptionD { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd sub", Description = "NamedSubCommand description.")]
-        private class NamedSubCommand : ICommand
-        {
-            [CommandParameter(0, Name = "param-b", Description = "ParameterB description.")]
-            public string? ParameterB { get; set; }
-
-            [CommandParameter(1, Name = "param-c", Description = "ParameterC description.")]
-            public string? ParameterC { get; set; }
-
-            [CommandOption("option-e", 'e', Description = "OptionE description.")]
-            public string? OptionE { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd-with-params")]
-        private class ParametersCommand : ICommand
-        {
-            [CommandParameter(0, Name = "first")]
-            public string? ParameterA { get; set; }
-
-            [CommandParameter(10)]
-            public int? ParameterB { get; set; }
-
-            [CommandParameter(20, Description = "A list of numbers", Name = "third list")]
-            public IEnumerable<int>? ParameterC { get; set; }
-
-            [CommandOption("option", 'o')]
-            public string? Option { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd-with-req-opts")]
-        private class RequiredOptionsCommand : ICommand
-        {
-            [CommandOption("option-a", 'a', IsRequired = true)]
-            public string? OptionA { get; set; }
-
-            [CommandOption("option-b", 'b', IsRequired = true)]
-            public IEnumerable<int>? OptionB { get; set; }
-
-            [CommandOption("option-c", 'c')]
-            public string? OptionC { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd-with-enum-args")]
-        private class EnumArgumentsCommand : ICommand
-        {
-            public enum CustomEnum { Value1, Value2, Value3 };
-
-            [CommandParameter(0, Name = "value", Description = "Enum parameter.")]
-            public CustomEnum ParamA { get; set; }
-
-            [CommandOption("value", Description = "Enum option.", IsRequired = true)]
-            public CustomEnum OptionA { get; set; } = CustomEnum.Value1;
-
-            [CommandOption("nullable-value", Description = "Nullable enum option.")]
-            public CustomEnum? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd-with-env-vars")]
-        private class EnvironmentVariableCommand : ICommand
-        {
-            [CommandOption("option-a", 'a', IsRequired = true, EnvironmentVariableName = "ENV_OPT_A")]
-            public string? OptionA { get; set; }
-
-            [CommandOption("option-b", 'b', EnvironmentVariableName = "ENV_OPT_B")]
-            public string? OptionB { get; set; }
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Command("cmd-with-defaults")]
-        private class ArgumentsWithDefaultValuesCommand : ICommand
-        {
-            public enum CustomEnum { Value1, Value2, Value3 };
-
-            [CommandOption(nameof(Object))]
-            public object? Object { get; set; } = 42;
-
-            [CommandOption(nameof(String))]
-            public string? String { get; set; } = "foo";
-
-            [CommandOption(nameof(EmptyString))]
-            public string EmptyString { get; set; } = "";
-
-            [CommandOption(nameof(Bool))]
-            public bool Bool { get; set; } = true;
-
-            [CommandOption(nameof(Char))]
-            public char Char { get; set; } = 't';
-
-            [CommandOption(nameof(Int))]
-            public int Int { get; set; } = 1337;
-
-            [CommandOption(nameof(TimeSpan))]
-            public TimeSpan TimeSpan { get; set; } = TimeSpan.FromMinutes(123);
-
-            [CommandOption(nameof(Enum))]
-            public CustomEnum Enum { get; set; } = CustomEnum.Value2;
-
-            [CommandOption(nameof(IntNullable))]
-            public int? IntNullable { get; set; } = 1337;
-
-            [CommandOption(nameof(StringArray))]
-            public string[]? StringArray { get; set; } = { "foo", "bar", "baz" };
-
-            [CommandOption(nameof(IntArray))]
-            public int[]? IntArray { get; set; } = { 1, 2, 3 };
-
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-    }
-}
--- a/CliFx.Tests/HelpTextSpecs.cs
+++ b/CliFx.Tests/HelpTextSpecs.cs
@@ -1,334 +1,180 @@
-using System.IO;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class HelpTextSpecs
+    public class HelpTextSpecs
    {
        private readonly ITestOutputHelper _output;

        public HelpTextSpecs(ITestOutputHelper output) => _output = output;

-        [Fact]
-        public async Task Version_information_can_be_requested_by_providing_the_version_option_without_other_arguments()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(NamedCommand))
-                .AddCommand(typeof(NamedSubCommand))
-                .UseVersionText("v6.9")
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(new[] {"--version"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOutData.Should().Be("v6.9");
-
-            _output.WriteLine(stdOutData);
-        }
-
-        [Fact]
-        public async Task Help_text_can_be_requested_by_providing_the_help_option()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(NamedCommand))
-                .AddCommand(typeof(NamedSubCommand))
-                .UseTitle("AppTitle")
-                .UseVersionText("AppVer")
-                .UseDescription("AppDesc")
-                .UseExecutableName("AppExe")
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            await application.RunAsync(new[] {"--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            stdOutData.Should().ContainAll(
-                "AppTitle", "AppVer",
-                "AppDesc",
-                "Usage",
-                "AppExe", "[command]", "[options]",
-                "Options",
-                "-a|--option-a", "OptionA description.",
-                "-b|--option-b", "OptionB description.",
-                "-h|--help", "Shows help text.",
-                "--version", "Shows version information.",
-                "Commands",
-                "cmd", "NamedCommand description.",
-                "You can run", "to show help on a specific command."
-            );
-
-            _output.WriteLine(stdOutData);
-        }
-
-        [Fact]
-        public async Task Help_text_can_be_requested_on_a_specific_named_command()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(NamedCommand))
-                .AddCommand(typeof(NamedSubCommand))
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            await application.RunAsync(new[] {"cmd", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            stdOutData.Should().ContainAll(
-                "Description",
-                "NamedCommand description.",
-                "Usage",
-                "cmd", "[command]", "<param-a>", "[options]",
-                "Parameters",
-                "* param-a", "ParameterA description.",
-                "Options",
-                "-c|--option-c", "OptionC description.",
-                "-d|--option-d", "OptionD description.",
-                "-h|--help", "Shows help text.",
-                "Commands",
-                "sub", "SubCommand description.",
-                "You can run", "to show help on a specific command."
-            );
-
-            _output.WriteLine(stdOutData);
-        }
-
-        [Fact]
-        public async Task Help_text_can_be_requested_on_a_specific_named_sub_command()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(NamedCommand))
-                .AddCommand(typeof(NamedSubCommand))
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            await application.RunAsync(new[] {"cmd", "sub", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            stdOutData.Should().ContainAll(
-                "Description",
-                "SubCommand description.",
-                "Usage",
-                "cmd sub", "<param-b>", "<param-c>", "[options]",
-                "Parameters",
-                "* param-b", "ParameterB description.",
-                "* param-c", "ParameterC description.",
-                "Options",
-                "-e|--option-e", "OptionE description.",
-                "-h|--help", "Shows help text."
-            );
-
-            _output.WriteLine(stdOutData);
-        }
-
-        [Fact]
-        public async Task Help_text_can_be_requested_without_specifying_command_even_if_default_command_is_not_defined()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(NamedCommand))
-                .AddCommand(typeof(NamedSubCommand))
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            await application.RunAsync(new[] {"--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            stdOutData.Should().ContainAll(
-                "Usage",
-                "[command]",
-                "Options",
-                "-h|--help", "Shows help text.",
-                "--version", "Shows version information.",
-                "Commands",
-                "cmd", "NamedCommand description.",
-                "You can run", "to show help on a specific command."
-            );
-
-            _output.WriteLine(stdOutData);
-        }
-
        [Fact]
        public async Task Help_text_shows_usage_format_which_lists_all_parameters()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(ParametersCommand))
+                .AddCommand<WithParametersCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            await application.RunAsync(new[] {"cmd-with-params", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "--help"});

            // Assert
-            stdOutData.Should().ContainAll(
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Usage",
-                "cmd-with-params", "<first>", "<parameterb>", "<third list...>", "[options]"
+                "cmd", "<parama>", "<paramb>", "<paramc...>"
            );

-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
        }

        [Fact]
        public async Task Help_text_shows_usage_format_which_lists_all_required_options()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(RequiredOptionsCommand))
+                .AddCommand<WithRequiredOptionsCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            await application.RunAsync(new[] {"cmd-with-req-opts", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "--help"});

            // Assert
-            stdOutData.Should().ContainAll(
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Usage",
-                "cmd-with-req-opts", "--option-a <value>", "--option-b <values...>", "[options]",
+                "cmd", "--opt-a <value>", "--opt-c <values...>", "[options]",
                "Options",
-                "* -a|--option-a",
-                "* -b|--option-b",
-                "-c|--option-c"
+                "* -a|--opt-a",
+                "-b|--opt-b",
+                "* -c|--opt-c"
            );

-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
        }

        [Fact]
-        public async Task Help_text_lists_all_valid_values_for_enum_arguments()
+        public async Task Help_text_shows_usage_format_which_lists_available_sub_commands()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(EnumArgumentsCommand))
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            await application.RunAsync(new[] {"cmd-with-enum-args", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"--help"});

            // Assert
-            stdOutData.Should().ContainAll(
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Usage",
-                "cmd-with-enum-args", "[options]",
+                "... named",
+                "... named sub"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_shows_all_valid_values_for_enum_arguments()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<WithEnumArgumentsCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"cmd", "--help"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Parameters",
-                "value", "Valid values: \"Value1\", \"Value2\", \"Value3\".",
+                "enum", "Valid values: \"Value1\", \"Value2\", \"Value3\".",
                "Options",
-                "* --value", "Enum option.", "Valid values: \"Value1\", \"Value2\", \"Value3\".",
-                "--nullable-value", "Nullable enum option.", "Valid values: \"Value1\", \"Value2\", \"Value3\"."
+                "--enum", "Valid values: \"Value1\", \"Value2\", \"Value3\".",
+                "* --required-enum", "Valid values: \"Value1\", \"Value2\", \"Value3\"."
            );

-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
        }

        [Fact]
-        public async Task Help_text_lists_environment_variable_names_for_options_that_have_them_defined()
+        public async Task Help_text_shows_environment_variable_names_for_options_that_have_them_defined()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(EnvironmentVariableCommand))
+                .AddCommand<WithEnvironmentVariablesCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            await application.RunAsync(new[] {"cmd-with-env-vars", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "--help"});

            // Assert
-            stdOutData.Should().ContainAll(
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Options",
-                "* -a|--option-a", "Environment variable:", "ENV_OPT_A",
-                "-b|--option-b", "Environment variable:", "ENV_OPT_B"
+                "-a|--opt-a", "Environment variable:", "ENV_OPT_A",
+                "-b|--opt-b", "Environment variable:", "ENV_OPT_B"
            );

-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
        }

        [Fact]
        public async Task Help_text_shows_default_values_for_non_required_options()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(ArgumentsWithDefaultValuesCommand))
+                .AddCommand<WithDefaultValuesCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            await application.RunAsync(new[] {"cmd-with-defaults", "--help"});
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"cmd", "--help"});

            // Assert
-            stdOutData.Should().ContainAll(
-                "Usage",
-                "cmd-with-defaults", "[options]",
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
                "Options",
-                "--Object", "Default: \"42\"",
-                "--String", "Default: \"foo\"",
-                "--EmptyString", "Default: \"\"",
-                "--Bool", "Default: \"True\"",
-                "--Char", "Default: \"t\"",
-                "--Int", "Default: \"1337\"",
-                "--TimeSpan", "Default: \"02:03:00\"",
-                "--Enum", "Default: \"Value2\"",
-                "--IntNullable", "Default: \"1337\"",
-                "--StringArray", "Default: \"foo\" \"bar\" \"baz\"",
-                "--IntArray", "Default: \"1\" \"2\" \"3\""
+                "--obj", "Default: \"42\"",
+                "--str", "Default: \"foo\"",
+                "--str-empty", "Default: \"\"",
+                "--str-array", "Default: \"foo\" \"bar\" \"baz\"",
+                "--bool", "Default: \"True\"",
+                "--char", "Default: \"t\"",
+                "--int", "Default: \"1337\"",
+                "--int-nullable", "Default: \"1337\"",
+                "--int-array", "Default: \"1\" \"2\" \"3\"",
+                "--timespan", "Default: \"02:03:00\"",
+                "--enum", "Default: \"Value2\""
            );

-            _output.WriteLine(stdOutData);
+            _output.WriteLine(stdOut.GetString());
        }
    }
 }
--- a/CliFx.Tests/Internal/CommandHelper.cs
+++ b/CliFx.Tests/Internal/CommandHelper.cs
@@ -1,23 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Domain;
-
-namespace CliFx.Tests.Internal
-{
-    internal static class CommandHelper
-    {
-        public static TCommand ResolveCommand<TCommand>(CommandInput input, IReadOnlyDictionary<string, string> environmentVariables)
-            where TCommand : ICommand, new()
-        {
-            var schema = CommandSchema.TryResolve(typeof(TCommand))!;
-
-            var instance = new TCommand();
-            schema.Bind(instance, input, environmentVariables);
-
-            return instance;
-        }
-
-        public static TCommand ResolveCommand<TCommand>(CommandInput input)
-            where TCommand : ICommand, new() =>
-            ResolveCommand<TCommand>(input, new Dictionary<string, string>());
-    }
-}
--- a/CliFx.Tests/Internal/CommandInputBuilder.cs
+++ b/CliFx.Tests/Internal/CommandInputBuilder.cs
@@ -1,45 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Domain;
-
-namespace CliFx.Tests.Internal
-{
-    internal class CommandInputBuilder
-    {
-        private readonly List<CommandDirectiveInput> _directives = new List<CommandDirectiveInput>();
-        private readonly List<CommandParameterInput> _parameters = new List<CommandParameterInput>();
-        private readonly List<CommandOptionInput> _options = new List<CommandOptionInput>();
-
-        private string? _commandName;
-
-        public CommandInputBuilder SetCommandName(string commandName)
-        {
-            _commandName = commandName;
-            return this;
-        }
-
-        public CommandInputBuilder AddDirective(string directive)
-        {
-            _directives.Add(new CommandDirectiveInput(directive));
-            return this;
-        }
-
-        public CommandInputBuilder AddParameter(string parameter)
-        {
-            _parameters.Add(new CommandParameterInput(parameter));
-            return this;
-        }
-
-        public CommandInputBuilder AddOption(string alias, params string[] values)
-        {
-            _options.Add(new CommandOptionInput(alias, values));
-            return this;
-        }
-
-        public CommandInput Build() => new CommandInput(
-            _directives,
-            _commandName,
-            _parameters,
-            _options
-        );
-    }
-}
--- a/CliFx.Tests/Internal/JsonExtensions.cs
+++ b/CliFx.Tests/Internal/JsonExtensions.cs
@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace CliFx.Tests.Internal
+{
+    internal static class JsonExtensions
+    {
+        public static T DeserializeJson<T>(this string json) =>
+            JsonConvert.DeserializeObject<T>(json);
+    }
+}
--- a/CliFx.Tests/Internal/TaskExtensions.cs
+++ b/CliFx.Tests/Internal/TaskExtensions.cs
@@ -1,19 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace CliFx.Tests.Internal
-{
-    internal static class TaskExtensions
-    {
-        public static async Task IgnoreCancellation(this Task task)
-        {
-            try
-            {
-                await task;
-            }
-            catch (OperationCanceledException)
-            {
-            }
-        }
-    }
-}
--- a/CliFx.Tests/RoutingSpecs.Commands.cs
+++ b/CliFx.Tests/RoutingSpecs.Commands.cs
@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests
-{
-    public partial class RoutingSpecs
-    {
-        [Command]
-        private class DefaultCommand : ICommand
-        {
-            public ValueTask ExecuteAsync(IConsole console)
-            {
-                console.Output.WriteLine("Hello world!");
-                return default;
-            }
-        }
-
-        [Command("concat", Description = "Concatenate strings.")]
-        private class ConcatCommand : ICommand
-        {
-            [CommandOption('i', IsRequired = true, Description = "Input strings.")]
-            public IReadOnlyList<string> Inputs { get; set; } = Array.Empty<string>();
-
-            [CommandOption('s', Description = "String separator.")]
-            public string Separator { get; set; } = "";
-
-            public ValueTask ExecuteAsync(IConsole console)
-            {
-                console.Output.WriteLine(string.Join(Separator, Inputs));
-                return default;
-            }
-        }
-
-        [Command("div", Description = "Divide one number by another.")]
-        private class DivideCommand : ICommand
-        {
-            [CommandOption("dividend", 'D', IsRequired = true, Description = "The number to divide.")]
-            public double Dividend { get; set; } = 0;
-
-            [CommandOption("divisor", 'd', IsRequired = true, Description = "The number to divide by.")]
-            public double Divisor { get; set; } = 0;
-
-            public ValueTask ExecuteAsync(IConsole console)
-            {
-                console.Output.WriteLine(Dividend / Divisor);
-                return default;
-            }
-        }
-    }
-}
--- a/CliFx.Tests/RoutingSpecs.cs
+++ b/CliFx.Tests/RoutingSpecs.cs
@@ -1,90 +1,235 @@
 using System;
-using System.Collections.Generic;
-using System.IO;
 using System.Threading.Tasks;
+using CliFx.Tests.Commands;
 using FluentAssertions;
 using Xunit;
+using Xunit.Abstractions;

 namespace CliFx.Tests
 {
-    public partial class RoutingSpecs
+    public class RoutingSpecs
    {
+        private readonly ITestOutputHelper _output;
+
+        public RoutingSpecs(ITestOutputHelper testOutput) => _output = testOutput;
+
        [Fact]
        public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(ConcatCommand))
-                .AddCommand(typeof(DivideCommand))
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>());
-
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(Array.Empty<string>());

            // Assert
            exitCode.Should().Be(0);
-            stdOutData.Should().Be("Hello world!");
-        }
+            stdOut.GetString().Trim().Should().Be(DefaultCommand.ExpectedOutputText);

-        [Fact]
-        public async Task Help_text_is_printed_if_no_arguments_were_provided_and_default_command_is_not_defined()
-        {
-            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(ConcatCommand))
-                .AddCommand(typeof(DivideCommand))
-                .UseConsole(console)
-                .UseDescription("This will be visible in help")
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>());
-
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOutData.Should().Contain("This will be visible in help");
+            _output.WriteLine(stdOut.GetString());
        }

        [Fact]
        public async Task Specific_named_command_is_executed_if_provided_arguments_match_its_name()
        {
            // Arrange
-            await using var stdOut = new MemoryStream();
-            var console = new VirtualConsole(output: stdOut);
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();

            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(DefaultCommand))
-                .AddCommand(typeof(ConcatCommand))
-                .AddCommand(typeof(DivideCommand))
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
                .UseConsole(console)
                .Build();

            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"concat", "-i", "foo", "bar", "-s", ", "},
-                new Dictionary<string, string>());
-
-            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+            var exitCode = await application.RunAsync(new[] {"named"});

            // Assert
            exitCode.Should().Be(0);
-            stdOutData.Should().Be("foo, bar");
+            stdOut.GetString().Trim().Should().Be(NamedCommand.ExpectedOutputText);
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Specific_named_sub_command_is_executed_if_provided_arguments_match_its_name()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"named", "sub"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Trim().Should().Be(NamedSubCommand.ExpectedOutputText);
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_is_printed_if_no_arguments_were_provided_and_default_command_is_not_defined()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseConsole(console)
+                .UseDescription("This will be visible in help")
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(Array.Empty<string>());
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().Contain("This will be visible in help");
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_is_printed_if_provided_arguments_contain_the_help_option()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"--help"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
+                "Default command description",
+                "Usage"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_is_printed_if_provided_arguments_contain_the_help_option_even_if_default_command_is_not_defined()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseDescription("This will be visible in help")
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"--help"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().Contain("This will be visible in help");
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_for_a_specific_named_command_is_printed_if_provided_arguments_match_its_name_and_contain_the_help_option()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"named", "--help"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
+                "Named command description",
+                "Usage",
+                "named"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Help_text_for_a_specific_named_sub_command_is_printed_if_provided_arguments_match_its_name_and_contain_the_help_option()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"named", "sub", "--help"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Should().ContainAll(
+                "Named sub command description",
+                "Usage",
+                "named", "sub"
+            );
+
+            _output.WriteLine(stdOut.GetString());
+        }
+
+        [Fact]
+        public async Task Version_is_printed_if_the_only_provided_argument_is_the_version_option()
+        {
+            // Arrange
+            var (console, stdOut, _) = VirtualConsole.CreateBuffered();
+
+            var application = new CliApplicationBuilder()
+                .AddCommand<DefaultCommand>()
+                .AddCommand<NamedCommand>()
+                .AddCommand<NamedSubCommand>()
+                .UseVersionText("v6.9")
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"--version"});
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.GetString().Trim().Should().Be("v6.9");
+
+            _output.WriteLine(stdOut.GetString());
        }
    }
 }
--- a/CliFx.props
+++ b/CliFx.props
@@ -1,11 +1,12 @@
 <Project>

  <PropertyGroup>
-    <Version>1.3.1</Version>
+    <Version>1.6</Version>
    <Company>Tyrrrz</Company>
    <Copyright>Copyright (C) Alexey Golub</Copyright>
    <LangVersion>latest</LangVersion>
    <Nullable>enable</Nullable>
+    <WarningsAsErrors>nullable</WarningsAsErrors>
  </PropertyGroup>

 </Project>
--- a/CliFx/ApplicationMetadata.cs
+++ b/CliFx/ApplicationMetadata.cs
@@ -28,7 +28,11 @@
        /// <summary>
        /// Initializes an instance of <see cref="ApplicationMetadata"/>.
        /// </summary>
-        public ApplicationMetadata(string title, string executableName, string versionText, string? description)
+        public ApplicationMetadata(
+            string title,
+            string executableName,
+            string versionText,
+            string? description)
        {
            Title = title;
            ExecutableName = executableName;
--- a/CliFx/ArgumentValueConverter.cs
+++ b/CliFx/ArgumentValueConverter.cs
@@ -0,0 +1,30 @@
+namespace CliFx
+{
+    /// <summary>
+    /// Implements custom conversion logic that maps an argument value to a domain type.
+    /// </summary>
+    /// <remarks>
+    /// This type is public for legacy reasons.
+    /// Please derive from <see cref="ArgumentValueConverter{T}"/> instead.
+    /// </remarks>
+    public interface IArgumentValueConverter
+    {
+        /// <summary>
+        /// Converts an input value to object of required type.
+        /// </summary>
+        public object ConvertFrom(string value);
+    }
+
+    /// <summary>
+    /// A base type for custom argument converters.
+    /// </summary>
+    public abstract class ArgumentValueConverter<T> : IArgumentValueConverter
+    {
+        /// <summary>
+        /// Converts an input value to object of required type.
+        /// </summary>
+        public abstract T ConvertFrom(string value);
+
+        object IArgumentValueConverter.ConvertFrom(string value) => ConvertFrom(value)!;
+    }
+}
--- a/CliFx/ArgumentValueValidator.cs
+++ b/CliFx/ArgumentValueValidator.cs
@@ -0,0 +1,55 @@
+namespace CliFx
+{
+    /// <summary>
+    /// Represents a result of a validation.
+    /// </summary>
+    public partial class ValidationResult
+    {
+        /// <summary>
+        /// Whether validation was successful.
+        /// </summary>
+        public bool IsValid => ErrorMessage == null;
+
+        /// <summary>
+        /// If validation has failed, contains the associated error, otherwise null.
+        /// </summary>
+        public string? ErrorMessage { get; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="ValidationResult"/>.
+        /// </summary>
+        public ValidationResult(string? errorMessage = null) =>
+            ErrorMessage = errorMessage;
+    }
+
+    public partial class ValidationResult
+    {
+        /// <summary>
+        /// Creates successful result, meaning that the validation has passed.
+        /// </summary>
+        public static ValidationResult Ok() => new ValidationResult();
+
+        /// <summary>
+        /// Creates an error result, meaning that the validation has failed.
+        /// </summary>
+        public static ValidationResult Error(string message) => new ValidationResult(message);
+    }
+
+    internal interface IArgumentValueValidator
+    {
+        ValidationResult Validate(object value);
+    }
+
+    /// <summary>
+    /// A base type for custom argument validators.
+    /// </summary>
+    public abstract class ArgumentValueValidator<T> : IArgumentValueValidator
+    {
+        /// <summary>
+        /// Validates the value.
+        /// </summary>
+        public abstract ValidationResult Validate(T value);
+
+        ValidationResult IArgumentValueValidator.Validate(object value) => Validate((T) value);
+    }
+}
--- a/CliFx/Attributes/CommandArgumentAttribute.cs
+++ b/CliFx/Attributes/CommandArgumentAttribute.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace CliFx.Attributes
+{
+    /// <summary>
+    /// Properties shared by parameter and option arguments.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public abstract class CommandArgumentAttribute : Attribute
+    {
+        /// <summary>
+        /// Option description, which is used in help text.
+        /// </summary>
+        public string? Description { get; set; }
+
+        /// <summary>
+        /// Type of converter to use when mapping the argument value.
+        /// Converter must derive from <see cref="ArgumentValueConverter{T}"/>.
+        /// </summary>
+        public Type? Converter { get; set; }
+
+        /// <summary>
+        /// Types of validators to use when mapping the argument value.
+        /// Validators must derive from <see cref="ArgumentValueValidator{T}"/>.
+        /// </summary>
+        public Type[] Validators { get; set; } = Array.Empty<Type>();
+    }
+}
--- a/CliFx/Attributes/CommandOptionAttribute.cs
+++ b/CliFx/Attributes/CommandOptionAttribute.cs
@@ -6,7 +6,7 @@ namespace CliFx.Attributes
    /// Annotates a property that defines a command option.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
-    public class CommandOptionAttribute : Attribute
+    public class CommandOptionAttribute : CommandArgumentAttribute
    {
        /// <summary>
        /// Option name (must be longer than a single character).
@@ -27,11 +27,6 @@ namespace CliFx.Attributes
        /// </summary>
        public bool IsRequired { get; set; }

-        /// <summary>
-        /// Option description, which is used in help text.
-        /// </summary>
-        public string? Description { get; set; }
-
        /// <summary>
        /// Environment variable that will be used as fallback if no option value is specified.
        /// </summary>
--- a/CliFx/Attributes/CommandParameterAttribute.cs
+++ b/CliFx/Attributes/CommandParameterAttribute.cs
@@ -6,7 +6,7 @@ namespace CliFx.Attributes
    /// Annotates a property that defines a command parameter.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
-    public class CommandParameterAttribute : Attribute
+    public class CommandParameterAttribute : CommandArgumentAttribute
    {
        /// <summary>
        /// Order of this parameter compared to other parameters.
@@ -21,11 +21,6 @@ namespace CliFx.Attributes
        /// </summary>
        public string? Name { get; set; }

-        /// <summary>
-        /// Parameter description, which is used in help text.
-        /// </summary>
-        public string? Description { get; set; }
-
        /// <summary>
        /// Initializes an instance of <see cref="CommandParameterAttribute"/>.
        /// </summary>
--- a/CliFx/CliApplication.cs
+++ b/CliFx/CliApplication.cs
@@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
 using CliFx.Attributes;
@@ -38,9 +39,6 @@ namespace CliFx
            _helpTextWriter = new HelpTextWriter(metadata, console);
        }

-        private void WriteError(string message) => _console.WithForegroundColor(ConsoleColor.Red, () =>
-            _console.Error.WriteLine(message));
-
        private async ValueTask LaunchAndWaitForDebuggerAsync()
        {
            var processId = ProcessEx.GetCurrentProcessId();
@@ -51,7 +49,9 @@ namespace CliFx
            Debugger.Launch();

            while (!Debugger.IsAttached)
+            {
                await Task.Delay(100);
+            }
        }

        private void WriteCommandLineInput(CommandInput input)
@@ -103,9 +103,9 @@ namespace CliFx
        }

        private ICommand GetCommandInstance(CommandSchema command) =>
-            command != StubDefaultCommand.Schema
+            command != FallbackDefaultCommand.Schema
                ? (ICommand) _typeActivator.CreateInstance(command.Type)
-                : new StubDefaultCommand();
+                : new FallbackDefaultCommand();

        /// <summary>
        /// Runs the application with specified command line arguments and environment variables, and returns the exit code.
@@ -141,7 +141,7 @@ namespace CliFx
                var command =
                    root.TryFindCommand(input.CommandName) ??
                    root.TryFindDefaultCommand() ??
-                    StubDefaultCommand.Schema;
+                    FallbackDefaultCommand.Schema;

                // Version option
                if (command.IsVersionOptionAvailable && input.IsVersionOptionSpecified)
@@ -159,7 +159,7 @@ namespace CliFx

                // Help option
                if (command.IsHelpOptionAvailable && input.IsHelpOptionSpecified ||
-                    command == StubDefaultCommand.Schema && !input.Parameters.Any() && !input.Options.Any())
+                    command == FallbackDefaultCommand.Schema && !input.Parameters.Any() && !input.Options.Any())
                {
                    _helpTextWriter.Write(root, command, defaultValues);
                    return ExitCode.Success;
@@ -173,7 +173,10 @@ namespace CliFx
                // This may throw exceptions which are useful only to the end-user
                catch (CliFxException ex)
                {
-                    WriteError(ex.ToString());
+                    _console.WithForegroundColor(ConsoleColor.Red, () =>
+                        _console.Error.WriteLine(ex.ToString())
+                    );
+
                    _helpTextWriter.Write(root, command, defaultValues);

                    return ExitCode.FromException(ex);
@@ -188,10 +191,14 @@ namespace CliFx
                // Swallow command exceptions and route them to the console
                catch (CommandException ex)
                {
-                    WriteError(ex.ToString());
+                    _console.WithForegroundColor(ConsoleColor.Red, () =>
+                        _console.Error.WriteLine(ex.ToString())
+                    );

                    if (ex.ShowHelp)
+                    {
                        _helpTextWriter.Write(root, command, defaultValues);
+                    }

                    return ex.ExitCode;
                }
@@ -202,7 +209,13 @@ namespace CliFx
            // because we still want the IDE to show them to the developer.
            catch (Exception ex) when (!Debugger.IsAttached)
            {
-                WriteError(ex.ToString());
+                _console.WithColors(ConsoleColor.White, ConsoleColor.DarkRed, () =>
+                    _console.Error.Write("ERROR:")
+                );
+
+                _console.Error.Write(" ");
+                _console.WriteException(ex);
+
                return ExitCode.FromException(ex);
            }
        }
@@ -218,9 +231,10 @@ namespace CliFx
        /// </remarks>
        public async ValueTask<int> RunAsync(IReadOnlyList<string> commandLineArguments)
        {
+            // Environment variable names are case-insensitive on Windows but are case-sensitive on Linux and macOS
            var environmentVariables = Environment.GetEnvironmentVariables()
                .Cast<DictionaryEntry>()
-                .ToDictionary(e => (string) e.Key, e => (string) e.Value, StringComparer.OrdinalIgnoreCase);
+                .ToDictionary(e => (string) e.Key, e => (string) e.Value, StringComparer.Ordinal);

            return await RunAsync(commandLineArguments, environmentVariables);
        }
@@ -256,11 +270,14 @@ namespace CliFx
                    : 1;
        }

+        // Fallback default command used when none is defined in the application
        [Command]
-        private class StubDefaultCommand : ICommand
+        private class FallbackDefaultCommand : ICommand
        {
-            public static CommandSchema Schema { get; } = CommandSchema.TryResolve(typeof(StubDefaultCommand))!;
+            public static CommandSchema Schema { get; } = CommandSchema.TryResolve(typeof(FallbackDefaultCommand))!;

+            // Never actually executed
+            [ExcludeFromCodeCoverage]
            public ValueTask ExecuteAsync(IConsole console) => default;
        }
    }
--- a/CliFx/CliApplicationBuilder.cs
+++ b/CliFx/CliApplicationBuilder.cs
@@ -34,6 +34,12 @@ namespace CliFx
            return this;
        }

+        /// <summary>
+        /// Adds a command of specified type to the application.
+        /// </summary>
+        public CliApplicationBuilder AddCommand<TCommand>() where TCommand : ICommand =>
+            AddCommand(typeof(TCommand));
+
        /// <summary>
        /// Adds multiple commands to the application.
        /// </summary>
@@ -159,9 +165,9 @@ namespace CliFx
        /// </summary>
        public CliApplication Build()
        {
-            _title ??= TryGetDefaultTitle() ?? "App";
-            _executableName ??= TryGetDefaultExecutableName() ?? "app";
-            _versionText ??= TryGetDefaultVersionText() ?? "v1.0";
+            _title ??= GetDefaultTitle();
+            _executableName ??= GetDefaultExecutableName();
+            _versionText ??= GetDefaultVersionText();
            _console ??= new SystemConsole();
            _typeActivator ??= new DefaultTypeActivator();

@@ -179,23 +185,29 @@ namespace CliFx
        // Entry assembly is null in tests
        private static Assembly? EntryAssembly => LazyEntryAssembly.Value;

-        private static string? TryGetDefaultTitle() => EntryAssembly?.GetName().Name;
+        private static string GetDefaultTitle() => EntryAssembly?.GetName().Name?? "App";

-        private static string? TryGetDefaultExecutableName()
+        private static string GetDefaultExecutableName()
        {
            var entryAssemblyLocation = EntryAssembly?.Location;

            // The assembly can be an executable or a dll, depending on how it was packaged
-            var isDll = string.Equals(Path.GetExtension(entryAssemblyLocation), ".dll", StringComparison.OrdinalIgnoreCase);
+            var isDll = string.Equals(
+                Path.GetExtension(entryAssemblyLocation),
+                ".dll",
+                StringComparison.OrdinalIgnoreCase
+            );

-            return isDll
+            var name = isDll
                ? "dotnet " + Path.GetFileName(entryAssemblyLocation)
                : Path.GetFileNameWithoutExtension(entryAssemblyLocation);
+
+            return name ?? "app";
        }

-        private static string? TryGetDefaultVersionText() =>
+        private static string GetDefaultVersionText() =>
            EntryAssembly != null
                ? $"v{EntryAssembly.GetName().Version.ToSemanticString()}"
-                : null;
+                : "v1.0";
    }
 }
--- a/CliFx/CliFx.csproj
+++ b/CliFx/CliFx.csproj
@@ -24,26 +24,16 @@
  </PropertyGroup>

  <ItemGroup>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
-      <_Parameter1>$(AssemblyName).Tests</_Parameter1>
-    </AssemblyAttribute>
-    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
-      <_Parameter1>$(AssemblyName).Analyzers</_Parameter1>
-    </AssemblyAttribute>
+    <None Include="../favicon.png" Pack="true" PackagePath="" />
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="all" />
-    <PackageReference Include="Nullable" Version="1.2.1" PrivateAssets="all" />
+    <PackageReference Include="Nullable" Version="1.3.0" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.3" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <None Include="../favicon.png" Pack="true" PackagePath="" />
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
  </ItemGroup>

  <!-- The following item group and target ensure that the analyzer project is copied into the output NuGet package -->
--- a/CliFx/DefaultTypeActivator.cs
+++ b/CliFx/DefaultTypeActivator.cs
@@ -1,5 +1,6 @@
 using System;
 using CliFx.Exceptions;
+using CliFx.Internal.Extensions;

 namespace CliFx
 {
@@ -13,7 +14,7 @@ namespace CliFx
        {
            try
            {
-                return Activator.CreateInstance(type);
+                return type.CreateInstance();
            }
            catch (Exception ex)
            {
--- a/CliFx/Domain/CommandArgumentSchema.cs
+++ b/CliFx/Domain/CommandArgumentSchema.cs
@@ -17,49 +17,71 @@ namespace CliFx.Domain

        public bool IsScalar => TryGetEnumerableArgumentUnderlyingType() == null;

-        protected CommandArgumentSchema(PropertyInfo? property, string? description)
+        public Type? ConverterType { get; }
+
+        public Type[] ValidatorTypes { get; }
+
+        protected CommandArgumentSchema(
+            PropertyInfo? property,
+            string? description,
+            Type? converterType,
+            Type[] validatorTypes)
        {
            Property = property;
            Description = description;
+            ConverterType = converterType;
+            ValidatorTypes = validatorTypes;
        }

        private Type? TryGetEnumerableArgumentUnderlyingType() =>
            Property != null && Property.PropertyType != typeof(string)
-                ? Property.PropertyType.GetEnumerableUnderlyingType()
+                ? Property.PropertyType.TryGetEnumerableUnderlyingType()
                : null;

        private object? ConvertScalar(string? value, Type targetType)
        {
            try
            {
-                // Primitive
+                // Custom conversion (always takes highest priority)
+                if (ConverterType != null)
+                    return ConverterType.CreateInstance<IArgumentValueConverter>().ConvertFrom(value!);
+
+                // No conversion necessary
+                if (targetType == typeof(object) || targetType == typeof(string))
+                    return value;
+
+                // Bool conversion (special case)
+                if (targetType == typeof(bool))
+                    return string.IsNullOrWhiteSpace(value) || bool.Parse(value);
+
+                // Primitive conversion
                var primitiveConverter = PrimitiveConverters.GetValueOrDefault(targetType);
-                if (primitiveConverter != null)
+                if (primitiveConverter != null && !string.IsNullOrWhiteSpace(value))
                    return primitiveConverter(value);

-                // Enum
-                if (targetType.IsEnum)
+                // Enum conversion
+                if (targetType.IsEnum && !string.IsNullOrWhiteSpace(value))
                    return Enum.Parse(targetType, value, true);

-                // Nullable
-                var nullableUnderlyingType = targetType.GetNullableUnderlyingType();
+                // Nullable<T> conversion
+                var nullableUnderlyingType = targetType.TryGetNullableUnderlyingType();
                if (nullableUnderlyingType != null)
                    return !string.IsNullOrWhiteSpace(value)
                        ? ConvertScalar(value, nullableUnderlyingType)
                        : null;

-                // String-constructable
+                // String-constructible conversion
                var stringConstructor = targetType.GetConstructor(new[] {typeof(string)});
                if (stringConstructor != null)
                    return stringConstructor.Invoke(new object[] {value!});

-                // String-parseable (with format provider)
-                var parseMethodWithFormatProvider = targetType.GetStaticParseMethod(true);
+                // String-parseable conversion (with format provider)
+                var parseMethodWithFormatProvider = targetType.TryGetStaticParseMethod(true);
                if (parseMethodWithFormatProvider != null)
                    return parseMethodWithFormatProvider.Invoke(null, new object[] {value!, FormatProvider});

-                // String-parseable (without format provider)
-                var parseMethod = targetType.GetStaticParseMethod();
+                // String-parseable conversion (without format provider)
+                var parseMethod = targetType.TryGetStaticParseMethod();
                if (parseMethod != null)
                    return parseMethod.Invoke(null, new object[] {value!});
            }
@@ -71,7 +93,10 @@ namespace CliFx.Domain
            throw CliFxException.CannotConvertToType(this, value, targetType);
        }

-        private object ConvertNonScalar(IReadOnlyList<string> values, Type targetEnumerableType, Type targetElementType)
+        private object ConvertNonScalar(
+            IReadOnlyList<string> values,
+            Type targetEnumerableType,
+            Type targetElementType)
        {
            var array = values
                .Select(v => ConvertScalar(v, targetElementType))
@@ -83,7 +108,7 @@ namespace CliFx.Domain
            if (targetEnumerableType.IsAssignableFrom(arrayType))
                return array;

-            // Constructable from an array
+            // Constructible from an array
            var arrayConstructor = targetEnumerableType.GetConstructor(new[] {arrayType});
            if (arrayConstructor != null)
                return arrayConstructor.Invoke(new object[] {array});
@@ -114,8 +139,31 @@ namespace CliFx.Domain
            }
        }

-        public void BindOn(ICommand command, IReadOnlyList<string> values) =>
-            Property?.SetValue(command, Convert(values));
+        private void Validate(object? value)
+        {
+            if (value is null)
+                return;
+
+            var validators = ValidatorTypes
+                .Select(t => t.CreateInstance<IArgumentValueValidator>())
+                .ToArray();
+
+            var failedValidations = validators
+                .Select(v => v.Validate(value))
+                .Where(result => !result.IsValid)
+                .ToArray();
+
+            if (failedValidations.Any())
+                throw CliFxException.ValidationFailed(this, failedValidations);
+        }
+
+        public void BindOn(ICommand command, IReadOnlyList<string> values)
+        {
+            var value = Convert(values);
+            Validate(value);
+
+            Property?.SetValue(command, value);
+        }

        public void BindOn(ICommand command, params string[] values) =>
            BindOn(command, (IReadOnlyList<string>) values);
@@ -126,7 +174,7 @@ namespace CliFx.Domain
                return Array.Empty<string>();

            var underlyingType =
-                Property.PropertyType.GetNullableUnderlyingType() ??
+                Property.PropertyType.TryGetNullableUnderlyingType() ??
                Property.PropertyType;

            // Enum
@@ -141,12 +189,9 @@ namespace CliFx.Domain
    {
        private static readonly IFormatProvider FormatProvider = CultureInfo.InvariantCulture;

-        private static readonly IReadOnlyDictionary<Type, Func<string?, object?>> PrimitiveConverters =
-            new Dictionary<Type, Func<string?, object?>>
+        private static readonly IReadOnlyDictionary<Type, Func<string, object?>> PrimitiveConverters =
+            new Dictionary<Type, Func<string, object?>>
            {
-                [typeof(object)] = v => v,
-                [typeof(string)] = v => v,
-                [typeof(bool)] = v => string.IsNullOrWhiteSpace(v) || bool.Parse(v),
                [typeof(char)] = v => v.Single(),
                [typeof(sbyte)] = v => sbyte.Parse(v, FormatProvider),
                [typeof(byte)] = v => byte.Parse(v, FormatProvider),
--- a/CliFx/Domain/CommandDirectiveInput.cs
+++ b/CliFx/Domain/CommandDirectiveInput.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;

 namespace CliFx.Domain
 {
@@ -12,6 +13,7 @@ namespace CliFx.Domain

        public CommandDirectiveInput(string name) => Name = name;

+        [ExcludeFromCodeCoverage]
        public override string ToString() => $"[{Name}]";
    }
 }
--- a/CliFx/Domain/CommandInput.cs
+++ b/CliFx/Domain/CommandInput.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using CliFx.Internal.Extensions;
@@ -36,6 +37,7 @@ namespace CliFx.Domain
            Options = options;
        }

+        [ExcludeFromCodeCoverage]
        public override string ToString()
        {
            var buffer = new StringBuilder();
@@ -136,7 +138,16 @@ namespace CliFx.Domain
            {
                var argument = commandLineArguments[index];

-                if (argument.StartsWith('-'))
+                var isOptionArgument =
+                    argument.StartsWith("--", StringComparison.OrdinalIgnoreCase) &&
+                    argument.Length > 2 &&
+                    char.IsLetter(argument[2]) ||
+                    argument.StartsWith('-') &&
+                    argument.Length > 1 &&
+                    char.IsLetter(argument[1]);
+
+                // Break on the first encountered option
+                if (isOptionArgument)
                    break;

                result.Add(new CommandParameterInput(argument));
@@ -159,7 +170,9 @@ namespace CliFx.Domain
                var argument = commandLineArguments[index];

                // Name
-                if (argument.StartsWith("--", StringComparison.Ordinal))
+                if (argument.StartsWith("--", StringComparison.Ordinal) &&
+                    argument.Length > 2 &&
+                    char.IsLetter(argument[2]))
                {
                    // Flush previous
                    if (!string.IsNullOrWhiteSpace(currentOptionAlias))
@@ -169,7 +182,9 @@ namespace CliFx.Domain
                    currentOptionValues = new List<string>();
                }
                // Short name
-                else if (argument.StartsWith('-'))
+                else if (argument.StartsWith('-') &&
+                         argument.Length > 1 &&
+                         char.IsLetter(argument[1]))
                {
                    foreach (var alias in argument.Substring(1))
                    {
--- a/CliFx/Domain/CommandOptionInput.cs
+++ b/CliFx/Domain/CommandOptionInput.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using CliFx.Internal.Extensions;

@@ -29,6 +30,7 @@ namespace CliFx.Domain

        public string GetRawValues() => Values.Select(v => v.Quote()).JoinToString(" ");

+        [ExcludeFromCodeCoverage]
        public override string ToString() => $"{GetRawAlias()} {GetRawValues()}";
    }
 }
--- a/CliFx/Domain/CommandOptionSchema.cs
+++ b/CliFx/Domain/CommandOptionSchema.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using System.Text;
@@ -22,8 +23,10 @@ namespace CliFx.Domain
            char? shortName,
            string? environmentVariableName,
            bool isRequired,
-            string? description)
-            : base(property, description)
+            string? description,
+            Type? converterType,
+            Type[] validatorTypes)
+            : base(property, description, converterType, validatorTypes)
        {
            Name = name;
            ShortName = shortName;
@@ -45,7 +48,7 @@ namespace CliFx.Domain

        public bool MatchesEnvironmentVariableName(string environmentVariableName) =>
            !string.IsNullOrWhiteSpace(EnvironmentVariableName) &&
-            string.Equals(EnvironmentVariableName, environmentVariableName, StringComparison.OrdinalIgnoreCase);
+            string.Equals(EnvironmentVariableName, environmentVariableName, StringComparison.Ordinal);

        public string GetUserFacingDisplayString()
        {
@@ -75,6 +78,7 @@ namespace CliFx.Domain

        public string GetInternalDisplayString() => $"{Property?.Name ?? "<implicit>"} ('{GetUserFacingDisplayString()}')";

+        [ExcludeFromCodeCoverage]
        public override string ToString() => GetInternalDisplayString();
    }

@@ -95,17 +99,35 @@ namespace CliFx.Domain
                attribute.ShortName,
                attribute.EnvironmentVariableName,
                attribute.IsRequired,
-                attribute.Description
+                attribute.Description,
+                attribute.Converter,
+                attribute.Validators
            );
        }
    }

    internal partial class CommandOptionSchema
    {
-        public static CommandOptionSchema HelpOption { get; } =
-            new CommandOptionSchema(null, "help", 'h', null, false, "Shows help text.");
+        public static CommandOptionSchema HelpOption { get; } = new CommandOptionSchema(
+            null,
+            "help",
+            'h',
+            null,
+            false,
+            "Shows help text.",
+            null,
+            Array.Empty<Type>()
+        );

-        public static CommandOptionSchema VersionOption { get; } =
-            new CommandOptionSchema(null, "version", null, null, false, "Shows version information.");
+        public static CommandOptionSchema VersionOption { get; } = new CommandOptionSchema(
+            null,
+            "version",
+            null,
+            null,
+            false,
+            "Shows version information.",
+            null,
+            Array.Empty<Type>()
+        );
    }
 }
--- a/CliFx/Domain/CommandParameterInput.cs
+++ b/CliFx/Domain/CommandParameterInput.cs
@@ -1,4 +1,6 @@
-namespace CliFx.Domain
+using System.Diagnostics.CodeAnalysis;
+
+namespace CliFx.Domain
 {
    internal class CommandParameterInput
    {
@@ -6,6 +8,7 @@

        public CommandParameterInput(string value) => Value = value;

+        [ExcludeFromCodeCoverage]
        public override string ToString() => Value;
    }
 }
--- a/CliFx/Domain/CommandParameterSchema.cs
+++ b/CliFx/Domain/CommandParameterSchema.cs
@@ -1,4 +1,6 @@
-using System.Reflection;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using System.Text;
 using CliFx.Attributes;

@@ -10,8 +12,14 @@ namespace CliFx.Domain

        public string Name { get; }

-        public CommandParameterSchema(PropertyInfo? property, int order, string name, string? description)
-            : base(property, description)
+        public CommandParameterSchema(
+            PropertyInfo? property,
+            int order,
+            string name,
+            string? description,
+            Type? converterType,
+            Type[] validatorTypes)
+            : base(property, description, converterType, validatorTypes)
        {
            Order = order;
            Name = name;
@@ -31,6 +39,7 @@ namespace CliFx.Domain

        public string GetInternalDisplayString() => $"{Property?.Name ?? "<implicit>"} ([{Order}] {GetUserFacingDisplayString()})";

+        [ExcludeFromCodeCoverage]
        public override string ToString() => GetInternalDisplayString();
    }

@@ -48,7 +57,9 @@ namespace CliFx.Domain
                property,
                attribute.Order,
                name,
-                attribute.Description
+                attribute.Description,
+                attribute.Converter,
+                attribute.Validators
            );
        }
    }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tyrrrz	90a01e729b	Update version	2020-12-06 18:42:58 +02:00
Tyrrrz	ac01c2aecb	Allow dashes to appear in parameter values	2020-12-06 18:39:03 +02:00
Tyrrrz	4acffe925c	Revert help text changes in the command section Not happy with how it looks right now. Confusing to the user.	2020-12-06 18:24:30 +02:00
Tyrrrz	18f53eeeef	Simplify gitignore and remove gitattributes	2020-12-06 17:58:02 +02:00
Tyrrrz	03d6942540	Require options to begin with a letter character Fixes #88	2020-11-29 17:14:23 +02:00
Tyrrrz	9be811a89a	Refactor ArgumentValueConverter into a class	2020-11-18 18:37:20 +02:00
Tyrrrz	f9f5a4696b	Add analyzers for invalid validators	2020-11-18 18:26:04 +02:00
Tyrrrz	d6da687170	Refactor recent PRs	2020-11-18 18:00:43 +02:00
Tyrrrz	eba66d0878	Simplify coverage collection	2020-11-11 01:20:08 +02:00
Tyrrrz	8c682766bd	Bump target frameworks on peripheral projects	2020-11-10 23:44:51 +02:00
Tyrrrz	39d626c8d8	Update build infra	2020-11-10 23:30:36 +02:00
Alexey Golub	a338ac8ce2	Custom value validators (#87 )	2020-11-09 17:21:18 +02:00
Oleksandr Shustov	11637127cb	remove redundant space	2020-11-08 20:01:47 +02:00
Oleksandr Shustov	4e12aefafb	add tests	2020-11-07 21:46:32 +02:00
Oleksandr Shustov	144d3592fb	cleanup after merge	2020-11-07 21:34:12 +02:00
Oleksandr Shustov	6f82c2f0f9	merge branch master into feature/custom-validators	2020-11-07 21:18:34 +02:00
Oleksandr Shustov	b8c60717d5	add a base type for custom validators	2020-11-06 20:37:46 +02:00
Rene Escalante	fec6850c39	Change format for the command section in help text (#83 )	2020-10-29 20:31:03 +02:00
Tyrrrz	6a378ad946	Update nuget packages	2020-10-27 17:20:07 +02:00
Tyrrrz	11579f11b1	Update readme	2020-10-25 01:55:12 +03:00
Tyrrrz	60a3b26fd1	Update version	2020-10-23 23:46:57 +03:00
Tyrrrz	3abdfb1acf	Improve child command usage info in help text	2020-10-23 23:36:36 +03:00
Tyrrrz	9557d386e2	Better success check in stack trace parsing	2020-10-23 23:00:29 +03:00
Tyrrrz	d0d024c427	Improve stack trace parsing	2020-10-23 22:57:48 +03:00
Tyrrrz	f765af6061	Update readme with info about custom converters	2020-10-23 22:03:20 +03:00
Tyrrrz	7f2202e869	Cleanup	2020-10-23 21:40:53 +03:00
Tyrrrz	14ad9d5738	Improve tests	2020-10-23 21:18:57 +03:00
Tyrrrz	b120138de3	Update github actions	2020-10-23 20:53:27 +03:00
Tyrrrz	8df1d607c1	Refactor & improve argument conversion feature	2020-10-23 20:52:26 +03:00
Tyrrrz	c06f2810b9	Cleanup analyzers	2020-10-23 18:23:58 +03:00
Tyrrrz	d52a205f13	Improve coverage slightly	2020-10-23 18:17:17 +03:00
Tyrrrz	0ec12e57c1	Refactor pretty stack traces	2020-10-23 18:01:40 +03:00
Nikiforov Alexey	c322b7029c	Add child command usage in help text (#77 )	2020-10-22 16:02:58 +03:00
Oleksandr Shustov	6a38c04c11	Custom value converters (#81 )	2020-10-16 14:22:42 +03:00
Alexey Golub	5e53107def	Treat nullability warnings as errors	2020-10-07 15:20:35 +03:00
Alexey Golub	36cea937de	Update nuget packages	2020-10-07 15:11:37 +03:00
Mårten Åsberg	438d6b98ac	Pretty printing of exception messages (#79 )	2020-10-06 20:43:19 +03:00
Alexey Golub	8e1488c395	Update readme	2020-09-14 22:31:25 +03:00
Alexey Golub	65d321b476	Update readme	2020-08-20 19:31:26 +03:00
Alexey Golub	c6d2359d6b	Update version	2020-08-20 17:02:19 +03:00
Alexey Golub	0d32876bad	Add VirtualConsole.CreateBuffered() for easier testing	2020-08-20 16:27:23 +03:00
Alexey Golub	c063251d89	Exclude some ToString() methods from coverage These are only used for debug information and I'm okayish with them failing at runtime.	2020-08-19 22:39:43 +03:00
Alexey Golub	3831cfc7c0	Get rid of internal tests Move all tests to e2e+ level	2020-08-19 22:31:09 +03:00
Alexey Golub	b17341b56c	Update version	2020-07-31 15:41:47 +03:00
Alexey Golub	5bda964fb5	Cleanup	2020-07-31 15:34:38 +03:00
Daniel Hix	432430489a	Add error for non-scalar parameters bound without any values (#71 )	2020-07-31 15:08:13 +03:00
Ron Myers	9a20101f30	Fix application crashes if there are two environment variables with same name, differing only in case (#67 )	2020-07-28 14:20:02 +03:00