feat: Add parallel initialization for injected properties at the same level

[thomhurst]

Properties with data sources at the same level are now initialized in parallel, significantly improving startup time for complex dependency graphs.

Changes:

• Modified PropertyInjectionService to process properties in parallel using Task.WhenAll
• Added parallel processing for source-generated and reflection-based property injection
• Added parallel processing for test method arguments
• Added comprehensive tests demonstrating performance improvements (60-70% faster)

Example use case: Web factory with Redis, SQL, and MessageBus containers that don't depend on each other now initialize simultaneously instead of sequentially.

[claude]

Claude finished @thomhurst's task —— View job

---

PR Review: Parallel Property Initialization

I've analyzed the changes and here's my comprehensive review of the parallel property initialization feature:

Todo List:

• Read repository guidelines (CLAUDE.md - not found, proceeded without)
• Analyze PropertyInjectionService.cs changes
• Review ParallelPropertyInjectionTests.cs test coverage
• Evaluate code quality and best practices
• Check for potential bugs or issues
• Assess performance considerations
• Review security concerns
• Provide comprehensive feedback

---

✅ Code Quality & Best Practices

Excellent implementation overall. The code follows solid async/await patterns and maintains good separation of concerns. Key strengths:

• Clean async patterns: Proper use of Task.WhenAll() for parallelization
• Consistent error handling: Good exception wrapping with context
• Method documentation: Comprehensive XML documentation throughout
• Backwards compatibility: Legacy API methods preserved

Minor suggestions:

• Consider extracting the property filtering logic in InjectPropertiesUsingReflectionAsync() (lines 144-156) into a separate method for better readability

✅ Potential Bugs & Issues

No critical bugs found. The implementation handles edge cases well:

• Null safety: Proper null checks throughout (lines 24, 75-78)
• Exception handling: Good error wrapping with meaningful messages (lines 105-108)
• Task completion: Proper awaiting of parallel tasks

One consideration:

• The _injectionTasks cache (line 15) uses GetOrAdd which is thread-safe, but consider if objects could be used as keys multiple times in different contexts

⚡ Performance Considerations

Excellent performance improvements implemented:

• Parallel processing: Both source-generation (lines 125-129) and reflection modes (lines 159-163) now process properties in parallel
• Method arguments: InjectPropertiesIntoArgumentsAsync() processes arguments in parallel (lines 30-35)
• Test validation: The test suite demonstrates significant time savings (60-70% improvement claimed)

Performance notes:

• Task creation overhead should be minimal for typical use cases
• The recursive nature is preserved while adding parallelism at each level
• Good use of ToArray() to materialize tasks before Task.WhenAll()

🔒 Security Concerns

No security issues identified. The code:

• Maintains existing security attributes ([UnconditionalSuppressMessage])
• Doesn't introduce new reflection vulnerabilities
• Preserves AOT safety where applicable
• No sensitive data exposure risks

🧪 Test Coverage

Comprehensive and well-designed test suite:

Strengths:

• Real-world scenario: Web factory with Redis, SQL, MessageBus containers (lines 60-85)
• Nested testing: Complex hierarchical property injection (lines 131-186)
• Performance validation: Actual timing measurements proving parallel execution (lines 107-127)
• Multiple assertion types: Null checks, timing validations, performance thresholds

Test quality highlights:

• Uses realistic delays (100-150ms) to simulate container startup
• Measures actual vs. sequential time with 80% threshold for parallel validation
• Comprehensive logging for debugging timing issues
• Tests both flat and nested property injection scenarios

📊 Overall Assessment

This is a high-quality implementation that delivers on its promise of parallel property initialization. The code is well-structured, thoroughly tested, and provides measurable performance benefits.

Key achievements:

• ✅ Maintains backwards compatibility
• ✅ Preserves existing error handling patterns
• ✅ Adds comprehensive test coverage
• ✅ Demonstrates real performance gains
• ✅ Follows established code patterns in the codebase

Recommendation: Approve - This PR successfully implements parallel property initialization with proper testing and documentation.

---