Update version

Closes #132

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: ⚠ Feature request
+    url: https://github.com/Tyrrrz/.github/blob/master/docs/project-status.md
+    about: Sorry, but this project is in maintenance mode and no longer accepts new feature requests.
   - name: 💬 Discord server
     url: https://discord.gg/2SUWKFnHSm
     about: Chat with the project community.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -1,22 +0,0 @@
-name: ✨ Feature request
-description: Request a new feature.
-labels: [enhancement]
-
-body:
-- type: markdown
-  attributes:
-    value: |
-      🧐 **Guidelines:**
-
-      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this feature has not been requested before.
-      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Some suggestions" or "Ideas for improvement".
-      - Keep your issue focused on one single problem. If you have multiple feature requests, please create separate issues for each of them.
-      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
-      - If you want to ask a question instead of requesting a feature, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
-
-- type: textarea
-  attributes:
-    label: Details
-    description: Clear and thorough explanation of the feature you have in mind.
-  validations:
-    required: true

.github/workflows/main.yml

@@ -4,7 +4,9 @@ on: [push, pull_request]
 
 jobs:
   main:
-    uses: Tyrrrz/.github/.github/workflows/NuGet.yml@master
+    uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
+    with:
+      dotnet-version: 7.0.x
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}

Changelog.md

@@ -1,3 +1,49 @@
+### v2.3.1 (08-Dec-2022)
+
+- Added support for the `required` keyword introduced in C# 11. Command options bound to required properties are now marked as required by default (equivalent to setting `IsRequired = true` on the attribute). Also added analyzers that prevent marking an option or parameter non-required if it's bound to a required property.
+
+### v2.3 (12-Jul-2022)
+
+- Added console dimension properties `WindowWidth` and `WindowHeight` to `IConsole` interface and implementing classes.
+- Improved inline documentation for members of `IConsole` interface.
+
+### v2.2.6 (14-Jun-2022)
+
+- Added an overload of `CliApplicationBuilder.UseTypeActivator(...)` that accepts an instance of `IServiceProvider`. This slightly simplifies integration with many DI containers.
+- Fixed minor grammar mistakes in user-facing error messages.
+
+### v2.2.5 (10-May-2022)
+
+- Updated default value resolution for the application executable name. It will now resolve to `myapp.exe` instead of `dotnet myapp.dll` when the application is launched through the EXE apphost on Windows. On other platforms, or when running the application through the .NET CLI, the behavior will be the same as before.
+
+### v2.2.4 (22-Apr-2022)
+
+- Added more contextual information to analyzer diagnostics.
+- Fixed an issue where the analyzer incorrectly reported an error on converters that didn't directly match the target type but were compatible through known built-in conversions.
+- Fixed an issue where MSBuild produced a lot of analyzer-related warnings in certain circumstances.
+
+### v2.2.3 (17-Apr-2022)
+
+- Changed method signature of `IConsole.ReadKey()` to return `ConsoleKeyInfo` instead of `void`. The return type was originally defined as `void` by mistake. This change is source-backwards-compatible but may break on binary level if you were previously calling this method indirectly (i.e. through a library).
+- Added `FakeConsole.EnqueueKey(...)` to facilitate the testing of `IConsole.ReadKey()`. You can use this method to simulate key presses in your application.
+- Extended analyzers that verify the correctness of specified converters and validators. They now also ensure that the specified types are compatible with the type of the underlying property.
+- Improved diagnostics produced by analyzers. Where relevant, highlighted code is now limited to the property or type identifier, instead of the whole property or type declaration. Also extended the diagnostic messages with additional information.
+- Fixed an issue where throwing an exception inside a constructor of a command type resulted in an unrelated error message about the absence of a parameterless constructor.
+
+### v2.2.2 (30-Jan-2022)
+
+- Fixed an issue where `ConsoleWriter` and `ConsoleReader` were not properly thread-safe.
+- Fixed an issue where the analyzer failed to load under certain circumstances when running inside Visual Studio.
+
+### v2.2.1 (16-Jan-2022)
+
+- Fixed an issue which caused help text to not show default values for optional parameters. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.2 (11-Jan-2022)
+
+- Added support for optional parameters. A parameter can be marked as optional by setting `IsRequired = false` on the attribute. Only one parameter is allowed to be optional and such parameter must be the last in order. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+- Fixed an issue where parameters and options bound to properties implemented as default interface members were not working correctly. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
 ### v2.1 (04-Jan-2022)
 
 - Added `IConsole.Clear()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
@@ -37,7 +83,7 @@
 ### v2.0 (21-Mar-2021)
 
 > Note: this major release includes many breaking changes.
-Please refer to the readme to find updated instructions and usage examples.
+> Please refer to the readme to find updated instructions and usage examples.
 
 - Renamed property `EnvironmentVariableName` to `EnvironmentVariable` on `CommandOption` attribute.
 - Removed most of schema validation checks that used to take place during application startup. Going forward, CliFx will be relying solely on its built-in set of Roslyn analyzers to catch common errors in command configuration.

CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,14 +9,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="FluentAssertions" Version="6.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.1.0" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -13,11 +13,13 @@ public class CommandMustBeAnnotatedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -28,12 +30,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public abstract class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public abstract class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -44,11 +48,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public abstract class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            public abstract class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -59,11 +65,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class Foo
-{
-    public int Bar { get; set; } = 5;
-}";
+        const string code =
+            """
+            public class Foo
+            {
+                public int Bar { get; set; } = 5;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class CommandMustImplementInterfaceAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,12 +31,14 @@ public class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -45,11 +49,13 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class Foo
-{
-    public int Bar { get; set; } = 5;
-}";
+        const string code =
+            """
+            public class Foo
+            {
+                public int Bar { get; set; } = 5;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class OptionMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyClass
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public abstract class MyCommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public abstract class MyCommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustBeRequiredIfPropertyRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveNameOrShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(null)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption(null)]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,14 +76,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class OptionMustHaveUniqueNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    [CommandOption(""foo"")]
-    public string Bar { get; set; }
+                [CommandOption("foo")]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    [CommandOption(""bar"")]
-    public string Bar { get; set; }
+                [CommandOption("bar")]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,15 +61,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -76,14 +82,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class OptionMustHaveUniqueShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    [CommandOption('f')]
-    public string Bar { get; set; }
+                [CommandOption('f')]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    [CommandOption('b')]
-    public string Bar { get; set; }
+                [CommandOption('b')]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    [CommandOption('F')]
-    public string Bar { get; set; }
+                [CommandOption('F')]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,15 +85,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -98,14 +106,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -9,48 +9,130 @@ public class OptionMustHaveValidConverterAnalyzerSpecs
     private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidConverterAnalyzer();
 
     [Fact]
-    public void Analyzer_reports_an_error_if_the_specified_option_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyConverter
-{
-    public string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter
+            {
+                public string Convert(string rawValue) => rawValue;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_the_specified_option_converter_derives_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyConverter : BindingConverter<string>
-{
-    public override string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +143,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +164,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveValidNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""f"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("f")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""1foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("1foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,15 +76,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -89,14 +97,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveValidShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('1')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('1')]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,14 +76,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -9,48 +9,78 @@ public class OptionMustHaveValidValidatorsAnalyzerSpecs
     private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidValidatorsAnalyzer();
 
     [Fact]
-    public void Analyzer_reports_an_error_if_one_of_the_specified_option_validators_does_not_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_an_option_has_a_validator_that_does_not_derive_from_BindingValidator()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyValidator
-{
-    public void Validate(string value) {}
-}
+        const string code =
+            """
+            public class MyValidator
+            {
+                public void Validate(string value) {}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_all_specified_option_validators_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_an_option_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyValidator : BindingValidator<string>
-{
-    public override BindingValidationError Validate(string value) => Ok();
-}
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +112,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class ParameterMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyClass
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public abstract class MyCommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public abstract class MyCommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs

@@ -0,0 +1,102 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeLastIfNonRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeLastIfNonRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_parameter_is_not_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_parameter_is_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_no_non_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1, IsRequired = true)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

@@ -9,44 +9,48 @@ public class ParameterMustBeLastIfNonScalarAnalyzerSpecs
     private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeLastIfNonScalarAnalyzer();
 
     [Fact]
-    public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_last_in_order()
+    public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_the_last_in_order()
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string[] Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string[] Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_is_last_in_order()
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_is_the_last_in_order()
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                [CommandParameter(1)]
+                public string[] Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeRequiredIfPropertyRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = true)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = true)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

@@ -0,0 +1,102 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeSingleIfNonRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeSingleIfNonRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_more_than_one_non_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_only_one_non_required_parameter_is_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_no_non_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            
+                [CommandParameter(1, IsRequired = true)]
+                public string Bar { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustBeSingleIfNonScalarAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string[] Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string[] Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                [CommandParameter(1)]
+                public string[] Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                [CommandParameter(1)]
+                public string[] Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustHaveUniqueNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Name = ""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public string Foo { get; set; }
             
-    [CommandParameter(1, Name = ""foo"")]
-    public string Bar { get; set; }
+                [CommandParameter(1, Name = "foo")]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Name = ""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public string Foo { get; set; }
             
-    [CommandParameter(1, Name = ""bar"")]
-    public string Bar { get; set; }
+                [CommandParameter(1, Name = "bar")]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,14 +61,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustHaveUniqueOrderAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(0)]
-    public string Bar { get; set; }
+                [CommandParameter(0)]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,14 +61,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -9,48 +9,131 @@ public class ParameterMustHaveValidConverterAnalyzerSpecs
     private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidConverterAnalyzer();
 
     [Fact]
-    public void Analyzer_reports_an_error_if_the_specified_parameter_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyConverter
-{
-    public string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter
+            {
+                public string Convert(string rawValue) => rawValue;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_the_specified_parameter_converter_derives_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyConverter : BindingConverter<string>
-{
-    public override string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +144,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +165,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -9,48 +9,78 @@ public class ParameterMustHaveValidValidatorsAnalyzerSpecs
     private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidValidatorsAnalyzer();
 
     [Fact]
-    public void Analyzer_reports_an_error_if_one_of_the_specified_parameter_validators_does_not_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_a_parameter_has_a_validator_that_does_not_derive_from_BindingValidator()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyValidator
-{
-    public void Validate(string value) {}
-}
+        const string code =
+            """
+            public class MyValidator
+            {
+                public void Validate(string value) {}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_all_specified_parameter_validators_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyValidator : BindingValidator<string>
-{
-    public override BindingValidationError Validate(string value) => Ok();
-}
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +112,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

@@ -13,16 +13,18 @@ public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        Console.WriteLine(""Hello world"");
-        return default;
-    }
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    Console.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -33,16 +35,19 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        Console.ForegroundColor = ConsoleColor.Black;
-        return default;
-    }
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    Console.ForegroundColor = ConsoleColor.Black;
+                    return default;
+                }
+            }
+            """;
+
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
@@ -52,16 +57,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        Console.Error.WriteLine(""Hello world"");
-        return default;
-    }
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    Console.Error.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -72,16 +79,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Hello world"");
-        return default;
-    }
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -92,14 +101,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public void SomeOtherMethod() => Console.WriteLine(""Test"");
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public void SomeOtherMethod() => Console.WriteLine("Test");
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -110,15 +121,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        return default;
-    }
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    return default;
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -57,8 +57,8 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         // Compile the code to IL
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
-            new[] {ast},
-            ReferenceAssemblies.Net50
+            new[] { ast },
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)),
             // DLL to avoid having to define the Main() method
             new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
@@ -72,9 +72,10 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
-                Environment.NewLine +
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                $"""
+                Failed to compile code.
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -101,11 +102,11 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         var expectedDiagnosticIds = expectedDiagnostics.Select(d => d.Id).Distinct().ToArray();
         var producedDiagnosticIds = producedDiagnostics.Select(d => d.Id).Distinct().ToArray();
 
-        var result =
+        var isSuccessfulAssertion =
             expectedDiagnosticIds.Intersect(producedDiagnosticIds).Count() ==
             expectedDiagnosticIds.Length;
 
-        Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
         {
             var buffer = new StringBuilder();
 
@@ -125,10 +126,17 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
 
             buffer.AppendLine("Produced diagnostics:");
 
-            foreach (var producedDiagnostic in producedDiagnostics)
+            if (producedDiagnostics.Any())
             {
-                buffer.Append("  - ");
-                buffer.Append(producedDiagnostic);
+                foreach (var producedDiagnostic in producedDiagnostics)
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(producedDiagnostic);
+                }
+            }
+            else
+            {
+                buffer.AppendLine("  < none >");
             }
 
             return new FailReason(buffer.ToString());
@@ -138,10 +146,9 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
     public void NotProduceDiagnostics(string sourceCode)
     {
         var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+        var isSuccessfulAssertion = !producedDiagnostics.Any();
 
-        var result = !producedDiagnostics.Any();
-
-        Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
         {
             var buffer = new StringBuilder();
 

CliFx.Analyzers/AnalyzerBase.cs

@@ -28,8 +28,8 @@ public abstract class AnalyzerBase : DiagnosticAnalyzer
         SupportedDiagnostics = ImmutableArray.Create(SupportedDiagnostic);
     }
 
-    protected Diagnostic CreateDiagnostic(Location location) =>
-        Diagnostic.Create(SupportedDiagnostic, location);
+    protected Diagnostic CreateDiagnostic(Location location, params object?[]? messageArgs) =>
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);
 
     public override void Initialize(AnalysisContext context)
     {

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -2,12 +2,21 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Nullable>annotations</Nullable>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <GenerateDependencyFile>true</GenerateDependencyFile>
     <NoWarn>$(NoWarn);RS1025;RS1026</NoWarn>
   </PropertyGroup>
   
+  <PropertyGroup>
+    <!--
+      Because this project only has a single target framework, the condition in
+      Directory.Build.props does not appear to work. This is a workaround for that.
+    -->
+    <Nullable>annotations</Nullable>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs

@@ -30,18 +30,20 @@ public class CommandMustBeAnnotatedAnalyzer : AnalyzerBase
 
         var implementsCommandInterface = type
             .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         var hasCommandAttribute = type
             .GetAttributes()
             .Select(a => a.AttributeClass)
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
 
         // If the interface is implemented, but the attribute is missing,
         // then it's very likely a user error.
         if (implementsCommandInterface && !hasCommandAttribute)
         {
-            context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs

@@ -25,17 +25,19 @@ public class CommandMustImplementInterfaceAnalyzer : AnalyzerBase
         var hasCommandAttribute = type
             .GetAttributes()
             .Select(a => a.AttributeClass)
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
 
         var implementsCommandInterface = type
             .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         // If the attribute is present, but the interface is not implemented,
         // it's very likely a user error.
         if (hasCommandAttribute && !implementsCommandInterface)
         {
-            context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -1,28 +1,36 @@
 using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
 using System.Linq;
 using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
 
 namespace CliFx.Analyzers.ObjectModel;
 
-internal partial class CommandOptionSymbol
+internal partial class CommandOptionSymbol : ICommandMemberSymbol
 {
+    public IPropertySymbol Property { get; }
+
     public string? Name { get; }
 
     public char? ShortName { get; }
 
+    public bool? IsRequired { get; }
+
     public ITypeSymbol? ConverterType { get; }
 
     public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
 
     public CommandOptionSymbol(
+        IPropertySymbol property,
         string? name,
         char? shortName,
+        bool? isRequired,
         ITypeSymbol? converterType,
         IReadOnlyList<ITypeSymbol> validatorTypes)
     {
+        Property = property;
         Name = name;
         ShortName = shortName;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
@@ -30,25 +38,34 @@ internal partial class CommandOptionSymbol
 
 internal partial class CommandOptionSymbol
 {
-    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
-        property
-            .GetAttributes()
-            .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
+    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) => property
+        .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute) == true);
 
-    private static CommandOptionSymbol FromAttribute(AttributeData attribute)
+    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
     {
+        var attribute = TryGetOptionAttribute(property);
+        if (attribute is null)
+            return null;
+
         var name = attribute
             .ConstructorArguments
-            .Where(a => a.Type.DisplayNameMatches("string") || a.Type.DisplayNameMatches("System.String"))
+            .Where(a => a.Type?.SpecialType == SpecialType.System_String)
             .Select(a => a.Value)
             .FirstOrDefault() as string;
 
         var shortName = attribute
             .ConstructorArguments
-            .Where(a => a.Type.DisplayNameMatches("char") || a.Type.DisplayNameMatches("System.Char"))
+            .Where(a => a.Type?.SpecialType == SpecialType.System_Char)
             .Select(a => a.Value)
             .FirstOrDefault() as char?;
 
+        var isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
         var converter = attribute
             .NamedArguments
             .Where(a => a.Key == "Converter")
@@ -64,17 +81,7 @@ internal partial class CommandOptionSymbol
             .Cast<ITypeSymbol>()
             .ToArray();
 
-        return new CommandOptionSymbol(name, shortName, converter, validators);
-    }
-
-    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
-    {
-        var attribute = TryGetOptionAttribute(property);
-
-        if (attribute is null)
-            return null;
-
-        return FromAttribute(attribute);
+        return new CommandOptionSymbol(property, name, shortName, isRequired, converter, validators);
     }
 
     public static bool IsOptionProperty(IPropertySymbol property) =>

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

@@ -5,24 +5,32 @@ using Microsoft.CodeAnalysis;
 
 namespace CliFx.Analyzers.ObjectModel;
 
-internal partial class CommandParameterSymbol
+internal partial class CommandParameterSymbol : ICommandMemberSymbol
 {
+    public IPropertySymbol Property { get; }
+
     public int Order { get; }
 
     public string? Name { get; }
 
+    public bool? IsRequired { get; }
+
     public ITypeSymbol? ConverterType { get; }
 
     public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
 
     public CommandParameterSymbol(
+        IPropertySymbol property,
         int order,
         string? name,
+        bool? isRequired,
         ITypeSymbol? converterType,
         IReadOnlyList<ITypeSymbol> validatorTypes)
     {
+        Property = property;
         Order = order;
         Name = name;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
@@ -30,14 +38,17 @@ internal partial class CommandParameterSymbol
 
 internal partial class CommandParameterSymbol
 {
-    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) =>
-        property
-            .GetAttributes()
-            .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute));
+    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) => property
+        .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute) == true);
 
-    private static CommandParameterSymbol FromAttribute(AttributeData attribute)
+    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
     {
-        var order = (int) attribute
+        var attribute = TryGetParameterAttribute(property);
+        if (attribute is null)
+            return null;
+
+        var order = (int)attribute
             .ConstructorArguments
             .Select(a => a.Value)
             .First()!;
@@ -48,6 +59,12 @@ internal partial class CommandParameterSymbol
             .Select(a => a.Value.Value)
             .FirstOrDefault() as string;
 
+        var isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
         var converter = attribute
             .NamedArguments
             .Where(a => a.Key == "Converter")
@@ -63,17 +80,7 @@ internal partial class CommandParameterSymbol
             .Cast<ITypeSymbol>()
             .ToArray();
 
-        return new CommandParameterSymbol(order, name, converter, validators);
-    }
-
-    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
-    {
-        var attribute = TryGetParameterAttribute(property);
-
-        if (attribute is null)
-            return null;
-
-        return FromAttribute(attribute);
+        return new CommandParameterSymbol(property, order, name, isRequired, converter, validators);
     }
 
     public static bool IsParameterProperty(IPropertySymbol property) =>

CliFx.Analyzers/ObjectModel/ICommandMemberSymbol.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;
+
+internal interface ICommandMemberSymbol
+{
+    IPropertySymbol Property { get; }
+
+    ITypeSymbol? ConverterType { get; }
+
+    IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+}
+
+internal static class CommandMemberSymbolExtensions
+{
+    public static bool IsScalar(this ICommandMemberSymbol member) =>
+        member.Property.Type.SpecialType == SpecialType.System_String ||
+        member.Property.Type.TryGetEnumerableUnderlyingType() is null;
+}

CliFx.Analyzers/ObjectModel/SymbolNames.cs

@@ -7,8 +7,6 @@ internal static class SymbolNames
     public const string CliFxCommandParameterAttribute = "CliFx.Attributes.CommandParameterAttribute";
     public const string CliFxCommandOptionAttribute = "CliFx.Attributes.CommandOptionAttribute";
     public const string CliFxConsoleInterface = "CliFx.Infrastructure.IConsole";
-    public const string CliFxBindingConverterInterface = "CliFx.Extensibility.IBindingConverter";
     public const string CliFxBindingConverterClass = "CliFx.Extensibility.BindingConverter<T>";
-    public const string CliFxBindingValidatorInterface = "CliFx.Extensibility.IBindingValidator";
     public const string CliFxBindingValidatorClass = "CliFx.Extensibility.BindingValidator<T>";
 }

CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs

@@ -34,11 +34,13 @@ public class OptionMustBeInsideCommandAnalyzer : AnalyzerBase
         var isInsideCommand = property
             .ContainingType
             .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         if (!isInsideCommand)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/OptionMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,49 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzer : AnalyzerBase
+{
+    public OptionMustBeRequiredIfPropertyRequiredAnalyzer()
+        : base(
+            "Options bound to required properties cannot be marked as non-required",
+            "This option cannot be marked as non-required because it's bound to a required property.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired)
+            return;
+
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (option.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(
+            CreateDiagnostic(
+                propertyDeclaration.Identifier.GetLocation()
+            )
+        );
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs

@@ -27,7 +27,9 @@ public class OptionMustHaveNameOrShortNameAnalyzer : AnalyzerBase
 
         if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -14,7 +14,9 @@ public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
     public OptionMustHaveUniqueNameAnalyzer()
         : base(
             "Options must have unique names",
-            "This option's name must be unique within the command (comparison IS NOT case sensitive).")
+            "This option's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another option with the same name: `{1}`.")
     {
     }
 
@@ -51,7 +53,13 @@ public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
 
             if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -13,7 +13,9 @@ public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
     public OptionMustHaveUniqueShortNameAnalyzer()
         : base(
             "Options must have unique short names",
-            "This option's short name must be unique within the command (comparison IS case sensitive).")
+            "This option's short name must be unique within the command (comparison IS case sensitive). " +
+            "Specified short name: `{0}` " +
+            "Property bound to another option with the same short name: `{1}`.")
     {
     }
 
@@ -50,7 +52,13 @@ public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
 
             if (option.ShortName == otherOption.ShortName)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

@@ -13,7 +13,7 @@ public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
     public OptionMustHaveValidConverterAnalyzer()
         : base(
             $"Option converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-            $"Converter specified for this option must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this option must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
         if (option.ConverterType is null)
             return;
 
-        // We check against an internal interface because checking against a generic class is a pain
-        var converterImplementsInterface = option
+        var converterValueType = option
             .ConverterType
-            .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-        if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (option.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

@@ -12,7 +12,8 @@ public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
     public OptionMustHaveValidNameAnalyzer()
         : base(
             "Options must have valid names",
-            "This option's name must be at least 2 characters long and must start with a letter.")
+            "This option's name must be at least 2 characters long and must start with a letter. " +
+            "Specified name: `{0}`.")
     {
     }
 
@@ -30,7 +31,12 @@ public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
 
         if (option.Name.Length < 2 || !char.IsLetter(option.Name[0]))
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.Name
+                )
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

@@ -12,7 +12,8 @@ public class OptionMustHaveValidShortNameAnalyzer : AnalyzerBase
     public OptionMustHaveValidShortNameAnalyzer()
         : base(
             "Option short names must be letter characters",
-            "This option's short name must be a single letter character.")
+            "This option's short name must be a single letter character. " +
+            "Specified short name: `{0}`.")
     {
     }
 
@@ -30,7 +31,12 @@ public class OptionMustHaveValidShortNameAnalyzer : AnalyzerBase
 
         if (!char.IsLetter(option.ShortName.Value))
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.ShortName
+                )
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -13,7 +13,7 @@ public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
     public OptionMustHaveValidValidatorsAnalyzer()
         : base(
             $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
-            $"All validators specified for this option must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+            $"Each validator specified for this option must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
     }
 
@@ -28,14 +28,22 @@ public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
 
         foreach (var validatorType in option.ValidatorTypes)
         {
-            // We check against an internal interface because checking against a generic class is a pain
-            var validatorImplementsInterface = validatorType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
 
-            if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
                 // No need to report multiple identical diagnostics on the same node
                 break;

CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs

@@ -34,11 +34,13 @@ public class ParameterMustBeInsideCommandAnalyzer : AnalyzerBase
         var isInsideCommand = property
             .ContainingType
             .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         if (!isInsideCommand)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeLastIfNonRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeLastIfNonRequiredAnalyzer()
+        : base(
+            "Parameters marked as non-required must be the last in order",
+            "This parameter is non-required so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-required parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
+        {
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
+
+            if (otherParameter.Order > parameter.Order)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

@@ -12,18 +12,12 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
 {
     public ParameterMustBeLastIfNonScalarAnalyzer()
         : base(
-            "Parameters of non-scalar types must be last in order",
-            "This parameter has a non-scalar type so it must be last in order (its order must be highest within the command).")
+            "Parameters of non-scalar types must be the last in order",
+            "This parameter has a non-scalar type so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-    private static bool IsScalar(ITypeSymbol type) =>
-        type.DisplayNameMatches("string") ||
-        type.DisplayNameMatches("System.String") ||
-        !type.AllInterfaces
-            .Select(i => i.ConstructedFrom)
-            .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
@@ -32,13 +26,13 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
         if (property.ContainingType is null)
             return;
 
-        if (IsScalar(property.Type))
-            return;
-
         var parameter = CommandParameterSymbol.TryResolve(property);
         if (parameter is null)
             return;
 
+        if (parameter.IsScalar())
+            return;
+
         var otherProperties = property
             .ContainingType
             .GetMembers()
@@ -54,7 +48,12 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
 
             if (otherParameter.Order > parameter.Order)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,49 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeRequiredIfPropertyRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeRequiredIfPropertyRequiredAnalyzer()
+        : base(
+            "Parameters bound to required properties cannot be marked as non-required",
+            "This parameter cannot be marked as non-required because it's bound to a required property.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(
+            CreateDiagnostic(
+                propertyDeclaration.Identifier.GetLocation()
+            )
+        );
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeSingleIfNonRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeSingleIfNonRequiredAnalyzer()
+        : base(
+            "Parameters marked as non-required are limited to one per command",
+            "This parameter is non-required so it must be the only such parameter in the command. " +
+            "Property bound to another non-required parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
+        {
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
+
+            if (otherParameter.IsRequired == false)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -13,17 +13,11 @@ public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
     public ParameterMustBeSingleIfNonScalarAnalyzer()
         : base(
             "Parameters of non-scalar types are limited to one per command",
-            "This parameter has a non-scalar type so it must be the only such parameter in the command.")
+            "This parameter has a non-scalar type so it must be the only such parameter in the command. " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-    private static bool IsScalar(ITypeSymbol type) =>
-        type.DisplayNameMatches("string") ||
-        type.DisplayNameMatches("System.String") ||
-        !type.AllInterfaces
-            .Select(i => i.ConstructedFrom)
-            .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
@@ -32,10 +26,11 @@ public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
         if (property.ContainingType is null)
             return;
 
-        if (!CommandParameterSymbol.IsParameterProperty(property))
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
             return;
 
-        if (IsScalar(property.Type))
+        if (parameter.IsScalar())
             return;
 
         var otherProperties = property
@@ -47,12 +42,18 @@ public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
 
         foreach (var otherProperty in otherProperties)
         {
-            if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
                 continue;
 
-            if (!IsScalar(otherProperty.Type))
+            if (!otherParameter.IsScalar())
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -14,7 +14,9 @@ public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
     public ParameterMustHaveUniqueNameAnalyzer()
         : base(
             "Parameters must have unique names",
-            "This parameter's name must be unique within the command (comparison IS NOT case sensitive).")
+            "This parameter's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another parameter with the same name: `{1}`.")
     {
     }
 
@@ -51,7 +53,13 @@ public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
 
             if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -13,7 +13,9 @@ public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
     public ParameterMustHaveUniqueOrderAnalyzer()
         : base(
             "Parameters must have unique order",
-            "This parameter's order must be unique within the command.")
+            "This parameter's order must be unique within the command. " +
+            "Specified order: {0}. " +
+            "Property bound to another parameter with the same order: `{1}`.")
     {
     }
 
@@ -44,7 +46,13 @@ public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
 
             if (parameter.Order == otherParameter.Order)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

@@ -13,7 +13,7 @@ public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
     public ParameterMustHaveValidConverterAnalyzer()
         : base(
             $"Parameter converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-            $"Converter specified for this parameter must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
         if (parameter.ConverterType is null)
             return;
 
-        // We check against an internal interface because checking against a generic class is a pain
-        var converterImplementsInterface = parameter
+        var converterValueType = parameter
             .ConverterType
-            .AllInterfaces
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-        if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (parameter.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -13,7 +13,7 @@ public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
     public ParameterMustHaveValidValidatorsAnalyzer()
         : base(
             $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
-            $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+            $"Each validator specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
     }
 
@@ -28,14 +28,22 @@ public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
 
         foreach (var validatorType in parameter.ValidatorTypes)
         {
-            // We check against an internal interface because checking against a generic class is a pain
-            var validatorImplementsInterface = validatorType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
 
-            if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
                 // No need to report multiple identical diagnostics on the same node
                 break;

CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs

@@ -65,7 +65,9 @@ public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
 
         if (isConsoleInterfaceAvailable)
         {
-            context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(systemConsoleMemberAccess.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -16,6 +18,25 @@ internal static class RoslynExtensions
             StringComparison.Ordinal
         );
 
+    public static IEnumerable<INamedTypeSymbol> GetBaseTypes(this ITypeSymbol type)
+    {
+        var current = type.BaseType;
+
+        while (current is not null)
+        {
+            yield return current;
+            current = current.BaseType;
+        }
+    }
+
+    public static ITypeSymbol? TryGetEnumerableUnderlyingType(this ITypeSymbol type) => type
+        .AllInterfaces
+        .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
+        .TypeArguments[0];
+
+    public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
+        compilation.ClassifyConversion(source, destination).Exists;
+
     public static void HandleClassDeclaration(
         this AnalysisContext analysisContext,
         Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -2,16 +2,16 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.6.0" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="Cocona" Version="2.1.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
+    <PackageReference Include="PowerArgs" Version="4.0.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 

CliFx.Demo/CliFx.Demo.csproj

@@ -2,17 +2,17 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -14,10 +14,10 @@ public partial class BookAddCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Book title.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-    public string Author { get; init; } = "";
+    public required string Author { get; init; }
 
     [CommandOption("published", 'p', Description = "Book publish date.")]
     public DateTimeOffset Published { get; init; } = CreateRandomDate();

CliFx.Demo/Commands/BookCommand.cs

@@ -13,7 +13,7 @@ public class BookCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Title of the book to retrieve.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookCommand(LibraryProvider libraryProvider)
     {

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -12,7 +12,7 @@ public class BookRemoveCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Title of the book to remove.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookRemoveCommand(LibraryProvider libraryProvider)
     {

CliFx.Demo/Readme.md

@@ -2,4 +2,4 @@
 
 Sample command line interface for managing a library of books.
 
-This demo project showcases basic CliFx functionality such as command routing, argument parsing, autogenerated help text.
+This demo project showcases basic CliFx functionality such as command routing, argument parsing, and autogenerated help text.

CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj

@@ -2,12 +2,12 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Tests.Dummy/Program.cs

@@ -1,4 +1,5 @@
-using System.Reflection;
+using System;
+using System.Reflection;
 using System.Threading.Tasks;
 
 namespace CliFx.Tests.Dummy;
@@ -14,9 +15,17 @@ public static partial class Program
 
 public static partial class Program
 {
-    public static async Task Main() =>
+    public static async Task Main()
+    {
+        // Make sure color codes are not produced because we rely on the output in tests
+        Environment.SetEnvironmentVariable(
+            "DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION",
+            "false"
+        );
+
         await new CliApplicationBuilder()
             .AddCommandsFromThisAssembly()
             .Build()
             .RunAsync();
+    }
 }

CliFx.Tests/CancellationSpecs.cs

@@ -21,28 +21,30 @@ public class CancellationSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public async ValueTask ExecuteAsync(IConsole console)
-    {
-        try
-        {
-            await Task.Delay(
-                TimeSpan.FromSeconds(3),
-                console.RegisterCancellationHandler()
-            );
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public async ValueTask ExecuteAsync(IConsole console)
+                {
+                    try
+                    {
+                        await Task.Delay(
+                            TimeSpan.FromSeconds(3),
+                            console.RegisterCancellationHandler()
+                        );
 
-            console.Output.WriteLine(""Completed successfully"");
-        }
-        catch (OperationCanceledException)
-        {
-            console.Output.WriteLine(""Cancelled"");
-            throw;
-        }
-    }
-}");
+                        console.Output.WriteLine("Completed successfully");
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        console.Output.WriteLine("Cancelled");
+                        throw;
+                    }
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/CliFx.Tests.csproj

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,15 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
-    <PackageReference Include="CliWrap" Version="3.3.3" />
-    <PackageReference Include="FluentAssertions" Version="6.2.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.1.0" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="CliWrap" Version="3.5.0" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -29,12 +26,4 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
-      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <Visible>false</Visible>
-    </None>
-  </ItemGroup>
-
 </Project>

CliFx.Tests/ConsoleSpecs.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
+using CliFx.Tests.Utils.Extensions;
 using CliWrap;
 using CliWrap.Buffered;
 using FluentAssertions;
@@ -30,7 +31,8 @@ public class ConsoleSpecs : SpecsBase
         var command = "Hello world" | Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("console-test"));
+                .Add("console-test")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -46,25 +48,28 @@ public class ConsoleSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.ResetColor();
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
-        console.CursorLeft = 42;
-        console.CursorTop = 24;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.ResetColor();
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.WindowWidth = 100;
+                    console.WindowHeight = 25;
+                    console.CursorLeft = 42;
+                    console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
-        console.Error.WriteLine(""world!"");
+                    console.Output.WriteLine("Hello ");
+                    console.Error.WriteLine("world!");
 
-        return default;
-    }
-}
-");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -88,6 +93,8 @@ public class Command : ICommand
         Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
 
         // This fails because tests don't spawn a console window
+        //Console.WindowWidth.Should().Be(100);
+        //Console.WindowHeight.Should().Be(25);
         //Console.CursorLeft.Should().NotBe(42);
         //Console.CursorTop.Should().NotBe(24);
 
@@ -102,20 +109,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    var input = console.Input.ReadToEnd();
+                    console.Output.WriteLine(input);
+                    console.Error.WriteLine(input);
 
-        return default;
-    }
-}
-");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -139,6 +147,54 @@ public class Command : ICommand
         stdErr.Trim().Should().Be("Hello world");
     }
 
+    [Fact]
+    public async Task Fake_console_can_read_key_presses()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('0', ConsoleKey.D0, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('a', ConsoleKey.A, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('\0', ConsoleKey.Backspace, false, false, false));
+
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().ConsistOfLines(
+            "D0",
+            "A",
+            "Backspace"
+        );
+    }
+
     [Fact]
     public void Console_does_not_emit_preamble_when_used_with_encoding_that_has_it()
     {

CliFx.Tests/ConversionSpecs.cs

@@ -21,20 +21,22 @@ public class ConversionSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -59,20 +61,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public object Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public object Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -97,25 +101,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public bool Foo { get; set; }
 
-    [CommandOption('b')]
-    public bool Bar { get; set; }
+                [CommandOption('b')]
+                public bool Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -143,20 +149,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public bool Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -181,20 +189,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -219,20 +229,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public double Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public double Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -257,20 +269,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public DateTimeOffset Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public DateTimeOffset Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString("u", CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(""u"", CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -295,20 +309,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public TimeSpan Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public TimeSpan Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -333,22 +349,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            """
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomEnum Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomEnum Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine((int) Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine((int) Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -373,25 +391,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int? Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int? Foo { get; set; }
 
-    [CommandOption('b')]
-    public int? Bar { get; set; }
+                [CommandOption('b')]
+                public int? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -419,27 +439,29 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            """
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomEnum? Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomEnum? Foo { get; set; }
 
-    [CommandOption('b')]
-    public CustomEnum? Bar { get; set; }
+                [CommandOption('b')]
+                public CustomEnum? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + (int?) Foo);
-        console.Output.WriteLine(""Bar = "" + (int?) Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + (int?) Foo);
+                    console.Output.WriteLine("Bar = " + (int?) Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -467,27 +489,29 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomType
-{
-    public string Value { get; }
+            """
+            public class CustomType
+            {
+                public string Value { get; }
 
-    public CustomType(string value) => Value = value;
-}
+                public CustomType(string value) => Value = value;
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.Value);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.Value);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -512,45 +536,47 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomTypeA
-{
-    public string Value { get; }
+            """
+            public class CustomTypeA
+            {
+                public string Value { get; }
 
-    private CustomTypeA(string value) => Value = value;
+                private CustomTypeA(string value) => Value = value;
 
-    public static CustomTypeA Parse(string value) => 
-        new CustomTypeA(value);
-}
+                public static CustomTypeA Parse(string value) =>
+                    new CustomTypeA(value);
+            }
 
-public class CustomTypeB
-{
-    public string Value { get; }
+            public class CustomTypeB
+            {
+                public string Value { get; }
 
-    private CustomTypeB(string value) => Value = value;
+                private CustomTypeB(string value) => Value = value;
 
-    public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
-        new CustomTypeB(value);
-}
+                public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
+                    new CustomTypeB(value);
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomTypeA Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomTypeA Foo { get; set; }
 
-    [CommandOption('b')]
-    public CustomTypeB Bar { get; set; }
+                [CommandOption('b')]
+                public CustomTypeB Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo.Value);
-        console.Output.WriteLine(""Bar = "" + Bar.Value);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo.Value);
+                    console.Output.WriteLine("Bar = " + Bar.Value);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -578,26 +604,28 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomConverter : BindingConverter<int>
-{
-    public override int Convert(string rawValue) =>
-        rawValue.Length;
-}
+            """
+            public class CustomConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) =>
+                    rawValue.Length;
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f', Converter = typeof(CustomConverter))]
-    public int Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f', Converter = typeof(CustomConverter))]
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -622,22 +650,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string[] Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public string[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -666,22 +696,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -710,22 +742,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public List<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public List<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -754,22 +788,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int[] Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -798,16 +834,18 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -832,18 +870,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomType {}
+            """
+            public class CustomType {}
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -868,23 +908,25 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomType : IEnumerable<object>
-{
-    public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
+            """
+            public class CustomType : IEnumerable<object>
+            {
+                public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
 
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+                IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -909,26 +951,28 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class ValidatorA : BindingValidator<int>
-{
-    public override BindingValidationError Validate(int value) => Ok();
-}
+            """
+            public class ValidatorA : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
 
-public class ValidatorB : BindingValidator<int>
-{
-    public override BindingValidationError Validate(int value) => Error(""Hello world"");
-}
+            public class ValidatorB : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Error("Hello world");
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
-    public int Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -953,25 +997,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public class CustomType
-{
-    public string Value { get; }
+            """
+            public class CustomType
+            {
+                public string Value { get; }
 
-    private CustomType(string value) => Value = value;
+                private CustomType(string value) => Value = value;
 
-    public static CustomType Parse(string value) => throw new Exception(""Hello world"");
-}
+                public static CustomType Parse(string value) => throw new Exception("Hello world");
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)

CliFx.Tests/DirectivesSpecs.cs

@@ -28,7 +28,8 @@ public class DirectivesSpecs : SpecsBase
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("[debug]")) | stdOutBuffer;
+                .Add("[debug]")
+            ) | stdOutBuffer;
 
         // Act
         try
@@ -57,7 +58,7 @@ public class DirectivesSpecs : SpecsBase
         }
         catch (OperationCanceledException)
         {
-            // It's expected to fail
+            // This is expected
         }
 
         var stdOut = stdOutBuffer.ToString();
@@ -74,13 +75,14 @@ public class DirectivesSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+            [Command("cmd")]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/EnvironmentSpecs.cs

@@ -25,20 +25,21 @@ public class EnvironmentSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true, EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,20 +68,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -109,22 +111,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}
-");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -156,20 +159,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -198,20 +202,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -246,9 +251,11 @@ public class Command : ICommand
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("env-test"))
+                .Add("env-test")
+            )
             .WithEnvironmentVariables(e => e
-                .Set("ENV_TARGET", "Mars"));
+                .Set("ENV_TARGET", "Mars")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();

CliFx.Tests/ErrorReportingSpecs.cs

@@ -22,14 +22,15 @@ public class ErrorReportingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,14 +61,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"", new Exception(""Another exception""));
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong", new Exception("Another exception"));
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -99,14 +101,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("Something went wrong", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -134,14 +137,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -172,14 +176,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69, true);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("Something went wrong", 69, true);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/HelpTextSpecs.cs

@@ -44,13 +44,14 @@ public class HelpTextSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -77,19 +78,20 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -116,25 +118,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd"", Description = ""Description of a named command."")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            [Command("cmd", Description = "Description of a named command.")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -160,25 +163,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd child"", Description = ""Description of a named child command."")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child", Description = "Description of a named child command.")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -257,13 +261,15 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command(Description = ""Description of the default command."")]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command(Description = "Description of the default command.")]
+                public class DefaultCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -292,19 +298,21 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                [Command]
+                public class DefaultCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd")]
+                public class NamedCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -333,22 +341,24 @@ public class NamedCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
                 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public string Foo { get; set; }
                 
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
+                    [CommandParameter(1)]
+                    public string Bar { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandParameter(2)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -378,28 +388,30 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-// Base members appear last in reflection order
-public abstract class CommandBase : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
                 
-    public abstract ValueTask ExecuteAsync(IConsole console);
-}
+                // Base members appear last in reflection order
+                public abstract class CommandBase : ICommand
+                {
+                    [CommandParameter(0)]
+                    public string Foo { get; set; }
                 
-[Command]
-public class Command : CommandBase
-{
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
+                    public abstract ValueTask ExecuteAsync(IConsole console);
+                }
                 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [Command]
+                public class Command : CommandBase
+                {
+                    [CommandParameter(2)]
+                    public IReadOnlyList<string> Baz { get; set; }
                 
-    public override ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandParameter(1)]
+                    public string Bar { get; set; }
+                
+                    public override ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -428,22 +440,24 @@ public class Command : CommandBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
                 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo", IsRequired = true)]
+                    public string Foo { get; set; }
                 
-    [CommandOption(""baz"", IsRequired = true)]
-    public IReadOnlyList<string> Baz { get; set; }
+                    [CommandOption("bar")]
+                    public string Bar { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("baz", IsRequired = true)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -472,19 +486,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0, Name = ""foo"", Description = ""Description of foo."")]
-    public string Foo { get; set; }
+            """
                 
-    [CommandOption(""bar"", Description = ""Description of bar."")]
-    public string Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0, Name = "foo", Description = "Description of foo.")]
+                    public string Foo { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("bar", Description = "Description of bar.")]
+                    public string Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -515,13 +531,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -551,13 +569,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command("cmd")]
+                public class Command : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -589,21 +609,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public CustomEnum Foo { get; set; }
+                public enum CustomEnum { One, Two, Three }
                 
-    [CommandOption(""bar"")]
-    public CustomEnum Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public CustomEnum Foo { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("bar")]
+                    public CustomEnum Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -634,21 +656,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public IReadOnlyList<CustomEnum> Foo { get; set; }
+                public enum CustomEnum { One, Two, Three }
                 
-    [CommandOption(""bar"")]
-    public IReadOnlyList<CustomEnum> Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public IReadOnlyList<CustomEnum> Foo { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum> Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -679,21 +703,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public CustomEnum? Foo { get; set; }
+                public enum CustomEnum { One, Two, Three }
                 
-    [CommandOption(""bar"")]
-    public IReadOnlyList<CustomEnum?> Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public CustomEnum? Foo { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum?> Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -724,21 +750,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public CustomEnum Foo { get; set; }
+                public enum CustomEnum { One, Two, Three }
                 
-    [CommandOption(""bar"", EnvironmentVariable = ""ENV_BAR"")]
-    public CustomEnum Bar { get; set; }
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                    public CustomEnum Foo { get; set; }
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("bar", EnvironmentVariable = "ENV_BAR")]
+                    public CustomEnum Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -768,39 +796,41 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public object Foo { get; set; } = 42;
+                public enum CustomEnum { One, Two, Three }
                 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo")]
+                    public object Foo { get; set; } = 42;
                 
-    [CommandOption(""baz"")]
-    public IReadOnlyList<string> Baz { get; set; } = new[] {""one"", ""two"", ""three""};
+                    [CommandOption("bar")]
+                    public string Bar { get; set; } = "hello";
                 
-    [CommandOption(""qwe"")]
-    public bool Qwe { get; set; } = true;
+                    [CommandOption("baz")]
+                    public IReadOnlyList<string> Baz { get; set; } = new[] {"one", "two", "three"};
                 
-    [CommandOption(""qop"")]
-    public int? Qop { get; set; } = 1337;
+                    [CommandOption("qwe")]
+                    public bool Qwe { get; set; } = true;
                 
-    [CommandOption(""zor"")]
-    public TimeSpan Zor { get; set; } = TimeSpan.FromMinutes(123);
+                    [CommandOption("qop")]
+                    public int? Qop { get; set; } = 1337;
                 
-    [CommandOption(""lol"")]
-    public CustomEnum Lol { get; set; } = CustomEnum.Two;
+                    [CommandOption("zor")]
+                    public TimeSpan Zor { get; set; } = TimeSpan.FromMinutes(123);
                 
-    [CommandOption(""hmm"", IsRequired = true)]
-    public string Hmm { get; set; } = ""not printed"";
+                    [CommandOption("lol")]
+                    public CustomEnum Lol { get; set; } = CustomEnum.Two;
                 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                    [CommandOption("hmm", IsRequired = true)]
+                    public string Hmm { get; set; } = "not printed";
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -836,25 +866,27 @@ public class Command : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command(""cmd1"", Description = ""Description of one command."")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd2"", Description = ""Description of another command."")]
-public class SecondCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                [Command("cmd1", Description = "Description of one command.")]
+                public class FirstCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
                 
-[Command(""cmd2 child"", Description = ""Description of another command's child command."")]
-public class SecondCommandChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                [Command("cmd2", Description = "Description of another command.")]
+                public class SecondCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child", Description = "Description of another command's child command.")]
+                public class SecondCommandChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -890,37 +922,39 @@ public class SecondCommandChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command(""cmd1"")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd1 child1"")]
-public class FirstCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                [Command("cmd1")]
+                public class FirstCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
                 
-[Command(""cmd2"")]
-public class SecondCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                [Command("cmd1 child1")]
+                public class FirstCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
                 
-[Command(""cmd2 child11"")]
-public class SecondCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                [Command("cmd2")]
+                public class SecondCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
                 
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                [Command("cmd2 child11")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -950,25 +984,27 @@ public class SecondCommandSecondChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command(""cmd1"")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd2 child1"")]
-public class SecondCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                [Command("cmd1")]
+                public class FirstCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
                 
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                [Command("cmd2 child1")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)

CliFx.Tests/OptionBindingSpecs.cs

@@ -22,19 +22,21 @@ public class OptionBindingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public bool Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,19 +62,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public bool Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -98,24 +102,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; }
+                [CommandOption("bar")]
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -144,24 +150,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
 
-    [CommandOption('b')]
-    public string Bar { get; set; }
+                [CommandOption('b')]
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -190,24 +198,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
 
-    [CommandOption('b')]
-    public string Bar { get; set; }
+                [CommandOption('b')]
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -236,21 +246,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""Foo"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("Foo")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -280,21 +292,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -324,21 +338,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -368,21 +384,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -412,21 +430,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", 'f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", 'f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -456,24 +476,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
+                [CommandOption("bar")]
+                public string Bar { get; set; } = "hello";
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -496,26 +518,106 @@ public class Command : ICommand
         );
     }
 
+    [Fact]
+    public async Task Option_binding_supports_multiple_inheritance_through_default_interface_members()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            public static class SharedContext
+            {
+                public static int Foo { get; set; }
+
+                public static bool Bar { get; set; }
+            }
+
+            public interface IHasFoo : ICommand
+            {
+                [CommandOption("foo")]
+                public int Foo
+                {
+                    get => SharedContext.Foo;
+                    set => SharedContext.Foo = value;
+                }
+            }
+
+            public interface IHasBar : ICommand
+            {
+                [CommandOption("bar")]
+                public bool Bar
+                {
+                    get => SharedContext.Bar;
+                    set => SharedContext.Bar = value;
+                }
+            }
+
+            public interface IHasBaz : ICommand
+            {
+                public string Baz { get; set; }
+            }
+
+            [Command]
+            public class Command : IHasFoo, IHasBar, IHasBaz
+            {
+                [CommandOption("baz")]
+                public string Baz { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + SharedContext.Foo);
+                    console.Output.WriteLine("Bar = " + SharedContext.Bar);
+                    console.Output.WriteLine("Baz = " + Baz);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] { "--foo", "42", "--bar", "--baz", "xyz" }
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = 42",
+            "Bar = True",
+            "Baz = xyz"
+        );
+    }
+
     [Fact]
     public async Task Option_binding_does_not_consider_a_negative_number_as_an_option_name_or_short_name()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -541,15 +643,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -575,15 +679,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -609,15 +715,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -643,15 +751,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -677,15 +787,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -704,4 +816,40 @@ public class Command : ICommand
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("expects a single argument, but provided with multiple");
     }
+
+    [Fact]
+    public async Task Option_binding_fails_if_a_required_property_option_has_not_been_provided()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Missing required option(s)");
+    }
 }

CliFx.Tests/ParameterBindingSpecs.cs

@@ -21,24 +21,26 @@ public class ParameterBindingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,33 +69,35 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
+                [CommandParameter(2)]
+                public IReadOnlyList<string> Baz { get; set; }
 
-    [CommandOption(""boo"")]
-    public string Boo { get; set; }
+                [CommandOption("boo")]
+                public string Boo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        foreach (var i in Baz)
-            console.Output.WriteLine(""Baz = "" + i);
+                    foreach (var i in Baz)
+                        console.Output.WriteLine("Baz = " + i);
 
-        return default;
-    }
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -120,23 +124,73 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Parameter_binding_fails_if_one_of_the_parameters_has_not_been_provided()
+    public async Task Parameter_is_not_bound_if_there_are_no_arguments_matching_its_order()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; } = "xyz";
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"abc"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = abc",
+            "Bar = xyz"
+        );
+    }
+
+    [Fact]
+    public async Task Parameter_binding_fails_if_a_required_parameter_has_not_been_provided()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+
+                [CommandParameter(1)]
+                public string Bar { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -153,7 +207,7 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().NotBe(0);
-        stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
@@ -162,18 +216,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public IReadOnlyList<string> Bar { get; set; }
+                [CommandParameter(1)]
+                public IReadOnlyList<string> Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -190,7 +246,7 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().NotBe(0);
-        stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
@@ -199,18 +255,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/RoutingSpecs.cs

@@ -21,37 +21,38 @@ public class RoutingSpecs : SpecsBase
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -77,37 +78,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -133,37 +135,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)

CliFx.Tests/TypeActivationSpecs.cs

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -22,16 +23,18 @@ public class TypeActivationSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""foo"");
-        return default;
-    }
-}");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("foo");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -58,14 +61,16 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public Command(string foo) {}
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public Command(string foo) {}
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -87,30 +92,32 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Delegate_type_activator_can_initialize_a_type_using_a_custom_function()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_given_function()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    private readonly string _foo;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                private readonly string _foo;
 
-    public Command(string foo) => _foo = foo;
+                public Command(string foo) => _foo = foo;
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(_foo);
-        return default;
-    }
-}");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(_foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
-            .UseTypeActivator(type => Activator.CreateInstance(type, "hello world")!)
+            .UseTypeActivator(type => Activator.CreateInstance(type, "Hello world")!)
             .Build();
 
         // Act
@@ -123,25 +130,73 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("hello world");
+        stdOut.Trim().Should().Be("Hello world");
     }
 
     [Fact]
-    public async Task Delegate_type_activator_fails_if_the_underlying_function_returns_null()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_service_provider()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""foo"");
-        return default;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                private readonly string _foo;
+
+                public Command(string foo) => _foo = foo;
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(_foo);
+                    return default;
+                }
+            }
+            """
+        );
+
+        var serviceProvider = new ServiceCollection()
+            .AddSingleton(commandType, Activator.CreateInstance(commandType, "Hello world")!)
+            .BuildServiceProvider();
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .UseTypeActivator(serviceProvider)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("Hello world");
     }
-}");
+
+    [Fact]
+    public async Task Custom_type_activator_fails_if_the_underlying_function_returns_null()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("foo");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/Utils/DynamicCommandBuilder.cs

@@ -61,7 +61,7 @@ internal static class DynamicCommandBuilder
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
             new[] {ast},
-            ReferenceAssemblies.Net50
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location))
                 .Append(MetadataReference.CreateFromFile(typeof(DynamicCommandBuilder).Assembly.Location)),
             // DLL to avoid having to define the Main() method
@@ -76,9 +76,10 @@ internal static class DynamicCommandBuilder
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
-                Environment.NewLine +
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                $"""
+                Failed to compile code.
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -94,9 +95,10 @@ internal static class DynamicCommandBuilder
         if (emitErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to emit code." +
-                Environment.NewLine +
-                string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))
+                $"""
+                Failed to emit code.
+                {string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))}
+                """
             );
         }
 

CliFx/ApplicationConfiguration.cs

@@ -24,7 +24,7 @@ public class ApplicationConfiguration
     public bool IsPreviewModeAllowed { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ApplicationConfiguration"/>.
+    /// Initializes an instance of <see cref="ApplicationConfiguration" />.
     /// </summary>
     public ApplicationConfiguration(
         IReadOnlyList<Type> commandTypes,

CliFx/ApplicationMetadata.cs

@@ -26,7 +26,7 @@ public class ApplicationMetadata
     public string? Description { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ApplicationMetadata"/>.
+    /// Initializes an instance of <see cref="ApplicationMetadata" />.
     /// </summary>
     public ApplicationMetadata(
         string title,

CliFx/Attributes/CommandAttribute.cs

@@ -26,7 +26,7 @@ public sealed class CommandAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute(string name)
     {
@@ -34,7 +34,7 @@ public sealed class CommandAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute()
     {

CliFx/Attributes/CommandOptionAttribute.cs

@@ -14,7 +14,7 @@ public sealed class CommandOptionAttribute : Attribute
     /// </summary>
     /// <remarks>
     /// Must contain at least two characters and start with a letter.
-    /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+    /// Either <see cref="Name" /> or <see cref="ShortName" /> must be set.
     /// All options in a command must have unique names (comparison IS NOT case-sensitive).
     /// </remarks>
     public string? Name { get; }
@@ -23,15 +23,19 @@ public sealed class CommandOptionAttribute : Attribute
     /// Option short name.
     /// </summary>
     /// <remarks>
-    /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+    /// Either <see cref="Name" /> or <see cref="ShortName" /> must be set.
     /// All options in a command must have unique short names (comparison IS case-sensitive).
     /// </remarks>
     public char? ShortName { get; }
 
     /// <summary>
-    /// Whether this option is required.
+    /// Whether this option is required (default: <c>false</c>).
     /// If an option is required, the user will get an error if they don't set it.
     /// </summary>
+    /// <remarks>
+    /// You can use the <c>required</c> keyword on the property (introduced in C# 11) to implicitly
+    /// set <see cref="IsRequired" /> to <c>true</c>.
+    /// </remarks>
     public bool IsRequired { get; set; }
 
     /// <summary>
@@ -51,7 +55,7 @@ public sealed class CommandOptionAttribute : Attribute
     /// a value expected by the underlying property.
     /// </summary>
     /// <remarks>
-    /// Converter must derive from <see cref="BindingConverter{T}"/>.
+    /// Converter must derive from <see cref="BindingConverter{T}" />.
     /// </remarks>
     public Type? Converter { get; set; }
 
@@ -60,12 +64,12 @@ public sealed class CommandOptionAttribute : Attribute
     /// property, after it has been bound.
     /// </summary>
     /// <remarks>
-    /// Validators must derive from <see cref="BindingValidator{T}"/>.
+    /// Validators must derive from <see cref="BindingValidator{T}" />.
     /// </remarks>
     public Type[] Validators { get; set; } = Array.Empty<Type>();
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     private CommandOptionAttribute(string? name, char? shortName)
     {
@@ -74,7 +78,7 @@ public sealed class CommandOptionAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(string name, char shortName)
         : this(name, (char?) shortName)
@@ -82,7 +86,7 @@ public sealed class CommandOptionAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(string name)
         : this(name, null)
@@ -90,7 +94,7 @@ public sealed class CommandOptionAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(char shortName)
         : this(null, (char?) shortName)

CliFx/Attributes/CommandParameterAttribute.cs

@@ -11,18 +11,26 @@ public sealed class CommandParameterAttribute : Attribute
 {
     /// <summary>
     /// Parameter order.
-    /// </summary>
-    /// <remarks>
     /// Higher order means the parameter appears later, lower order means
     /// it appears earlier.
-    ///
+    /// </summary>
+    /// <remarks>
     /// All parameters in a command must have unique order.
-    ///
     /// Parameter whose type is a non-scalar (e.g. array), must always be the last in order.
     /// Only one non-scalar parameter is allowed in a command.
     /// </remarks>
     public int Order { get; }
 
+    /// <summary>
+    /// Whether this parameter is required (default: <c>true</c>).
+    /// If a parameter is required, the user will get an error if they don't set it.
+    /// </summary>
+    /// <remarks>
+    /// Parameter marked as non-required must always be the last in order.
+    /// Only one non-required parameter is allowed in a command.
+    /// </remarks>
+    public bool IsRequired { get; set; } = true;
+
     /// <summary>
     /// Parameter name.
     /// This is shown to the user in the help text.
@@ -43,7 +51,7 @@ public sealed class CommandParameterAttribute : Attribute
     /// a value expected by the underlying property.
     /// </summary>
     /// <remarks>
-    /// Converter must derive from <see cref="BindingConverter{T}"/>.
+    /// Converter must derive from <see cref="BindingConverter{T}" />.
     /// </remarks>
     public Type? Converter { get; set; }
 
@@ -52,12 +60,12 @@ public sealed class CommandParameterAttribute : Attribute
     /// property, after it has been bound.
     /// </summary>
     /// <remarks>
-    /// Validators must derive from <see cref="BindingValidator{T}"/>.
+    /// Validators must derive from <see cref="BindingValidator{T}" />.
     /// </remarks>
     public Type[] Validators { get; set; } = Array.Empty<Type>();
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandParameterAttribute"/>.
+    /// Initializes an instance of <see cref="CommandParameterAttribute" />.
     /// </summary>
     public CommandParameterAttribute(int order)
     {

CliFx/CliApplication.cs

@@ -34,7 +34,7 @@ public class CliApplication
     private readonly CommandBinder _commandBinder;
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliApplication"/>.
+    /// Initializes an instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication(
         ApplicationMetadata metadata,
@@ -112,7 +112,7 @@ public class CliApplication
         // Activate command instance
         var commandInstance = commandSchema == FallbackDefaultCommand.Schema
             ? new FallbackDefaultCommand() // bypass activator
-            : (ICommand) _typeActivator.CreateInstance(commandSchema.Type);
+            : (ICommand)_typeActivator.CreateInstance(commandSchema.Type);
 
         // Assemble help context
         var helpContext = new HelpContext(
@@ -176,7 +176,7 @@ public class CliApplication
     {
         try
         {
-            // Console colors may have already been overriden by the parent process,
+            // Console colors may have already been overridden by the parent process,
             // so we need to reset it to make sure that everything we write looks properly.
             _console.ResetColor();
 

CliFx/CliApplicationBuilder.cs

@@ -6,12 +6,13 @@ using System.Reflection;
 using CliFx.Attributes;
 using CliFx.Infrastructure;
 using CliFx.Schema;
+using CliFx.Utils;
 using CliFx.Utils.Extensions;
 
 namespace CliFx;
 
 /// <summary>
-/// Builder for <see cref="CliApplication"/>.
+/// Builder for <see cref="CliApplication" />.
 /// </summary>
 public partial class CliApplicationBuilder
 {
@@ -21,7 +22,7 @@ public partial class CliApplicationBuilder
     private bool _isPreviewModeAllowed = true;
     private string? _title;
     private string? _executableName;
-    private string? _versionText;
+    private string? _version;
     private string? _description;
     private IConsole? _console;
     private ITypeActivator? _typeActivator;
@@ -57,8 +58,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(Assembly commandAssembly)
     {
@@ -72,8 +73,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assemblies to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(IEnumerable<Assembly> commandAssemblies)
     {
@@ -87,8 +88,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the calling assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFromThisAssembly() => AddCommandsFrom(Assembly.GetCallingAssembly());
 
@@ -144,7 +145,7 @@ public partial class CliApplicationBuilder
     /// </remarks>
     public CliApplicationBuilder SetVersion(string version)
     {
-        _versionText = version;
+        _version = version;
         return this;
     }
 
@@ -158,7 +159,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="IConsole"/>.
+    /// Configures the application to use the specified implementation of <see cref="IConsole" />.
     /// </summary>
     public CliApplicationBuilder UseConsole(IConsole console)
     {
@@ -167,7 +168,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="ITypeActivator"/>.
+    /// Configures the application to use the specified implementation of <see cref="ITypeActivator" />.
     /// </summary>
     public CliApplicationBuilder UseTypeActivator(ITypeActivator typeActivator)
     {
@@ -182,14 +183,20 @@ public partial class CliApplicationBuilder
         UseTypeActivator(new DelegateTypeActivator(typeActivator));
 
     /// <summary>
-    /// Creates a configured instance of <see cref="CliApplication"/>.
+    /// Configures the application to use the specified service provider for activating types.
+    /// </summary>
+    public CliApplicationBuilder UseTypeActivator(IServiceProvider serviceProvider) =>
+        UseTypeActivator(serviceProvider.GetService);
+
+    /// <summary>
+    /// Creates a configured instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication Build()
     {
         var metadata = new ApplicationMetadata(
             _title ?? GetDefaultTitle(),
             _executableName ?? GetDefaultExecutableName(),
-            _versionText ?? GetDefaultVersionText(),
+            _version ?? GetDefaultVersionText(),
             _description
         );
 
@@ -210,14 +217,9 @@ public partial class CliApplicationBuilder
 
 public partial class CliApplicationBuilder
 {
-    private static readonly Lazy<Assembly?> EntryAssemblyLazy = new(Assembly.GetEntryAssembly);
-
-    // Entry assembly can be null, for example in tests
-    private static Assembly? EntryAssembly => EntryAssemblyLazy.Value;
-
     private static string GetDefaultTitle()
     {
-        var entryAssemblyName = EntryAssembly?.GetName().Name;
+        var entryAssemblyName = EnvironmentEx.EntryAssembly?.GetName().Name;
         if (string.IsNullOrWhiteSpace(entryAssemblyName))
             return "App";
 
@@ -226,26 +228,39 @@ public partial class CliApplicationBuilder
 
     private static string GetDefaultExecutableName()
     {
-        var entryAssemblyLocation = EntryAssembly?.Location;
+        var entryAssemblyLocation = EnvironmentEx.EntryAssembly?.Location;
         if (string.IsNullOrWhiteSpace(entryAssemblyLocation))
             return "app";
 
-        // The assembly can be an .exe or a .dll, depending on how it was packaged
+        // If the application was launched via matching EXE apphost, use that as the executable name
+        var isLaunchedViaAppHost = string.Equals(
+            EnvironmentEx.ProcessPath,
+            Path.ChangeExtension(entryAssemblyLocation, ".exe"),
+            StringComparison.OrdinalIgnoreCase
+        );
+
+        if (isLaunchedViaAppHost)
+            return Path.GetFileNameWithoutExtension(entryAssemblyLocation);
+
+        // Otherwise, use the entry assembly as the executable name.
+        // Prefix it with `dotnet` if it's a DLL file.
         var isDll = string.Equals(
             Path.GetExtension(entryAssemblyLocation),
             ".dll",
             StringComparison.OrdinalIgnoreCase
         );
 
-        var name = isDll
+        return isDll
             ? "dotnet " + Path.GetFileName(entryAssemblyLocation)
             : Path.GetFileNameWithoutExtension(entryAssemblyLocation);
-
-        return name;
     }
 
-    private static string GetDefaultVersionText() =>
-        EntryAssembly is not null
-            ? "v" + EntryAssembly.GetName().Version.ToSemanticString()
-            : "v1.0";
+    private static string GetDefaultVersionText()
+    {
+        var entryAssemblyVersion = EnvironmentEx.EntryAssembly?.GetName().Version;
+        if (entryAssemblyVersion is null)
+            return "v1.0";
+
+        return "v" + entryAssemblyVersion.ToSemanticString();
+    }
 }

CliFx/CliFx.csproj

@@ -2,6 +2,10 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.1;netstandard2.0</TargetFrameworks>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup>
     <Authors>$(Company)</Authors>
     <Description>Declarative framework for building command line applications</Description>
     <PackageTags>command line executable interface framework parser arguments cli app application net core</PackageTags>
@@ -23,17 +27,26 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />
-    <PackageReference Include="Nullable" Version="1.3.0" PrivateAssets="all" />
+    <PackageReference Include="Nullable" Version="1.3.1" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
   </ItemGroup>
 
-  <!-- Pack the analyzer assembly inside the package -->
+  <!-- Embed the analyzer inside the package -->
   <ItemGroup>
-    <ProjectReference Include="../CliFx.Analyzers/CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="../CliFx.Analyzers/CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/CliFx.Analyzers.deps.json" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
     <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/CliFx.Analyzers.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Buffers.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Collections.Immutable.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Memory.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Numerics.Vectors.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Reflection.Metadata.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Text.Encoding.CodePages.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Threading.Tasks.Extensions.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
   </ItemGroup>
 
 </Project>

CliFx/CommandBinder.cs

@@ -27,7 +27,7 @@ internal class CommandBinder
         // Custom converter
         if (memberSchema.ConverterType is not null)
         {
-            var converter = (IBindingConverter) _typeActivator.CreateInstance(memberSchema.ConverterType);
+            var converter = (IBindingConverter)_typeActivator.CreateInstance(memberSchema.ConverterType);
             return converter.Convert(rawValue);
         }
 
@@ -43,12 +43,6 @@ internal class CommandBinder
             return string.IsNullOrWhiteSpace(rawValue) || bool.Parse(rawValue);
         }
 
-        // IConvertible primitives (int, double, char, etc)
-        if (targetType.IsConvertible())
-        {
-            return Convert.ChangeType(rawValue, targetType, _formatProvider);
-        }
-
         // Special case for DateTimeOffset
         if (targetType == typeof(DateTimeOffset))
         {
@@ -68,6 +62,12 @@ internal class CommandBinder
             return Enum.Parse(targetType, rawValue!, true);
         }
 
+        // Convertible primitives (int, double, char, etc)
+        if (targetType.Implements(typeof(IConvertible)))
+        {
+            return Convert.ChangeType(rawValue, targetType, _formatProvider);
+        }
+
         // Nullable<T>
         var nullableUnderlyingType = targetType.TryGetNullableUnderlyingType();
         if (nullableUnderlyingType is not null)
@@ -78,32 +78,32 @@ internal class CommandBinder
         }
 
         // String-constructible (FileInfo, etc)
-        var stringConstructor = targetType.GetConstructor(new[] {typeof(string)});
+        var stringConstructor = targetType.GetConstructor(new[] { typeof(string) });
         if (stringConstructor is not null)
         {
-            return stringConstructor.Invoke(new object?[] {rawValue});
+            return stringConstructor.Invoke(new object?[] { rawValue });
         }
 
         // String-parseable (with IFormatProvider)
         var parseMethodWithFormatProvider = targetType.TryGetStaticParseMethod(true);
         if (parseMethodWithFormatProvider is not null)
         {
-            return parseMethodWithFormatProvider.Invoke(null, new object?[] {rawValue, _formatProvider});
+            return parseMethodWithFormatProvider.Invoke(null, new object?[] { rawValue, _formatProvider });
         }
 
         // String-parseable (without IFormatProvider)
         var parseMethod = targetType.TryGetStaticParseMethod();
         if (parseMethod is not null)
         {
-            return parseMethod.Invoke(null, new object?[] {rawValue});
+            return parseMethod.Invoke(null, new object?[] { rawValue });
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
-            Environment.NewLine +
-            $"There is no known way to convert a string value into an instance of type `{targetType.FullName}`." +
-            Environment.NewLine +
-            "To fix this, either change the property to use a supported type or configure a custom converter."
+            $"""
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
+            There is no known way to convert a string value into an instance of type `{targetType.FullName}`
+            To fix this, either change the property to use a supported type or configure a custom converter.
+            """
         );
     }
 
@@ -126,18 +126,18 @@ internal class CommandBinder
         }
 
         // Array-constructible (List<T>, HashSet<T>, etc)
-        var arrayConstructor = targetEnumerableType.GetConstructor(new[] {arrayType});
+        var arrayConstructor = targetEnumerableType.GetConstructor(new[] { arrayType });
         if (arrayConstructor is not null)
         {
-            return arrayConstructor.Invoke(new object?[] {array});
+            return arrayConstructor.Invoke(new object?[] { array });
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
-            Environment.NewLine +
-            $"There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`." +
-            Environment.NewLine +
-            "To fix this, change the property to use a type which can be assigned from an array or a type that has a constructor which accepts an array."
+            $"""
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
+            There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`.
+            To fix this, change the property to use a type which can be assigned from an array or a type that has a constructor which accepts an array.
+            """
         );
     }
 
@@ -169,20 +169,21 @@ internal class CommandBinder
                 : ex.Message;
 
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from provided argument(s):" +
-                Environment.NewLine +
-                rawValues.Select(v => '<' + v + '>').JoinToString(" ") +
-                Environment.NewLine +
-                $"Error: {errorMessage}",
+                $"""
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from the provided argument(s):
+                {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
+                Error: {errorMessage}
+                """,
                 ex
             );
         }
 
         // Mismatch (scalar but too many values)
         throw CliFxException.UserError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:" +
-            Environment.NewLine +
-            rawValues.Select(v => '<' + v + '>').JoinToString(" ")
+            $"""
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:
+            {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
+            """
         );
     }
 
@@ -192,7 +193,7 @@ internal class CommandBinder
 
         foreach (var validatorType in memberSchema.ValidatorTypes)
         {
-            var validator = (IBindingValidator) _typeActivator.CreateInstance(validatorType);
+            var validator = (IBindingValidator)_typeActivator.CreateInstance(validatorType);
             var error = validator.Validate(convertedValue);
 
             if (error is not null)
@@ -202,11 +203,11 @@ internal class CommandBinder
         if (errors.Any())
         {
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value." +
-                Environment.NewLine +
-                "Error(s):" +
-                Environment.NewLine +
-                errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)
+                $"""
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value.
+                Error(s):
+                {errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)}
+                """
             );
         }
     }
@@ -223,7 +224,7 @@ internal class CommandBinder
     {
         // Ensure there are no unexpected parameters and that all parameters are provided
         var remainingParameterInputs = commandInput.Parameters.ToList();
-        var remainingParameterSchemas = commandSchema.Parameters.ToList();
+        var remainingRequiredParameterSchemas = commandSchema.Parameters.Where(p => p.IsRequired).ToList();
 
         var position = 0;
 
@@ -238,7 +239,7 @@ internal class CommandBinder
             {
                 var parameterInput = commandInput.Parameters[position];
 
-                var rawValues = new[] {parameterInput.Value};
+                var rawValues = new[] { parameterInput.Value };
                 BindMember(parameterSchema, commandInstance, rawValues);
 
                 position++;
@@ -258,28 +259,26 @@ internal class CommandBinder
                 remainingParameterInputs.RemoveRange(parameterInputs);
             }
 
-            remainingParameterSchemas.Remove(parameterSchema);
+            remainingRequiredParameterSchemas.Remove(parameterSchema);
         }
 
         if (remainingParameterInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unexpected parameter(s):" +
-                Environment.NewLine +
-                remainingParameterInputs
-                    .Select(p => p.GetFormattedIdentifier())
-                    .JoinToString(" ")
+                $"""
+                Unexpected parameter(s):
+                {remainingParameterInputs.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
+                """
             );
         }
 
-        if (remainingParameterSchemas.Any())
+        if (remainingRequiredParameterSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing parameter(s):" +
-                Environment.NewLine +
-                remainingParameterSchemas
-                    .Select(o => o.GetFormattedIdentifier())
-                    .JoinToString(" ")
+                $"""
+                Missing required parameter(s):
+                {remainingRequiredParameterSchemas.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
+                """
             );
         }
     }
@@ -316,7 +315,7 @@ internal class CommandBinder
             else if (environmentVariableInput is not null)
             {
                 var rawValues = optionSchema.Property.IsScalar()
-                    ? new[] {environmentVariableInput.Value}
+                    ? new[] { environmentVariableInput.Value }
                     : environmentVariableInput.SplitValues();
 
                 BindMember(optionSchema, commandInstance, rawValues);
@@ -337,22 +336,20 @@ internal class CommandBinder
         if (remainingOptionInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unrecognized option(s):" +
-                Environment.NewLine +
-                remainingOptionInputs
-                    .Select(o => o.GetFormattedIdentifier())
-                    .JoinToString(", ")
+                $"""
+                Unrecognized option(s):
+                {remainingOptionInputs.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
+                """
             );
         }
 
         if (remainingRequiredOptionSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required option(s):" +
-                Environment.NewLine +
-                remainingRequiredOptionSchemas
-                    .Select(o => o.GetFormattedIdentifier())
-                    .JoinToString(", ")
+                $"""
+                Missing required option(s):
+                {remainingRequiredOptionSchemas.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
+                """
             );
         }
     }

CliFx/Exceptions/CliFxException.cs

@@ -24,7 +24,7 @@ public partial class CliFxException : Exception
     public bool ShowHelp { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliFxException"/>.
+    /// Initializes an instance of <see cref="CliFxException" />.
     /// </summary>
     public CliFxException(
         string message,

CliFx/Exceptions/CommandException.cs

@@ -9,7 +9,7 @@ namespace CliFx.Exceptions;
 public class CommandException : CliFxException
 {
     /// <summary>
-    /// Initializes an instance of <see cref="CommandException"/>.
+    /// Initializes an instance of <see cref="CommandException" />.
     /// </summary>
     public CommandException(
         string message,

CliFx/Extensibility/BindingValidationError.cs

@@ -11,7 +11,7 @@ public class BindingValidationError
     public string Message { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="BindingValidationError"/>.
+    /// Initializes an instance of <see cref="BindingValidationError" />.
     /// </summary>
     public BindingValidationError(string message) => Message = message;
 }

CliFx/Extensibility/BindingValidator.cs

@@ -23,13 +23,13 @@ public abstract class BindingValidator<T> : IBindingValidator
 
     /// <summary>
     /// Validates the value bound to a parameter or an option.
-    /// Returns <code>null</code> if validation is successful, or an error in case of failure.
+    /// Returns null if validation is successful, or an error in case of failure.
     /// </summary>
     /// <remarks>
-    /// You can use the utility methods <see cref="Ok"/> and <see cref="Error"/> to
+    /// You can use the utility methods <see cref="Ok" /> and <see cref="Error" /> to
     /// create an appropriate result.
     /// </remarks>
     public abstract BindingValidationError? Validate(T? value);
 
-    BindingValidationError? IBindingValidator.Validate(object? value) => Validate((T?) value);
+    BindingValidationError? IBindingValidator.Validate(object? value) => Validate((T?)value);
 }

CliFx/Formatting/HelpConsoleFormatter.cs

@@ -157,7 +157,15 @@ internal class HelpConsoleFormatter : ConsoleFormatter
 
         foreach (var parameterSchema in _context.CommandSchema.Parameters.OrderBy(p => p.Order))
         {
-            Write(ConsoleColor.Red, "* ");
+            if (parameterSchema.IsRequired)
+            {
+                Write(ConsoleColor.Red, "* ");
+            }
+            else
+            {
+                WriteHorizontalMargin();
+            }
+
             Write(ConsoleColor.DarkCyan, $"{parameterSchema.Name}");
 
             WriteColumnMargin();
@@ -199,6 +207,12 @@ internal class HelpConsoleFormatter : ConsoleFormatter
                 Write(' ');
             }
             
+            // Default value
+            if (!parameterSchema.IsRequired)
+            {
+                WriteDefaultValue(parameterSchema);
+            }
+
             WriteLine();
         }
     }
@@ -290,60 +304,65 @@ internal class HelpConsoleFormatter : ConsoleFormatter
             // Default value
             if (!optionSchema.IsRequired)
             {
-                var defaultValue = _context.CommandDefaultValues.GetValueOrDefault(optionSchema);
-                if (defaultValue is not null)
-                {
-                    // Non-Scalar
-                    if (defaultValue is not string && defaultValue is IEnumerable defaultValues)
-                    {
-                        var elementType =
-                            defaultValues.GetType().TryGetEnumerableUnderlyingType() ??
-                            typeof(object);
-
-                        if (elementType.IsToStringOverriden())
-                        {
-                            Write(ConsoleColor.White, "Default: ");
-
-                            var isFirst = true;
-
-                            foreach (var element in defaultValues)
-                            {
-                                if (isFirst)
-                                {
-                                    isFirst = false;
-                                }
-                                else
-                                {
-                                    Write(", ");
-                                }
-
-                                Write('"');
-                                Write(element.ToString(CultureInfo.InvariantCulture));
-                                Write('"');
-                            }
-
-                            Write('.');
-                        }
-                    }
-                    else
-                    {
-                        if (defaultValue.GetType().IsToStringOverriden())
-                        {
-                            Write(ConsoleColor.White, "Default: ");
-
-                            Write('"');
-                            Write(defaultValue.ToString(CultureInfo.InvariantCulture));
-                            Write('"');
-                            Write('.');
-                        }
-                    }
-                }
+                WriteDefaultValue(optionSchema);
             }
 
             WriteLine();
         }
     }
 
+    private void WriteDefaultValue(IMemberSchema schema)
+    {
+        var defaultValue = _context.CommandDefaultValues.GetValueOrDefault(schema);
+        if (defaultValue is not null)
+        {
+            // Non-Scalar
+            if (defaultValue is not string && defaultValue is IEnumerable defaultValues)
+            {
+                var elementType =
+                    defaultValues.GetType().TryGetEnumerableUnderlyingType() ??
+                    typeof(object);
+
+                if (elementType.IsToStringOverriden())
+                {
+                    Write(ConsoleColor.White, "Default: ");
+
+                    var isFirst = true;
+
+                    foreach (var element in defaultValues)
+                    {
+                        if (isFirst)
+                        {
+                            isFirst = false;
+                        }
+                        else
+                        {
+                            Write(", ");
+                        }
+
+                        Write('"');
+                        Write(element.ToString(CultureInfo.InvariantCulture));
+                        Write('"');
+                    }
+
+                    Write('.');
+                }
+            }
+            else
+            {
+                if (defaultValue.GetType().IsToStringOverriden())
+                {
+                    Write(ConsoleColor.White, "Default: ");
+
+                    Write('"');
+                    Write(defaultValue.ToString(CultureInfo.InvariantCulture));
+                    Write('"');
+                    Write('.');
+                }
+            }
+        }
+    }
+
     private void WriteCommandChildren()
     {
         var childCommandSchemas = _context

CliFx/ICommand.cs

@@ -9,7 +9,7 @@ namespace CliFx;
 public interface ICommand
 {
     /// <summary>
-    /// Executes the command using the specified implementation of <see cref="IConsole"/>.
+    /// Executes the command using the specified implementation of <see cref="IConsole" />.
     /// </summary>
     /// <remarks>
     /// If the execution of the command is not asynchronous, simply end the method with

CliFx/Infrastructure/ConsoleReader.cs

@@ -1,11 +1,16 @@
-using System.IO;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implements a <see cref="TextReader"/> for reading characters from a console stream.
+/// Implements a <see cref="TextReader" /> for reading characters from a console stream.
 /// </summary>
+// Both the underlying stream AND the stream reader must be synchronized!
+// https://github.com/Tyrrrz/CliFx/issues/123
 public partial class ConsoleReader : StreamReader
 {
     /// <summary>
@@ -14,7 +19,7 @@ public partial class ConsoleReader : StreamReader
     public IConsole Console { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleReader"/>.
+    /// Initializes an instance of <see cref="ConsoleReader" />.
     /// </summary>
     public ConsoleReader(IConsole console, Stream stream, Encoding encoding)
         : base(stream, encoding, false, 4096)
@@ -23,20 +28,79 @@ public partial class ConsoleReader : StreamReader
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleReader"/>.
+    /// Initializes an instance of <see cref="ConsoleReader" />.
     /// </summary>
     public ConsoleReader(IConsole console, Stream stream)
         : this(console, stream, System.Console.InputEncoding)
     {
     }
+
+    // The following overrides are required to establish thread-safe behavior
+    // in methods deriving from StreamReader.
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override int Peek() => base.Peek();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override int Read() => base.Read();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override int Read(char[] buffer, int index, int count) =>
+        base.Read(buffer, index, count);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override int ReadBlock(char[] buffer, int index, int count) =>
+        base.ReadBlock(buffer, index, count);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override string? ReadLine() => base.ReadLine();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override string ReadToEnd() => base.ReadToEnd();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task<int> ReadAsync(char[] buffer, int index, int count) =>
+        // Must be non-async to work with locks
+        Task.FromResult(Read(buffer, index, count));
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task<int> ReadBlockAsync(char[] buffer, int index, int count) =>
+        // Must be non-async to work with locks
+        Task.FromResult(ReadBlock(buffer, index, count));
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task<string?> ReadLineAsync() =>
+        // Must be non-async to work with locks
+        Task.FromResult(ReadLine());
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task<string> ReadToEndAsync() =>
+        // Must be non-async to work with locks
+        Task.FromResult(ReadToEnd());
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Close() => base.Close();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    protected override void Dispose(bool disposing) => base.Dispose(disposing);
 }
 
 public partial class ConsoleReader
 {
-    internal static ConsoleReader Create(IConsole console, Stream? stream) => new(
+    internal static ConsoleReader Create(IConsole console, Stream stream) => new(
         console,
-        stream is not null
-            ? Stream.Synchronized(stream)
-            : Stream.Null
+        Stream.Synchronized(stream)
     );
 }

CliFx/Infrastructure/ConsoleWriter.cs

@@ -1,12 +1,17 @@
-using System.IO;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading.Tasks;
 using CliFx.Utils;
 
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implements a <see cref="TextWriter"/> for writing characters to a console stream.
+/// Implements a <see cref="TextWriter" /> for writing characters to a console stream.
 /// </summary>
+// Both the underlying stream AND the stream writer must be synchronized!
+// https://github.com/Tyrrrz/CliFx/issues/123
 public partial class ConsoleWriter : StreamWriter
 {
     /// <summary>
@@ -15,7 +20,7 @@ public partial class ConsoleWriter : StreamWriter
     public IConsole Console { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleWriter"/>.
+    /// Initializes an instance of <see cref="ConsoleWriter" />.
     /// </summary>
     public ConsoleWriter(IConsole console, Stream stream, Encoding encoding)
         : base(stream, encoding.WithoutPreamble(), 256)
@@ -24,20 +29,251 @@ public partial class ConsoleWriter : StreamWriter
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleWriter"/>.
+    /// Initializes an instance of <see cref="ConsoleWriter" />.
     /// </summary>
     public ConsoleWriter(IConsole console, Stream stream)
         : this(console, stream, System.Console.OutputEncoding)
     {
     }
+
+    // The following overrides are required to establish thread-safe behavior
+    // in methods deriving from StreamWriter.
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(char[] buffer, int index, int count) => base.Write(buffer, index, count);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(char[] buffer) => base.Write(buffer);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(char value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(string? value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(string format, object? arg0) => base.Write(format, arg0);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(string format, object? arg0, object? arg1) =>
+        base.Write(format, arg0, arg1);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(string format, object? arg0, object? arg1, object? arg2) =>
+        base.Write(format, arg0, arg1, arg2);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(string format, params object?[] arg) => base.Write(format, arg);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(bool value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(int value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(long value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(uint value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(ulong value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(float value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(double value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(decimal value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Write(object? value) => base.Write(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteAsync(char[] buffer, int index, int count)
+    {
+        // Must be non-async to work with locks
+        Write(buffer, index, count);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteAsync(char value)
+    {
+        // Must be non-async to work with locks
+        Write(value);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteAsync(string? value)
+    {
+        // Must be non-async to work with locks
+        Write(value);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine() => base.WriteLine();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(char[] buffer, int index, int count) =>
+        base.WriteLine(buffer, index, count);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(char[] buffer) => base.WriteLine(buffer);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(char value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(string? value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(string format, object? arg0) => base.WriteLine(format, arg0);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(string format, object? arg0, object? arg1) =>
+        base.WriteLine(format, arg0, arg1);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(string format, object? arg0, object? arg1, object? arg2) =>
+        base.WriteLine(format, arg0, arg1, arg2);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(string format, params object?[] arg) =>
+        base.WriteLine(format, arg);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(bool value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(int value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(long value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(uint value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(ulong value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(float value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(double value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(decimal value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void WriteLine(object? value) => base.WriteLine(value);
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteLineAsync()
+    {
+        // Must be non-async to work with locks
+        WriteLine();
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteLineAsync(char value)
+    {
+        // Must be non-async to work with locks
+        WriteLine(value);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteLineAsync(char[] buffer, int index, int count)
+    {
+        // Must be non-async to work with locks
+        WriteLine(buffer, index, count);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task WriteLineAsync(string? value)
+    {
+        // Must be non-async to work with locks
+        WriteLine(value);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Flush() => base.Flush();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override Task FlushAsync()
+    {
+        // Must be non-async to work with locks
+        Flush();
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    public override void Close() => base.Close();
+
+    /// <inheritdoc />
+    [ExcludeFromCodeCoverage, MethodImpl(MethodImplOptions.Synchronized)]
+    protected override void Dispose(bool disposing) => base.Dispose(disposing);
 }
 
 public partial class ConsoleWriter
 {
-    internal static ConsoleWriter Create(IConsole console, Stream? stream) => new(
+    internal static ConsoleWriter Create(IConsole console, Stream stream) => new(
         console,
-        stream is not null
-            ? Stream.Synchronized(stream)
-            : Stream.Null
+        Stream.Synchronized(stream)
     ) {AutoFlush = true};
 }

CliFx/Infrastructure/DefaultTypeActivator.cs

@@ -4,7 +4,7 @@ using CliFx.Exceptions;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="ITypeActivator"/> that instantiates an object
+/// Implementation of <see cref="ITypeActivator" /> that instantiates an object
 /// by using its parameterless constructor.
 /// </summary>
 public class DefaultTypeActivator : ITypeActivator
@@ -16,14 +16,15 @@ public class DefaultTypeActivator : ITypeActivator
         {
             return Activator.CreateInstance(type);
         }
-        catch (Exception ex)
+        // Only catch MemberAccessException because the constructor can throw for its own reasons too
+        catch (MemberAccessException ex)
         {
             throw CliFxException.InternalError(
-                $"Failed to create an instance of type `{type.FullName}`." +
-                Environment.NewLine +
-                "Default type activator is only capable of instantiating a type if it has a public parameterless constructor." +
-                Environment.NewLine +
-                "To fix this, either add a parameterless constructor to the type or configure a custom activator on the application.",
+                $"""
+                Failed to create an instance of type `{type.FullName}`, could not access the constructor.
+                Default type activator is only capable of instantiating a type if it has a public parameterless constructor.
+                To fix this, either add a parameterless constructor to the type or configure a custom activator for the application.
+                """,
                 ex
             );
         }

CliFx/Infrastructure/DelegateTypeActivator.cs

@@ -4,7 +4,7 @@ using CliFx.Exceptions;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="ITypeActivator"/> that instantiates an object
+/// Implementation of <see cref="ITypeActivator" /> that instantiates an object
 /// by using a predefined function.
 /// </summary>
 public class DelegateTypeActivator : ITypeActivator
@@ -12,7 +12,7 @@ public class DelegateTypeActivator : ITypeActivator
     private readonly Func<Type, object> _func;
 
     /// <summary>
-    /// Initializes an instance of <see cref="DelegateTypeActivator"/>.
+    /// Initializes an instance of <see cref="DelegateTypeActivator" />.
     /// </summary>
     public DelegateTypeActivator(Func<Type, object> func) => _func = func;
 
@@ -24,11 +24,11 @@ public class DelegateTypeActivator : ITypeActivator
         if (instance is null)
         {
             throw CliFxException.InternalError(
-                $"Failed to create an instance of type `{type.FullName}`, received <null> instead." +
-                Environment.NewLine +
-                "To fix this, ensure that the provided type activator is configured correctly, as it's not expected to return <null>." +
-                Environment.NewLine +
-                "If you are relying on a dependency container, this error may indicate that the specified type has not been registered."
+                $"""
+                Failed to create an instance of type `{type.FullName}`, received <null> instead.
+                To fix this, ensure that the provided type activator is configured correctly, as it's not expected to return <null>.
+                If you are relying on a dependency container, this error may indicate that the specified type has not been registered.
+                """
             );
         }
 

CliFx/Infrastructure/FakeConsole.cs

@@ -1,11 +1,12 @@
 using System;
+using System.Collections.Concurrent;
 using System.IO;
 using System.Threading;
 
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="IConsole"/> that uses the provided fake
+/// Implementation of <see cref="IConsole" /> that uses the provided fake
 /// standard input, output, and error streams.
 /// </summary>
 /// <remarks>
@@ -14,6 +15,7 @@ namespace CliFx.Infrastructure;
 public class FakeConsole : IConsole, IDisposable
 {
     private readonly CancellationTokenSource _cancellationTokenSource = new();
+    private readonly ConcurrentQueue<ConsoleKeyInfo> _keys = new();
 
     /// <inheritdoc />
     public ConsoleReader Input { get; }
@@ -40,11 +42,10 @@ public class FakeConsole : IConsole, IDisposable
     public ConsoleColor BackgroundColor { get; set; } = ConsoleColor.Black;
 
     /// <inheritdoc />
-    public void ResetColor()
-    {
-        ForegroundColor = ConsoleColor.Gray;
-        BackgroundColor = ConsoleColor.Black;
-    }
+    public int WindowWidth { get; set; } = 232; // Windows defaults
+
+    /// <inheritdoc />
+    public int WindowHeight { get; set; } = 14; // Windows defaults
 
     /// <inheritdoc />
     public int CursorLeft { get; set; }
@@ -53,13 +54,39 @@ public class FakeConsole : IConsole, IDisposable
     public int CursorTop { get; set; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="FakeConsole"/>.
+    /// Initializes an instance of <see cref="FakeConsole" />.
     /// </summary>
     public FakeConsole(Stream? input = null, Stream? output = null, Stream? error = null)
     {
-        Input = ConsoleReader.Create(this, input);
-        Output = ConsoleWriter.Create(this, output);
-        Error = ConsoleWriter.Create(this, error);
+        Input = ConsoleReader.Create(this, input ?? Stream.Null);
+        Output = ConsoleWriter.Create(this, output ?? Stream.Null);
+        Error = ConsoleWriter.Create(this, error ?? Stream.Null);
+    }
+
+    /// <inheritdoc />
+    public ConsoleKeyInfo ReadKey(bool intercept = false) =>
+        _keys.TryDequeue(out var key)
+            ? key
+            : throw new InvalidOperationException(
+                "Cannot read key because there are no key presses enqueued. " +
+                $"Use the `{nameof(EnqueueKey)}(...)` method to simulate a key press."
+            );
+
+    /// <summary>
+    /// Enqueues a simulated key press, which can then be read by calling <see cref="ReadKey" />.
+    /// </summary>
+    public void EnqueueKey(ConsoleKeyInfo key) => _keys.Enqueue(key);
+
+    /// <inheritdoc />
+    public void ResetColor()
+    {
+        ForegroundColor = ConsoleColor.Gray;
+        BackgroundColor = ConsoleColor.Black;
+    }
+
+    /// <inheritdoc />
+    public void Clear()
+    {
     }
 
     /// <inheritdoc />
@@ -69,7 +96,7 @@ public class FakeConsole : IConsole, IDisposable
     /// Sends a cancellation signal to the currently executing command.
     /// </summary>
     /// <remarks>
-    /// If the command is not cancellation-aware (i.e. it doesn't call <see cref="IConsole.RegisterCancellationHandler"/>),
+    /// If the command is not cancellation-aware (i.e. it doesn't call <see cref="IConsole.RegisterCancellationHandler" />),
     /// this method will not have any effect.
     /// </remarks>
     public void RequestCancellation(TimeSpan? delay = null)
@@ -85,16 +112,6 @@ public class FakeConsole : IConsole, IDisposable
         }
     }
 
-    /// <inheritdoc />
-    public void Clear()
-    {
-    }
-
-    /// <inheritdoc />
-    public void ReadKey(bool intercept = false)
-    {
-    }
-
     /// <inheritdoc />
     public virtual void Dispose() => _cancellationTokenSource.Dispose();
 }

CliFx/Infrastructure/FakeInMemoryConsole.cs

@@ -3,7 +3,7 @@
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="IConsole"/> that uses fake
+/// Implementation of <see cref="IConsole" /> that uses fake
 /// standard input, output, and error streams backed by in-memory stores.
 /// </summary>
 /// <remarks>
@@ -24,7 +24,7 @@ public class FakeInMemoryConsole : FakeConsole
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="FakeInMemoryConsole"/>.
+    /// Initializes an instance of <see cref="FakeInMemoryConsole" />.
     /// </summary>
     public FakeInMemoryConsole()
         : this(new MemoryStream(), new MemoryStream(), new MemoryStream())