# Optimizing .NET 10 Performance: A Practical Guide to Runtime Enhancements and Production Patterns

## Executive Summary

.NET 10 represents a significant leap in runtime performance, delivering hundreds of optimizations across the JIT compiler, garbage collector, and core libraries. However, these improvements alone won’t maximize your application’s potential—you need to understand *how* to leverage them effectively.

This guide addresses a critical production challenge: many .NET developers deploy applications that leave substantial performance gains on the table. They use EF Core inefficiently, allocate unnecessarily on the heap, miss JIT optimization opportunities, and fail to measure their actual bottlenecks. The result is higher infrastructure costs, slower response times, and poor user experiences.

By mastering the techniques in this tutorial, you’ll learn to write idiomatic C# that runs at near-native speed, reduce garbage collection pressure, optimize data access patterns, and measure performance scientifically rather than guessing. These aren’t theoretical concepts—they’re production-tested patterns that directly impact your bottom line.

## Prerequisites

Before starting, ensure you have:

– **.NET 10 SDK** installed (latest version)
– **Visual Studio 2022** (v17.10+) or **Visual Studio Code** with C# Dev Kit
– **BenchmarkDotNet** NuGet package for performance measurement
– **dotnet-counters** CLI tool for runtime diagnostics
– Basic understanding of async/await, LINQ, and Entity Framework Core
– A sample project or willingness to create one for experimentation

Install the diagnostic tools:

“`bash
dotnet tool install –global dotnet-counters
dotnet tool install –global dotnet-trace
“`

## Understanding .NET 10’s Performance Foundation

### The JIT Compiler Revolution

.NET 10’s JIT compiler introduces three game-changing optimizations that directly benefit your code without requiring changes:

**Escape Analysis & Stack Allocation**: The JIT now proves when objects don’t escape method boundaries and allocates them on the stack instead of the heap. This eliminates garbage collection pressure entirely for temporary objects.

**Improved Devirtualization**: Virtual method calls are now optimized away more aggressively through guarded devirtualization (GDV) with dynamic PGO. This means your interface-based code runs closer to direct method calls.

**Enhanced Code Layout**: The JIT uses a traveling salesman problem heuristic to organize method code blocks optimally, improving instruction cache locality and reducing branch mispredictions.

These optimizations mean idiomatic C# code—using interfaces, foreach loops, and lambdas—now runs at near-native speed.

## Step-by-Step Implementation: Core Optimization Patterns

### Step 1: Eliminate Unnecessary Allocations

**The Problem**: Every heap allocation creates GC pressure. Reducing allocations is the single most impactful optimization.

**The Solution**: Use `Span`, `stackalloc`, and `ArrayPool` for temporary buffers.

// ❌ BEFORE: Multiple allocations
public class CsvProcessor
{
    public decimal CalculateSum(string csvLine)
    {
        var parts = csvLine.Split(',');
        decimal sum = 0;
        foreach (var part in parts)
        {
            if (decimal.TryParse(part, out var value))
                sum += value;
        }
        return sum;
    }
}

// ✅ AFTER: Zero allocations for the split operation
public class OptimizedCsvProcessor
{
    public decimal CalculateSum(ReadOnlySpan csvLine)
    {
        decimal sum = 0;
        var enumerator = csvLine.Split(',');
        
        foreach (var part in enumerator)
        {
            if (decimal.TryParse(part, out var value))
                sum += value;
        }
        return sum;
    }
}

// For larger buffers, use ArrayPool
public class BufferOptimizedProcessor
{
    public void ProcessLargeData(ReadOnlySpan data)
    {
        byte[] buffer = ArrayPool.Shared.Rent(data.Length);
        try
        {
            data.CopyTo(buffer);
            // Process buffer
        }
        finally
        {
            ArrayPool.Shared.Return(buffer);
        }
    }
}

### Step 2: Optimize Entity Framework Core Queries

**The Problem**: EF Core can generate inefficient SQL and load unnecessary data into memory.

**The Solution**: Use projection, `AsNoTracking()`, and split queries strategically.

// ❌ BEFORE: Loads entire entities, tracks them, causes cartesian explosion
public class OrderService
{
    private readonly AppDbContext _context;
    
    public async Task> GetOrdersWithDetails(int customerId)
    {
        return await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .Include(o => o.Items)
            .Include(o => o.Shipments)
            .ToListAsync();
    }
}

// ✅ AFTER: Projects only needed data, no tracking, split queries
public class OptimizedOrderService
{
    private readonly AppDbContext _context;
    
    public record OrderDto(int Id, string OrderNumber, decimal Total, int ItemCount);
    
    public async Task> GetOrdersWithDetails(int customerId)
    {
        return await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .AsNoTracking()
            .AsSplitQuery()
            .Select(o => new OrderDto(
                o.Id,
                o.OrderNumber,
                o.Items.Sum(i => i.Price * i.Quantity),
                o.Items.Count
            ))
            .ToListAsync();
    }
}

// For read-heavy scenarios, use compiled queries
public class CompiledQueryService
{
    private readonly AppDbContext _context;
    
    private static readonly Func> 
        GetOrdersByCustomerCompiled = EF.CompileAsyncQuery(
            (AppDbContext ctx, int customerId) =>
                ctx.Orders
                    .Where(o => o.CustomerId == customerId)
                    .AsNoTracking()
                    .Select(o => new OrderDto(
                        o.Id,
                        o.OrderNumber,
                        o.Items.Sum(i => i.Price * i.Quantity),
                        o.Items.Count
                    ))
        );
    
    public async Task> GetOrders(int customerId)
    {
        return await GetOrdersByCustomerCompiled(_context, customerId).ToListAsync();
    }
}

### Step 3: Implement Pagination for Large Datasets

**The Problem**: Loading millions of records into memory crashes your application.

**The Solution**: Always paginate, even when you think you won’t need to.

public record PaginationParams(int PageNumber = 1, int PageSize = 50)
{
    public int Skip => (PageNumber - 1) * PageSize;
    public int Take => PageSize;
}

public record PagedResult(List Items, int TotalCount, int PageNumber, int PageSize)
{
    public int TotalPages => (TotalCount + PageSize - 1) / PageSize;
    public bool HasNextPage => PageNumber < TotalPages;
    public bool HasPreviousPage => PageNumber > 1;
}

public class PaginatedQueryService
{
    private readonly AppDbContext _context;
    
    public async Task> GetOrdersPaged(
        int customerId, 
        PaginationParams pagination)
    {
        var query = _context.Orders
            .Where(o => o.CustomerId == customerId)
            .AsNoTracking();
        
        var totalCount = await query.CountAsync();
        
        var items = await query
            .OrderByDescending(o => o.CreatedDate)
            .Skip(pagination.Skip)
            .Take(pagination.Take)
            .Select(o => new OrderDto(
                o.Id,
                o.OrderNumber,
                o.Items.Sum(i => i.Price * i.Quantity),
                o.Items.Count
            ))
            .ToListAsync();
        
        return new PagedResult(
            items,
            totalCount,
            pagination.PageNumber,
            pagination.PageSize
        );
    }
}

### Step 4: Leverage Database Indexes

**The Problem**: Queries scan entire tables instead of using indexes.

**The Solution**: Create strategic indexes and verify they’re being used.

// In your DbContext configuration
public class AppDbContext : DbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Single-column index for common filters
        modelBuilder.Entity()
            .HasIndex(o => o.CustomerId)
            .HasDatabaseName("IX_Order_CustomerId");
        
        // Composite index for complex queries
        modelBuilder.Entity()
            .HasIndex(o => new { o.CustomerId, o.CreatedDate })
            .HasDatabaseName("IX_Order_Customer_CreatedDate")
            .IsDescending(false, true); // Descending on CreatedDate
        
        // Filtered index for active records only
        modelBuilder.Entity()
            .HasIndex(o => o.Status)
            .HasFilter("[Status] != 'Cancelled'")
            .HasDatabaseName("IX_Order_ActiveStatus");
    }
}

// Verify index usage with SQL
public class IndexAnalysisService
{
    private readonly AppDbContext _context;
    
    public async Task> AnalyzeQueryPlan(string query)
    {
        var connection = _context.Database.GetDbConnection();
        await connection.OpenAsync();
        
        using var command = connection.CreateCommand();
        command.CommandText = $"SET STATISTICS IO ON; {query}";
        
        var reader = await command.ExecuteReaderAsync();
        // Parse execution plan to verify index usage
        
        return new List { /* results */ };
    }
}

### Step 5: Implement Batch Operations

**The Problem**: Updating 10,000 records one-by-one generates 10,000 database round trips.

**The Solution**: Use batch updates and deletes without loading entities.

public class BatchOperationService
{
    private readonly AppDbContext _context;
    
    // ❌ BEFORE: Loads all entities into memory
    public async Task UpdateOrderStatusSlow(int customerId, string newStatus)
    {
        var orders = await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .ToListAsync();
        
        foreach (var order in orders)
        {
            order.Status = newStatus;
        }
        
        await _context.SaveChangesAsync();
    }
    
    // ✅ AFTER: Single database operation
    public async Task UpdateOrderStatusFast(int customerId, string newStatus)
    {
        await _context.Orders
            .Where(o => o.CustomerId == customerId)
            .ExecuteUpdateAsync(s => s.SetProperty(o => o.Status, newStatus));
    }
    
    // Batch delete without loading
    public async Task DeleteCancelledOrders(int daysOld)
    {
        var cutoffDate = DateTime.UtcNow.AddDays(-daysOld);
        
        await _context.Orders
            .Where(o => o.Status == "Cancelled" && o.CreatedDate < cutoffDate)
            .ExecuteDeleteAsync();
    }
}

### Step 6: Optimize Async I/O Operations

**The Problem**: Blocking threads on I/O operations wastes server resources.

**The Solution**: Use async/await properly with `ConfigureAwait(false)`.

public class AsyncOptimizedService
{
    private readonly HttpClient _httpClient;
    
    // ✅ CORRECT: Async all the way, ConfigureAwait for libraries
    public async Task> FetchMultipleUsersOptimized(
        IEnumerable userIds,
        CancellationToken cancellationToken = default)
    {
        var tasks = userIds
            .Select(id => FetchUserAsync(id, cancellationToken))
            .ToList();
        
        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
        return results.ToList();
    }
    
    private async Task FetchUserAsync(
        int userId,
        CancellationToken cancellationToken)
    {
        var response = await _httpClient
            .GetAsync($"/api/users/{userId}", cancellationToken)
            .ConfigureAwait(false);
        
        var content = await response.Content
            .ReadAsStringAsync(cancellationToken)
            .ConfigureAwait(false);
        
        return JsonSerializer.Deserialize(content)!;
    }
    
    // ❌ WRONG: Mixing sync and async
    public List FetchMultipleUsersWrong(IEnumerable userIds)
    {
        return userIds
            .Select(id => FetchUserAsync(id).Result) // Blocks thread!
            .ToList();
    }
}

### Step 7: Measure Performance Scientifically

**The Problem**: Guessing about performance leads to wasted optimization efforts.

**The Solution**: Use BenchmarkDotNet for rigorous measurement.

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[SimpleJob(warmupCount: 3, targetCount: 5)]
public class PerformanceBenchmarks
{
    private string _csvData = "1.5,2.3,4.7,8.9,3.2,5.1,6.8,9.2,1.1,7.3";
    
    [Benchmark(Baseline = true)]
    public decimal StringSplitApproach()
    {
        var parts = _csvData.Split(',');
        decimal sum = 0;
        foreach (var part in parts)
        {
            if (decimal.TryParse(part, out var value))
                sum += value;
        }
        return sum;
    }
    
    [Benchmark]
    public decimal SpanApproach()
    {
        decimal sum = 0;
        var enumerator = _csvData.AsSpan().Split(',');
        foreach (var part in enumerator)
        {
            if (decimal.TryParse(part, out var value))
                sum += value;
        }
        return sum;
    }
}

// Run benchmarks
public class Program
{
    public static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run();
    }
}

## Production-Ready ASP.NET Core Optimization

### Implementing Rate Limiting and Request Timeouts

using Microsoft.AspNetCore.RateLimiting;
using Microsoft.AspNetCore.Http.Timeouts;
using System.Threading.RateLimiting;

var builder = WebApplication.CreateBuilder(args);

// Configure rate limiting policies
builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("standard", opt =>
    {
        opt.PermitLimit = 100;
        opt.Window = TimeSpan.FromSeconds(60);
        opt.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        opt.QueueLimit = 50;
    });
    
    options.AddSlidingWindowLimiter("premium", opt =>
    {
        opt.PermitLimit = 500;
        opt.Window = TimeSpan.FromSeconds(60);
        opt.SegmentsPerWindow = 6;
    });
    
    options.OnRejected = async (context, token) =>
    {
        context.HttpContext.Response.StatusCode = StatusCodes.Status429TooManyRequests;
        await context.HttpContext.Response.WriteAsJsonAsync(
            new { error = "Rate limit exceeded" },
            cancellationToken: token
        );
    };
});

// Configure request timeouts
builder.Services.AddRequestTimeouts(options =>
{
    options.DefaultPolicy = new RequestTimeoutPolicy
    {
        Timeout = TimeSpan.FromSeconds(30)
    };
});

var app = builder.Build();

// Apply middleware
app.UseRateLimiter();
app.UseRequestTimeouts();

// Endpoints with specific policies
app.MapGet("/api/fast-operation", async (HttpContext ctx) =>
{
    await Task.Delay(100);
    return Results.Ok(new { message = "Completed quickly" });
})
.WithName("FastOperation")
.WithRequestTimeout(TimeSpan.FromSeconds(5))
.RequireRateLimiting("standard");

app.MapPost("/api/heavy-processing", async (HttpContext ctx) =>
{
    await Task.Delay(5000);
    return Results.Ok(new { message = "Heavy processing complete" });
})
.WithName("HeavyProcessing")
.WithRequestTimeout(TimeSpan.FromSeconds(30))
.RequireRateLimiting("premium");

app.Run();

### Optimizing JSON Serialization

using System.Text.Json;
using System.Text.Json.Serialization;

// Use source generation for compile-time optimization
[JsonSerializable(typeof(OrderDto))]
[JsonSerializable(typeof(List))]
public partial class AppJsonSerializerContext : JsonSerializerContext
{
}

public class OptimizedJsonService
{
    private static readonly JsonSerializerOptions Options = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
        WriteIndented = false, // Disable for production
        TypeInfoResolver = new AppJsonSerializerContext().TypeInfoResolver
    };
    
    public string SerializeOrder(OrderDto order)
    {
        return JsonSerializer.Serialize(order, Options);
    }
    
    public OrderDto DeserializeOrder(string json)
    {
        return JsonSerializer.Deserialize(json, Options)!;
    }
}

// Use Minimal APIs for lightweight endpoints
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/api/orders/{id}", async (int id, AppDbContext db) =>
{
    var order = await db.Orders
        .AsNoTracking()
        .FirstOrDefaultAsync(o => o.Id == id);
    
    return order is null
        ? Results.NotFound()
        : Results.Ok(order);
})
.WithName("GetOrder")
.WithOpenApi()
.Produces(StatusCodes.Status200OK)
.Produces(StatusCodes.Status404NotFound);

app.Run();

## Common Pitfalls & Troubleshooting

### Pitfall 1: Forgetting `ConfigureAwait(false)` in Libraries

**Problem**: Your library code captures the synchronization context, blocking thread pool threads.

**Solution**: Always use `ConfigureAwait(false)` in library code.

```csharp
// ❌ WRONG
public async Task GetDataAsync()
{
var response = await _httpClient.GetAsync(url);
return await response.Content.ReadAsAsync();
}

// ✅ CORRECT
public async Task GetDataAsync()
{
var response = await _httpClient.GetAsync(url).ConfigureAwait(false);
return await response.Content.ReadAsAsync().ConfigureAwait(false);
}
```

### Pitfall 2: Using `Include()` Without Understanding Cartesian Explosion

**Problem**: Including multiple collections creates a cartesian product, multiplying result rows.

**Solution**: Use `AsSplitQuery()` or project instead.

```csharp
// ❌ WRONG: Returns 1000 rows instead of 10
var orders = await _context.Orders
.Include(o => o.Items) // 10 items per order
.Include(o => o.Shipments) // 10 shipments per order
.Take(10)
.ToListAsync();

// ✅ CORRECT
var orders = await _context.Orders
.AsSplitQuery()
.Include(o => o.Items)
.Include(o => o.Shipments)
.Take(10)
.ToListAsync();
```

### Pitfall 3: Tracking Entities When You Only Need to Read

**Problem**: Change tracking adds overhead for read-only queries.

**Solution**: Use `AsNoTracking()` for queries that don't modify data.

```csharp
// ❌ WRONG: Unnecessary tracking overhead
var reports = await _context.Reports
.Where(r => r.Date > cutoff)
.ToListAsync();

// ✅ CORRECT
var reports = await _context.Reports
.AsNoTracking()
.Where(r => r.Date > cutoff)
.ToListAsync();
```

### Pitfall 4: Creating New HttpClient Instances

**Problem**: Each HttpClient instance creates a socket, exhausting system resources.

**Solution**: Reuse a single instance or use HttpClientFactory.

```csharp
// ❌ WRONG: Socket exhaustion
public class BadService
{
public async Task FetchData(string url)
{
using var client = new HttpClient();
return await client.GetStringAsync(url);
}
}

// ✅ CORRECT: Reuse instance
public class GoodService
{
private static readonly HttpClient Client = new();

public async Task FetchData(string url)
{
return await Client.GetStringAsync(url);
}
}

// ✅ BEST: Use HttpClientFactory in ASP.NET Core
public class BestService
{
private readonly IHttpClientFactory _factory;

public BestService(IHttpClientFactory factory) => _factory = factory;

public async Task FetchData(string url)
{
var client = _factory.CreateClient();
return await client.GetStringAsync(url);
}
}
```

### Pitfall 5: Not Measuring Before Optimizing

**Problem**: You optimize the wrong code path, wasting effort.

**Solution**: Profile first, optimize second.

```csharp
// Use dotnet-counters to identify bottlenecks
// dotnet-counters monitor -p System.Runtime

// Or use BenchmarkDotNet to compare approaches
[Benchmark]
public void Approach1() { /* ... */ }

[Benchmark]
public void Approach2() { /* ... */ }
```

## Performance & Scalability Considerations

### Monitoring in Production

Implement comprehensive monitoring to catch performance regressions:

using System.Diagnostics;

public class PerformanceMonitoringMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
    
    public PerformanceMonitoringMiddleware(
        RequestDelegate next,
        ILogger logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            await _next(context);
        }
        finally
        {
            stopwatch.Stop();
            
            if (stopwatch.ElapsedMilliseconds > 1000)
            {
                _logger.LogWarning(
                    "Slow request: {Method} {Path} took {ElapsedMs}ms",
                    context.Request.Method,
                    context.Request.Path,
                    stopwatch.ElapsedMilliseconds
                );
            }
        }
    }
}

// Register in Startup
app.UseMiddleware();

### Caching Strategy

Implement multi-level caching for scalability:

public class CachingService
{
    private readonly IMemoryCache _memoryCache;
    private readonly IDistributedCache _distributedCache;
    private readonly AppDbContext _context;
    
    public async Task GetOrderWithCaching(int orderId)
    {
        const string cacheKey = $"order_{orderId}";
        
        // L1: In-process memory cache (fastest)
        if (_memoryCache.TryGetValue(cacheKey, out OrderDto? cached))
            return cached!;
        
        // L2: Distributed cache (Redis, etc.)
        var distributedData = await _distributedCache.GetStringAsync(cacheKey);
        if (distributedData is not null)
        {
            var order = JsonSerializer.Deserialize(distributedData)!;
            _memoryCache.Set(cacheKey, order, TimeSpan.FromMinutes(5));
            return order;
        }
        
        // L3: Database
        var dbOrder = await _context.Orders
            .AsNoTracking()
            .FirstOrDefaultAsync(o => o.Id == orderId);
        
        if (dbOrder is not null)
        {
            var dto = MapToDto(dbOrder);
            
            // Populate both caches
            _memoryCache.Set(cacheKey, dto, TimeSpan.FromMinutes(5));
            await _distributedCache.SetStringAsync(
                cacheKey,
                JsonSerializer.Serialize(dto),
                new DistributedCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
                }
            );
            
            return dto;
        }
        
        throw new InvalidOperationException($"Order {orderId} not found");
    }
    
    private OrderDto MapToDto(Order order) => new(
        order.Id,
        order.OrderNumber,
        order.Items.Sum(i => i.Price * i.Quantity),
        order.Items.Count
    );
}

## Practical Best Practices

### 1. Use Dependency Injection for Testability

```csharp
// Register services with appropriate lifetimes
builder.Services.AddScoped();
builder.Services.AddSingleton();
builder.Services.AddHttpClient();
```

### 2. Implement Structured Logging

```csharp
public class OrderService
{
private readonly ILogger _logger;

public async Task GetOrderAsync(int orderId)
{
using var activity = new Activity("GetOrder").Start();
activity?.SetTag("order.id", orderId);

_logger.LogInformation(
"Fetching order {OrderId}",
orderId
);

// Implementation
}
}
```

### 3. Use Records for DTOs

```csharp
// Records provide value semantics and immutability
public record OrderDto(
int Id,
string OrderNumber,
decimal Total,
int ItemCount
);

// With validation
public record CreateOrderRequest(
int CustomerId,
List Items)
{
public void Validate()
{
if (CustomerId <= 0) throw new ArgumentException("Invalid customer ID"); if (Items.Count == 0) throw new ArgumentException("Order must have items"); } } ``` ### 4. Implement Proper Error Handling ```csharp public class ErrorHandlingMiddleware { private readonly RequestDelegate _next; private readonly ILogger _logger;

public async Task InvokeAsync(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
_logger.LogError(ex, "Unhandled exception");

context.Response.ContentType = "application/json";
context.Response.StatusCode = StatusCodes.Status500InternalServerError;

await context.Response.WriteAsJsonAsync(new
{
error = "An error occurred",
traceId = context.TraceIdentifier
});
}
}
}
```

## Conclusion

.NET 10 provides unprecedented performance capabilities, but realizing them requires understanding both the runtime optimizations and the patterns that leverage them effectively. The techniques in this guide—eliminating allocations, optimizing queries, measuring scientifically, and implementing proper caching—form the foundation of high-performance .NET applications.

**Your next steps**:

1. **Profile your current application** using dotnet-counters and BenchmarkDotNet to identify actual bottlenecks
2. **Apply the most impactful optimizations first**: database query optimization typically yields 10-100x improvements
3. **Measure continuously** to ensure optimizations deliver expected results
4. **Implement monitoring** in production to catch regressions early
5. **Stay current** with .NET 10 release notes and performance blogs as new optimizations emerge

Remember: premature optimization is the root of all evil, but measured optimization is the path to production excellence.

---

## Frequently Asked Questions

### Q1: Should I use `AsNoTracking()` for all queries?

**A**: Use `AsNoTracking()` for read-only queries where you don't modify data. For queries where you'll call `SaveChangesAsync()`, keep tracking enabled. The overhead is minimal for small result sets but significant for large queries.

### Q2: When should I use `AsSplitQuery()` vs. `Include()`?

**A**: Use `AsSplitQuery()` when including multiple collections to avoid cartesian explosion. Use regular `Include()` for single collections or when you know the relationship is one-to-one. Split queries execute multiple database round trips but return correct result counts.

### Q3: Is `Span` always faster than arrays?

**A**: `Span` is faster for temporary operations because it can use stack allocation and avoids GC pressure. However, you cannot store `Span` in fields or return it from async methods. Use `Memory` for those scenarios.

### Q4: How do I know if my indexes are being used?

**A**: Enable SQL query statistics in your database and examine execution plans. In SQL Server, use `SET STATISTICS IO ON`. In EF Core, use `context.Database.Log` to see generated SQL.

### Q5: Should I always use `ConfigureAwait(false)`?

**A**: Yes, in library code. In ASP.NET Core applications, it's less critical because there's no synchronization context, but it's still a good habit. Never omit it in libraries that might be used in UI applications.

### Q6: What's the difference between `Task.WhenAll()` and `Task.Run()`?

**A**: `Task.WhenAll()` waits for multiple async operations concurrently without blocking threads. `Task.Run()` schedules work on the thread pool. Use `WhenAll()` for I/O-bound operations and `Run()` for CPU-bound work.

### Q7: How do I choose between memory cache and distributed cache?

**A**: Use memory cache for small, frequently accessed data that's local to a single server. Use distributed cache (Redis) for data shared across multiple servers or when you need cache invalidation across instances.

### Q8: Can I use compiled queries with dynamic LINQ?

**A**: No, compiled queries require static expressions. For dynamic queries, use regular LINQ to Entities and rely on the JIT compiler's optimizations.

### Q9: What's the performance impact of using interfaces vs. concrete types?

**A**: In .NET 10, the JIT compiler optimizes interface calls through devirtualization, making the performance difference negligible for most scenarios. Use interfaces for design flexibility without performance concerns.

### Q10: How do I handle pagination efficiently for large datasets?

**A**: Always use `Skip()` and `Take()` with a reasonable page size (typically 20-100 items). Avoid `OrderBy()` without indexes. Consider keyset pagination for very large datasets where offset becomes expensive.