dotnet-modernize

Analyze existing .NET code for modernization opportunities. Identifies outdated target frameworks, deprecated packages, superseded API patterns, and missing modern best practices. Provides actionable recommendations for each finding.

Scope

• Outdated target framework detection
• Deprecated package identification
• Superseded API pattern flagging
• Actionable modernization recommendations

Out of scope

• Actual migration paths and polyfill strategies — see [skill:dotnet-version-upgrade]
• Multi-targeting guidance — see [skill:dotnet-multi-targeting]

Prerequisites: Run [skill:dotnet-version-detection] first to determine the current SDK, TFM, and language version. Run [skill:dotnet-project-analysis] to understand solution structure and dependencies.

Cross-references: [skill:dotnet-project-structure] for modern layout conventions, [skill:dotnet-add-analyzers] for analyzer-based detection of deprecated patterns, [skill:dotnet-scaffold-project] for the target state of a fully modernized project.

Modernization Checklist

Run through this checklist against the existing codebase. Each section identifies what to look for and what the modern replacement is.

1. Target Framework

Check <TargetFramework> in .csproj files (or Directory.Build.props):

To scan all projects:

# Find all TFMs in the solution
find . -name "*.csproj" -exec grep -h "TargetFramework" {} \; | sort -u

# Check Directory.Build.props
grep "TargetFramework" Directory.Build.props 2>/dev/null

2. Deprecated and Superseded Packages

Scan Directory.Packages.props (or individual .csproj files) for packages that have been superseded:

To scan for deprecated packages:

# List all package references
grep -rh "PackageVersion\|PackageReference" \
  Directory.Packages.props $(find . -name "*.csproj") 2>/dev/null | \
  grep -i "Include=" | sort -u

Note on Newtonsoft.Json: Existing projects with deep Newtonsoft.Json usage (custom converters, JObject manipulation) may not benefit from immediate migration. Flag it but assess the migration cost.

3. Superseded API Patterns

Look for code patterns that have modern replacements:

Startup.cs / Program.cs Pattern

Old (pre-.NET 6):

public class Startup
{
    public void ConfigureServices(IServiceCollection services) { }
    public void Configure(IApplicationBuilder app) { }
}

Modern (minimal hosting):

var builder = WebApplication.CreateBuilder(args);
// ConfigureServices equivalent
var app = builder.Build();
// Configure equivalent
app.Run();

HttpClient Registration

Old:

services.AddHttpClient<MyService>(client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
})
.AddTransientHttpErrorPolicy(p => p.WaitAndRetryAsync(3, _ => TimeSpan.FromMilliseconds(300)));

Modern (with Microsoft.Extensions.Resilience):

services.AddHttpClient<MyService>(client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
})
.AddStandardResilienceHandler();

Synchronous I/O

Flag: File.ReadAllText, Stream.Read, HttpClient without Async suffix.

Modern: Use async variants — File.ReadAllTextAsync, Stream.ReadAsync, await httpClient.GetAsync().

String Concatenation in Hot Paths

Flag: String concatenation (+) or String.Format in logging, loops.

Modern: Use string interpolation with LoggerMessage source generators, or StringBuilder.

Legacy Collection Patterns

Flag: Hashtable, ArrayList, non-generic collections.

Modern: Dictionary<TKey, TValue>, List<T>, generic collections.

ILogger Pattern

Old:

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

Modern (high-performance):

[LoggerMessage(Level = LogLevel.Information, Message = "Processing order {OrderId}")]
static partial void LogProcessingOrder(ILogger logger, string orderId);

4. Missing Modern Build Configuration

Check for the absence of recommended build infrastructure:

5. Deprecated C# Language Patterns

6. Security and Compliance

# Run all NuGet audits
dotnet list package --vulnerable --include-transitive
dotnet list package --deprecated
dotnet list package --outdated

Running a Modernization Scan

Combine the checks into a systematic scan:

# 1. Check TFMs
echo "=== Target Frameworks ==="
find . -name "*.csproj" -exec grep -Hl "TargetFramework" {} \; | while read f; do
  echo "$f: $(grep -o '<TargetFramework[s]*>[^<]*' "$f" | head -1)"
done

# 2. Check for deprecated packages
echo "=== Package Audit ==="
dotnet list package --deprecated 2>/dev/null
dotnet list package --vulnerable --include-transitive 2>/dev/null

# 3. Check build infrastructure
echo "=== Build Infrastructure ==="
test -f Directory.Build.props && echo "OK: Directory.Build.props" || echo "MISSING: Directory.Build.props"
test -f Directory.Packages.props && echo "OK: Directory.Packages.props (CPM)" || echo "MISSING: Directory.Packages.props"
test -f .editorconfig && echo "OK: .editorconfig" || echo "MISSING: .editorconfig"
test -f global.json && echo "OK: global.json" || echo "MISSING: global.json"
test -f nuget.config && echo "OK: nuget.config" || echo "MISSING: nuget.config"

# 4. Check for old patterns in code
echo "=== Code Patterns ==="
grep -rl "class Startup" --include="*.cs" . 2>/dev/null && echo "FOUND: Legacy Startup.cs pattern"
grep -rl "Microsoft.Extensions.Http.Polly" --include="*.csproj" --include="*.props" . 2>/dev/null && echo "FOUND: Deprecated Polly package"
grep -rl "Swashbuckle" --include="*.csproj" --include="*.props" . 2>/dev/null && echo "FOUND: Swashbuckle (consider built-in OpenAPI for .NET 9+)"
grep -rl "System.Data.SqlClient" --include="*.csproj" --include="*.props" . 2>/dev/null && echo "FOUND: System.Data.SqlClient (use Microsoft.Data.SqlClient)"

Prioritizing Modernization

Not all modernization is equally urgent. Prioritize by impact:

1. Security — vulnerable packages, end-of-life TFMs (no security patches)
2. Supportability — deprecated packages with no upstream maintenance
3. Performance — patterns with significant perf impact (sync-over-async, legacy collections in hot paths)
4. Developer experience — build infrastructure (CPM, analyzers, editorconfig) improves daily workflow
5. Code style — language pattern updates are lowest priority but reduce cognitive load over time

What’s Next

This skill flags modernization opportunities. For executing upgrades:

• TFM version upgrades and migration paths — [skill:dotnet-version-upgrade]
• Multi-targeting strategies — [skill:dotnet-multi-targeting]
• Polyfill packages for cross-version support — [skill:dotnet-multi-targeting]
• Adding missing build infrastructure — [skill:dotnet-project-structure], [skill:dotnet-scaffold-project]
• Configuring analyzers — [skill:dotnet-add-analyzers]
• Adding CI/CD — [skill:dotnet-add-ci]

References

• .NET Support Policy
• Breaking Changes in .NET
• .NET Upgrade Assistant
• NuGet Package Vulnerability Auditing
• Modern C# Features