Updating Zip with sample app source files

Author: ChrisHowd

DownloadableCodeProjects/Downloads/GHCopilotEx10LabApps.zip

@@ -5,6 +5,12 @@
     <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    
+    <!-- Enable optimizations even for Debug so that running the app with the
+    'benchmark' argument via 'dotnet run' produces valid BenchmarkDotNet results.
+    Without this, a Debug build shows a warning that the assembly is non-optimized. -->
+    <Optimize>true</Optimize>
+    
   </PropertyGroup>
 
   <ItemGroup>

DownloadableCodeProjects/standalone-lab-projects/implement-performance-profiling/ContosoOnlineStore/ContosoOnlineStore.csproj

@@ -9,6 +9,7 @@ This document outlines the intentional performance bottlenecks in the Contoso On
 ### 🔴 Critical Performance Issues
 
 #### 1. Product Catalog Linear Search
+
 **File**: `ProductCatalog.cs`  
 **Method**: `GetProductById()`  
 **Issue**: Uses linear search (FirstOrDefault) instead of dictionary lookup  
@@ -23,65 +24,79 @@ return _productIndex.TryGetValue(productId, out var product) ? product : null;
 ```
 
 #### 2. Inefficient Search Implementation
+
 **File**: `ProductCatalog.cs`  
 **Method**: `SearchProducts()`  
-**Issues**: 
+**Issues**:
+
 - Multiple string operations per product
 - Inefficient cache key generation
 - Sequential processing with artificial delays
 
 **Impact**: High latency for search operations
 
 #### 3. Sequential Order Processing
+
 **File**: `OrderProcessor.cs`  
 **Method**: `FinalizeOrderAsync()`  
 **Issues**:
+
 - Individual product lookups in loops
 - Sequential inventory checks
 - Synchronous receipt generation
 
 ### 🟡 Moderate Performance Issues
 
 #### 4. Inventory Management Bottlenecks
+
 **File**: `InventoryManager.cs`  
 **Method**: `GetLowStockProducts()`  
 **Issues**:
+
 - Individual database queries simulation
 - Inefficient logging implementation
 - No batch operations
 
 #### 5. Email Service Delays
+
 **File**: `EmailService.cs`  
 **Method**: `SendConfirmationAsync()`  
 **Issues**:
+
 - Sequential email content generation
 - Individual product lookups in email templates
 - Synchronous validation operations
 
 ### 🟢 Minor Performance Issues
 
 #### 6. Excessive Logging Overhead
+
 **Throughout the application**  
 **Issues**:
+
 - Detailed logging in hot paths
 - String concatenation in logging
 - Synchronous logging operations
 
 #### 7. Memory Allocation Patterns
+
 **Various files**  
 **Issues**:
+
 - Frequent list creation and sorting
 - String concatenation without StringBuilder
 - Cache dictionary overhead
 
 ## Performance Optimization Exercise Guide
 
 ### Exercise 1: Optimize Product Lookup (Beginner)
+
 **Goal**: Improve product lookup performance from O(n) to O(1)  
 **Files**: `ProductCatalog.cs`  
 **Expected Improvement**: 90%+ reduction in lookup time
 
 **Steps**:
+
 1. Identify the linear search in `GetProductById()`
 2. Implement dictionary-based product index
 3. Update index when products are added/modified
@@ -90,11 +105,13 @@ return _productIndex.TryGetValue(productId, out var product) ? product : null;
 **Success Criteria**: Product lookups complete in <1ms
 
 ### Exercise 2: Batch Inventory Operations (Intermediate)
+
 **Goal**: Reduce individual database calls  
 **Files**: `InventoryManager.cs`, `OrderProcessor.cs`  
 **Expected Improvement**: 70%+ reduction in inventory check time
 
 **Steps**:
+
 1. Identify individual inventory checks in loops
 2. Implement batch inventory validation
 3. Create bulk stock update operations
@@ -103,11 +120,13 @@ return _productIndex.TryGetValue(productId, out var product) ? product : null;
 **Success Criteria**: Batch operations 5x faster than individual calls
 
 ### Exercise 3: Async Processing Pipeline (Advanced)
+
 **Goal**: Implement parallel processing for order operations  
 **Files**: `OrderProcessor.cs`, `EmailService.cs`  
 **Expected Improvement**: 60%+ reduction in total processing time
 
 **Steps**:
+
 1. Identify sequential operations that can be parallelized
 2. Implement async/await patterns properly
 3. Create parallel processing for order validation
@@ -116,11 +135,13 @@ return _productIndex.TryGetValue(productId, out var product) ? product : null;
 **Success Criteria**: Order processing completes in <500ms
 
 ### Exercise 4: Intelligent Caching (Advanced)
+
 **Goal**: Implement comprehensive caching strategy  
 **Files**: `ProductCatalog.cs`, `OrderProcessor.cs`  
 **Expected Improvement**: 80%+ improvement in repeated operations
 
 **Steps**:
+
 1. Implement product search result caching
 2. Add price calculation caching
 3. Create smart cache invalidation
@@ -133,19 +154,65 @@ return _productIndex.TryGetValue(productId, out var product) ? product : null;
 ### Using Built-in Performance Tracking
 
 The application includes performance counters that display:
+
 - Order processing times
 - Individual operation durations
 - Memory allocation patterns
 - Cache hit/miss ratios
 
 ### Running Benchmarks
 
-Use BenchmarkDotNet for detailed analysis:
+To use BenchmarkDotNet for detailed analysis, run the following command:
+
+```bash
+dotnet run -c Release -- benchmark
+```
+
+This command will run the application in Release mode and execute the benchmarks defined in your project.
+
+If you omit the `-c Release` option, the compiler defaults to Debug mode. Since the default value for `Optimize` in a Debug build is `false`, BenchmarkDotNet will detect a non‑optimized assembly. The result is a warning or error “Assembly ... is non-optimized... build it in RELEASE.”
+
+You can update the .csproj file to enable optimizations even for Debug mode so that running the app with the 'benchmark' argument via 'dotnet run' should produce valid BenchmarkDotNet results.
+
+Add the following line inside the main `<PropertyGroup>` in the .csproj file.
+
+```xml
+<Optimize>true</Optimize>
+```
+
+Without this, a Debug build shows the warning/error that the assembly is non-optimized.
+
+It's best to explicitly use Release (recommended for keeping Debug truly debuggable):
+
+```bash
+dotnet run -c Release -- benchmark
+```
+
+Warning: Always optimizing Debug can make stepping through code less intuitive. If you
+prefer traditional debugging, revert the global <Optimize>true> and instead:
+
+Run benchmarks with -c Release:
+
+```bash
+dotnet run -c Release -- benchmark
+```
+
+Or add a dedicated configuration:
+
+```xml
+<PropertyGroup Condition=\"'$(Configuration)'=='Benchmarks'\"> 
+    <Optimize>true</Optimize>
+</PropertyGroup>
+```
+
+And then run:
+
 ```bash
-dotnet run -- benchmark
+dotnet run -c Benchmarks -- benchmark
 ```
 
-This provides:
+Using BenchmarkDotNet provides:
+
 - Precise timing measurements
 - Memory allocation tracking
 - Statistical analysis
@@ -154,12 +221,14 @@ This provides:
 ### Performance Targets
 
 #### Before Optimization (Baseline)
+
 - Order processing: 2000-3000ms
 - Product lookup: 10-50ms per operation
 - Search operations: 100-500ms
 - Inventory checks: 50-200ms
 
 #### After Optimization (Target)
+
 - Order processing: <500ms
 - Product lookup: <1ms per operation
 - Search operations: <50ms
@@ -168,36 +237,46 @@ This provides:
 ## Common Optimization Patterns
 
 ### 1. Dictionary Lookups
+
 Replace linear searches with dictionary/hash table lookups:
+
 ```csharp
 // Instead of: list.FirstOrDefault(x => x.Id == id)
 // Use: dictionary.TryGetValue(id, out var item)
 ```
 
 ### 2. Batch Operations
+
 Group multiple database operations:
+
 ```csharp
 // Instead of: multiple individual queries
 // Use: single batch query with multiple IDs
 ```
 
 ### 3. Async/Await Best Practices
+
 Properly implement asynchronous operations:
+
 ```csharp
 // Instead of: Task.Wait() or .Result
 // Use: await Task.WhenAll(tasks)
 ```
 
 ### 4. Caching Strategies
+
 Implement multi-level caching:
+
 ```csharp
 // Memory cache for frequently accessed data
 // Distributed cache for shared data
 // Smart cache invalidation
 ```
 
 ### 5. Object Pooling
+
 Reuse expensive objects:
+
 ```csharp
 // Pool StringBuilder, HttpClient, etc.
 // Reduce garbage collection pressure
@@ -206,19 +285,23 @@ Reuse expensive objects:
 ## Profiling Tools Integration
 
 ### Visual Studio Diagnostic Tools
+
 - CPU Usage analysis
 - Memory Usage tracking
 - Events timeline
 - Performance tips
 
 ### dotMemory/dotTrace
+
 - Memory profiling
 - Performance profiling
 - Timeline analysis
 - Comparison reports
 
 ### Application Insights (Simulated)
+
 The application logs performance metrics that simulate:
+
 - Request/response times
 - Dependency call durations
 - Exception tracking
@@ -227,20 +310,26 @@ The application logs performance metrics that simulate:
 ## Validation and Testing
 
 ### Performance Tests
+
 Run the included performance test suite:
+
 ```bash
 dotnet test --logger trx --collect:"XPlat Code Coverage"
 ```
 
 ### Load Testing Simulation
+
 The application includes concurrent operation testing:
+
 - Multiple simultaneous orders
 - Concurrent product lookups
 - Search load testing
 - Inventory contention handling
 
 ### Regression Testing
+
 Ensure optimizations don't break functionality:
+
 - Unit test coverage >80%
 - Integration test scenarios
 - Performance benchmark baselines
@@ -249,21 +338,27 @@ Ensure optimizations don't break functionality:
 ## Real-World Considerations
 
 ### Production Deployment
+
 Consider these factors when applying optimizations:
+
 - Database connection pooling
 - CDN for static content
 - Load balancing strategies
 - Auto-scaling configurations
 
 ### Monitoring and Alerting
+
 Implement production monitoring:
+
 - Performance threshold alerts
 - Error rate monitoring
 - Resource utilization tracking
 - User experience metrics
 
 ### Security Impact
+
 Ensure optimizations don't compromise security:
+
 - Input validation performance
 - Rate limiting implementation
 - Authentication/authorization caching

DownloadableCodeProjects/standalone-lab-projects/implement-performance-profiling/ContosoOnlineStore/PERFORMANCE_GUIDE.md

@@ -84,11 +84,10 @@ Use the following steps to download the sample project and open it in Visual Stu
 
     - GHCopilotEx10LabApps\
         - ContosoOnlineStore\
-            - Benchmarks
+            - Benchmarks\
             - Configuration\
             - Exceptions\
             - Services\
-            - Tests\
             - appsettings.json
             - InventoryManager.cs
             - Orders.cs
@@ -99,6 +98,9 @@ Use the following steps to download the sample project and open it in Visual Stu
             - ProductCatalog.cs
             - Program.cs
             - README.md
+        - ContosoOnlineStore.Tests\
+            - ContosoOnlineStoreTests.cs
+            - Usings.cs
         - DataAnalyzerReporter\
 
 ## Exercise scenario