refactor(samples): modernise CommandProcessor samples

[holytshirt]

• Use Host.CreateApplicationBuilder() instead of CreateDefaultBuilder()
• Replace GetService with GetRequiredService for safer DI resolution
• Remove Serilog dependencies in favor of built-in logging
• Use string interpolation in handlers
• Make command classes internal sealed
• HelloWorldInternalBus: switch to async handler, remove custom mapper

[claude]

Pull Request Review

Summary

This PR modernizes the CommandProcessor sample applications by adopting current .NET hosting patterns and simplifying dependencies. The changes align well with modern .NET best practices.

---

Positive Changes

1. Modern Hosting Patterns

• Switching from Host.CreateDefaultBuilder() to Host.CreateApplicationBuilder() follows the recommended .NET 6+ pattern
• Using host.Run() instead of host.WaitForShutdown() is the standard approach for console host apps
• Cleaner service registration with the builder pattern

2. Safer Dependency Injection

• GetRequiredService<IAmACommandProcessor>() instead of GetService<>() is the correct choice - it will throw if the service is not registered, catching configuration errors early rather than failing with NullReferenceException later

3. Dependency Simplification

• Removing Serilog dependencies reduces external dependencies in sample code
• Built-in logging is simpler for samples and demonstrates the framework without extra setup

4. Code Quality Improvements

• String interpolation is more readable than format strings
• internal sealed classes follow good encapsulation practices for sample code
• Consistent use of CancellationToken cancellationToken = default parameter

5. HelloWorldInternalBus Improvements

• Switching to async handler (GreetingCommandHandlerAsync) shows modern async patterns
• Removing custom mapper simplifies the sample - good for demonstrating core concepts
• Added proper MIT license header to Program.cs (was missing)
• More streamlined service registration

---

Minor Observations

1. Namespace Inconsistency (samples/CommandProcessor/HelloWorldInternalBus/GreetingCommandHandlerAsync.cs:29)

The handler is in namespace HelloWorld while the command is in HelloWorldInternalBus. This works but creates inconsistency - consider aligning the namespace to HelloWorldInternalBus for consistency.

2. tests.http Formatting (samples/WebAPI/WebAPI_Dapper/tests.http)

The JSON spacing changes are correct and follow standard JSON formatting, though this file seems unrelated to the CommandProcessor samples modernization.

---

Code Quality Assessment

Adherence to Repository Conventions:

• Follows Responsibility-Driven Design principles
• Proper use of internal sealed for sample classes
• Good separation of concerns
• No primitive obsession issues
• Simple, focused methods

Best Practices:

• No security vulnerabilities introduced
• No breaking changes to public APIs
• Async/await patterns used correctly
• CancellationToken handling is appropriate
• No resource leaks

Performance:

• No performance regressions
• Async patterns properly implemented

---

Test Coverage

Note: These are sample applications demonstrating usage patterns. They do not require unit tests themselves, but they should successfully compile, run without errors, and demonstrate best practices.

Recommendation: Verify that each sample builds and runs successfully in CI.

---

Overall Assessment

This is a high-quality refactoring PR that:

• Modernizes the samples to use current .NET patterns
• Simplifies dependencies
• Improves code safety with GetRequiredService
• Removes unnecessary complexity
• Makes the samples better teaching tools

The changes follow the repository design principles by focusing on structural improvements without altering behavior.

Recommendation: Approve with minor namespace consistency suggestion.

---

Review generated following repository CLAUDE.md guidelines and design principles.

[iancooper]

Looks good. Thanks for updating these @holytshirt

[claude]

PR Review: Modernise CommandProcessor Samples

Overall Assessment

This is a well-executed modernization of the sample applications. The changes align with .NET 8 best practices and improve code quality. ✅

Positive Changes

1. Modern Host Builder Pattern ✅

• Switching from CreateDefaultBuilder() to Host.CreateApplicationBuilder() is the correct approach for .NET 8+
• More concise and idiomatic for modern .NET applications

2. Safer Dependency Injection ✅

• Changing GetService() to GetRequiredService() is excellent
• Fails fast if dependencies aren't registered, making bugs more obvious

3. Dependency Cleanup ✅

• Removing Serilog dependencies in favor of built-in logging reduces complexity
• Appropriate for sample code that should demonstrate core functionality

4. Code Quality Improvements ✅

• String interpolation ($"Hello {name}") is more readable than String.Format()
• Making command classes internal sealed follows encapsulation best practices
• Removing ConfigureAwait() in application code is correct per Stephen Cleary's guidance

5. Handler Consistency ✅

• Renaming GreetingCommandRequestHandlerAsync → GreetingCommandHandlerAsync improves consistency
• Namespace fix in HelloWorldInternalBus (HelloWorld → HelloWorldInternalBus) resolves confusion

6. Architecture Simplification ✅

• Removing the custom GreetingCommandMessageMapper from HelloWorldInternalBus simplifies the sample
• Using async handler directly is cleaner for demonstration purposes

Issues & Concerns

1. ⚠️ Breaking Change in HelloWorldInternalBus/Program.cs:69

var commandProcessor = host.Services.GetService<IAmACommandProcessor>();
commandProcessor?.Post(new GreetingCommand("Ian"));

Issue: Using GetService() instead of GetRequiredService() is inconsistent with the other samples.

Impact: If the service isn't registered, this will silently do nothing (null reference). The null-conditional operator ?. masks the problem.

Recommendation: Change to:

var commandProcessor = host.Services.GetRequiredService<IAmACommandProcessor>();
commandProcessor.Post(new GreetingCommand("Ian"));

This matches the pattern used in HelloWorld and HelloWorldAsync samples (lines 36-38 in HelloWorld/Program.cs).

2. ⚠️ Async Consistency in HelloWorldInternalBus

The sample uses Post() (fire-and-forget) but the handler is async. While this works, consider documenting why Post() is used instead of SendAsync().

Current:

commandProcessor.Post(new GreetingCommand("Ian"));
await host.RunAsync();

The async handler will execute, but users might wonder about the mixing of sync/async patterns.

3. Minor: WebAPI_Dapper/tests.http Changes

The formatting changes to tests.http are stylistic improvements but unrelated to the PR's stated purpose. Consider whether these belong in a separate commit for clarity.

Code Style Compliance

Checking against .agent_instructions/code_style.md:

• ✅ PascalCase for public members
• ✅ Internal sealed classes
• ✅ String interpolation usage
• ✅ Nullable reference types (implicitly handled)
• ✅ Expression-bodied members where appropriate

Security Considerations

No security concerns identified. The changes are refactoring existing sample code without introducing new attack surfaces.

Performance Considerations

• ✅ Host.CreateApplicationBuilder() has better performance characteristics than CreateDefaultBuilder()
• ✅ Removing unnecessary dependencies reduces startup time
• No negative performance impacts identified

Test Coverage

⚠️ Note: These are sample applications without automated tests. Manual testing should verify:

1. All three samples still execute successfully
2. HelloWorldInternalBus properly routes messages through the internal bus
3. Handler attributes (e.g., [RequestLoggingAsync]) still function correctly

Recommendations

Required Changes

1. Fix HelloWorldInternalBus/Program.cs:69 - Use GetRequiredService() instead of GetService() for consistency and fail-fast behavior

Optional Improvements

1. Consider adding a comment in HelloWorldInternalBus explaining why Post() is used with an async handler
2. Separate the tests.http formatting changes into a distinct commit if you value atomic commits

Summary

This PR demonstrates good modernization practices and improves code quality. With the one consistency fix for GetRequiredService(), this will be ready to merge. The changes make the samples more idiomatic for .NET 8 developers and easier to understand.

Recommendation: Approve after addressing the GetRequiredService() consistency issue.

---

Review generated by Claude Code following repository conventions from CLAUDE.md

[codescene-delta-analysis]

No application code in the PR — skipped Code Health checks.

See analysis details in CodeScene

Quality Gate Profile: Clean Code Collective
Want more control? Customize Code Health rules or catch issues early with our IDE extension and CLI tool.

[claude]

Pull Request Review: Modernize Sample Code to .NET 8 Patterns

Overall Assessment

This is a high-quality PR that successfully modernizes 30+ sample applications to use .NET 8 hosting patterns and best practices. The changes are well-executed and remarkably consistent across the codebase.

Overall Grade: A-

What This PR Does Well

1. Consistent Migration: All samples follow the same modernization pattern using Host.CreateApplicationBuilder()
2. Improved Null Safety: Changed GetService to GetRequiredService provides fail-fast behavior
3. Modern C# Syntax: String interpolation throughout
4. Better Encapsulation: Classes properly marked as internal sealed where appropriate
5. Naming Consistency: Handler naming standardized
6. Simplified Code: Removed unnecessary boilerplate
7. Dependency Reduction: Removing Serilog simplifies samples
8. License Compliance: Added missing MIT license headers

Issues and Recommendations

High Priority - Requires Verification:

1. Message Mapper Removal in HelloWorldInternalBus - The mapper was completely removed from samples/CommandProcessor/HelloWorldInternalBus/GreetingCommandMessageMapper.cs. Need to verify the sample still functions correctly. Manual testing of HelloWorldInternalBus is required.

Medium Priority - Consider Addressing:

2. Logging Visibility - Removing Serilog without replacement configuration may reduce logging output visibility. Consider adding a comment in key samples about logging configuration.

3. ConfigureAwait Removal - This is actually correct for .NET 8 console applications. Well done!

Code Quality Analysis

Pattern Consistency: 5/5 - Excellent, same pattern across all samples
Null Safety: 5/5 - GetRequiredService is safer
Modern Syntax: 5/5 - String interpolation, top-level statements
Encapsulation: 5/5 - Proper use of internal sealed
Async Patterns: 5/5 - Correct removal of ConfigureAwait
Documentation: 3/5 - Could benefit from comments

Security and Performance

Security: No concerns. The switch to GetRequiredService improves null safety.
Performance: The sealed keyword additions provide minor performance benefits.
Breaking Changes: Changes are limited to samples, no impact on library code.

Testing Recommendations

1. Run each modified sample to verify basic functionality
2. Verify logging output is visible and useful
3. Specifically test HelloWorldInternalBus due to mapper removal
4. Test with various .NET 8 SDK versions

Final Recommendation

APPROVE WITH MINOR VERIFICATION

This PR is well-executed and ready to merge after verifying HelloWorldInternalBus functions correctly without the message mapper. The modernization brings the samples up to .NET 8 standards and makes them more accessible to developers learning Brighter.

Great work on this comprehensive modernization effort!

Review performed by Claude Code - Analyzed 1,158 additions and 1,734 deletions across 39 files