Mimante/.github/upgrades/plan.md

.NET 10.0 Upgrade Plan — AutoBidder Solution

Table of Contents

• 1. Executive Summary
• 2. Migration Strategy
• 3. Detailed Dependency Analysis
• 4. Project-by-Project Plans
  • 4.1 AutoBidder.csproj
• 5. Package Update Reference
• 6. Breaking Changes Catalog
• 7. Risk Management
• 8. Testing & Validation Strategy
• 9. Complexity & Effort Assessment
• 10. Source Control Strategy
• 11. Success Criteria

---

1. Executive Summary

Scenario

Upgrade the AutoBidder Blazor/ASP.NET Core solution from .NET 8.0 to .NET 10.0 (LTS).

Scope

Metric	Value
Total Projects	1
Total NuGet Packages	3 (2 need upgrade, 1 compatible)
Total Lines of Code	14,361
Total Code Files	50
API Incompatibilities	0
Security Vulnerabilities	0
Estimated LOC Impact	0+ (minimal)

Target State

• All projects targeting net10.0
• All NuGet packages updated to .NET 10 compatible versions
• Solution builds with 0 errors
• No security vulnerabilities

Selected Strategy

All-At-Once Strategy — All projects upgraded simultaneously in a single atomic operation.

Rationale:

• 1 project (small solution)
• Currently on .NET 8.0 (modern SDK-style)
• Zero project-to-project dependencies
• All packages have known target framework versions available
• No API incompatibilities detected
• No security vulnerabilities

Complexity Classification

Simple — 1 project, dependency depth 0, no high-risk indicators, no vulnerabilities.

Iteration strategy: Fast batch (2-3 detail iterations covering all sections).

Critical Issues

• ?? Npgsql.EntityFrameworkCore.PostgreSQL 8.0.0 is marked compatible but has no suggested new version — verify compatibility with EF Core 10.0.5 at build time.

2. Migration Strategy

Approach: All-At-Once

The entire solution is upgraded in a single coordinated atomic operation. There are no intermediate states — the project file, all package references, and any required code modifications are applied together.

Justification

• 1 project — no dependency ordering complexity
• 0 inter-project dependencies — no phasing required
• 0 API incompatibilities — minimal risk of breaking changes
• Low difficulty rating from assessment
• SDK-style project — clean project file structure
• All packages have target versions or are compatible

Execution Approach

All operations are performed as a unified upgrade:

1. Update TargetFramework in AutoBidder.csproj from net8.0 to net10.0
2. Update all NuGet package references to their target versions
3. Restore dependencies
4. Build the solution and fix all compilation errors
5. Verify solution builds with 0 errors

No parallel vs sequential decision is needed — there is only one project.

3. Detailed Dependency Analysis

Dependency Graph

The solution contains a single project with no inter-project dependencies.

Level 0 (Foundation):
  ??? AutoBidder.csproj (AspNetCore, Blazor)
        ??? Microsoft.AspNetCore.Identity.EntityFrameworkCore 8.0.0
        ??? Microsoft.EntityFrameworkCore.Sqlite 8.0.0
        ??? Npgsql.EntityFrameworkCore.PostgreSQL 8.0.0

Project Groupings

Since there is only 1 project with 0 dependencies, all work is performed in a single atomic operation with no phasing required.

Phase	Projects	Description
Phase 1: Atomic Upgrade	AutoBidder.csproj	Framework + packages upgrade, build, fix errors

Critical Path

There is no critical path — the single project is both leaf and root. The entire upgrade is a single step.

Circular Dependencies

None detected.

4. Project-by-Project Plans

4.1 AutoBidder.csproj

Current State

Attribute	Value
Target Framework	net8.0
Project Kind	AspNetCore (Blazor)
SDK-style	Yes
Lines of Code	14,361
Code Files	50 (76 total files)
NuGet Packages	3
Project Dependencies	0
Dependants	0
Risk Level	?? Low

Target State

Attribute	Value
Target Framework	net10.0
Updated Packages	2 of 3

Migration Steps

1. Prerequisites

• .NET 10 SDK installed ?
• No global.json to update ?

2. Framework Update

• Update TargetFramework property in AutoBidder.csproj from net8.0 to net10.0

3. Package Updates

Package	Current Version	Target Version	Reason
Microsoft.AspNetCore.Identity.EntityFrameworkCore	8.0.0	10.0.5	Upgrade recommended for .NET 10 compatibility
Microsoft.EntityFrameworkCore.Sqlite	8.0.0	10.0.5	Upgrade recommended for .NET 10 compatibility
Npgsql.EntityFrameworkCore.PostgreSQL	8.0.0	(keep)	? Compatible — verify at build time with EF Core 10.0.5

4. Expected Breaking Changes

• No API incompatibilities detected by assessment
• Potential behavioral changes from EF Core 8 ? 10 (see §6 Breaking Changes Catalog)
• Potential ASP.NET Core / Blazor configuration or middleware changes

5. Code Modifications

• No code modifications identified by the assessment (0 estimated LOC impact)
• Compilation errors (if any) will be discovered and fixed during the build step

6. Validation Checklist

• AutoBidder.csproj targets net10.0
• All package references updated to target versions
• Solution restores without dependency conflicts
• Solution builds with 0 errors
• No security vulnerabilities

5. Package Update Reference

Common Package Updates (affecting AutoBidder.csproj)

Package	Current	Target	Update Reason
Microsoft.AspNetCore.Identity.EntityFrameworkCore	8.0.0	10.0.5	Framework compatibility — align with .NET 10
Microsoft.EntityFrameworkCore.Sqlite	8.0.0	10.0.5	Framework compatibility — align with .NET 10

Compatible Packages (no update required)

Package	Current Version	Status
Npgsql.EntityFrameworkCore.PostgreSQL	8.0.0	? Compatible — verify at build time that it works with EF Core 10.0.5

Notes

• All EF Core-related packages should align to the same major version where possible
• Npgsql.EntityFrameworkCore.PostgreSQL 8.0.0 is marked compatible by the assessment; however, if build errors occur related to EF Core version mismatch, investigate whether a newer Npgsql version is required

6. Breaking Changes Catalog

The assessment detected 0 API incompatibilities. However, the following areas should be monitored during the build and test phases:

Framework Breaking Changes (.NET 8 ? .NET 10)

Area	Risk	Description
ASP.NET Core / Blazor	Low	Possible middleware, routing, or configuration changes between .NET 8 and .NET 10
Entity Framework Core 8 ? 10	Low	Possible behavioral changes in query translation, migrations, or model building
Base Class Library (BCL)	Low	Minor API behavioral changes possible

Package-Specific Considerations

Package	Consideration
Npgsql.EntityFrameworkCore.PostgreSQL 8.0.0	Verify compatibility with EF Core 10.0.5 — if incompatible, investigate newer Npgsql version
Microsoft.AspNetCore.Identity.EntityFrameworkCore 10.0.5	Identity API changes possible between major versions

Discovery Approach

Since no specific breaking changes were identified, the primary discovery mechanism is:

1. Build the solution after all updates
2. Analyze compilation errors
3. Fix identified issues referencing .NET 10 migration documentation

7. Risk Management

Risk Assessment

Project	Risk Level	Description	Mitigation
AutoBidder.csproj	?? Low	Single project, 0 API issues, 2 straightforward package updates	Standard upgrade process; rollback via Git if needed

Specific Risks

Risk	Probability	Impact	Mitigation
Npgsql EF Core compatibility	Low	Medium	If build fails due to EF Core version mismatch, upgrade Npgsql to a .NET 10-compatible version
Undiscovered breaking changes in Blazor/ASP.NET Core	Low	Low	Fix compilation errors during build step; consult .NET 10 migration guide
EF Core migration compatibility	Low	Medium	Verify existing database migrations still apply correctly with EF Core 10

Contingency Plans

• Build failures from Npgsql: Search for a newer version of Npgsql.EntityFrameworkCore.PostgreSQL compatible with EF Core 10. If none exists, evaluate alternative PostgreSQL providers.
• Unexpected compilation errors: Use .NET 10 breaking changes documentation to resolve. The upgrade branch isolates all changes — the docker branch remains untouched.
• Rollback: Discard the upgrade-to-NET10 branch and return to docker branch.

8. Testing & Validation Strategy

Build Validation

After the atomic upgrade:

• dotnet restore completes without dependency conflicts
• dotnet build completes with 0 errors
• No new warnings related to deprecated APIs

Test Execution

No dedicated test projects were identified in the solution. Validation relies on:

1. Successful build with 0 errors
2. No dependency conflicts
3. No security vulnerabilities

?? Recommendation: If there are test projects not captured in the solution file, or integration/manual tests, execute them after the upgrade to verify runtime behavior — particularly around Entity Framework Core database operations and Blazor component rendering.

9. Complexity & Effort Assessment

Per-Project Complexity

Project	Complexity	Dependencies	Package Updates	Risk	Notes
AutoBidder.csproj	?? Low	0 projects	2 packages	Low	Single project, no API issues, straightforward upgrade

Overall Assessment

Factor	Rating
Solution Complexity	Low (1 project, 0 dependencies)
Package Update Complexity	Low (2 packages with known target versions)
Breaking Change Risk	Low (0 API incompatibilities detected)
Testing Complexity	Low (build verification only — no test projects)
Overall Upgrade Complexity	Low

10. Source Control Strategy

Branching

Parameter	Value
Source branch	docker
Upgrade branch	upgrade-to-NET10
Strategy	Single branch for all upgrade changes

Commit Approach

Single commit for the entire atomic upgrade operation:

• Framework update, package updates, compilation fixes — all in one commit
• Commit message: Upgrade to .NET 10.0 — update framework and packages

Merge Process

1. Verify solution builds with 0 errors on upgrade-to-NET10
2. Merge upgrade-to-NET10 into docker (or open a Pull Request for review)
3. Delete upgrade-to-NET10 branch after successful merge

11. Success Criteria

Technical Criteria

• AutoBidder.csproj targets net10.0
• Microsoft.AspNetCore.Identity.EntityFrameworkCore updated to 10.0.5
• Microsoft.EntityFrameworkCore.Sqlite updated to 10.0.5
• Npgsql.EntityFrameworkCore.PostgreSQL compatible (build succeeds)
• Solution builds with 0 errors
• No package dependency conflicts
• No security vulnerabilities

Quality Criteria

• Code quality maintained (no degraded patterns)
• No new compiler warnings from deprecated APIs

Process Criteria

• All-At-Once strategy followed (single atomic operation)
• All changes on upgrade-to-NET10 branch
• Single commit for entire upgrade