Migrating from .NET Framework to Modern .NET: A Planning Guide
How to plan a move from .NET Framework to modern .NET: assessing dependencies, Web Forms and WCF, choosing a migration strategy, testing and running both side by side.

In this article
- Why Migrate
- Step 1: Assess the Application
- Step 2: Understand the Hard Parts
- Step 3: Choose a Strategy
- Step 4: Build a Safety Net
- Step 5: Move Shared Code First
- Step 6: Plan Hosting and Operations
- Step 7: Cut Over Gradually
- Cost and Timeline Considerations
- Recommendations
- How Webespire Consulting Can Help
- Frequently Asked Questions
- Conclusion
Migrating from .NET Framework to modern .NET (the cross-platform successor that began as .NET Core) gives applications better performance, Linux and container hosting options, current language features and an active release cadence. .NET Framework 4.8.x still receives security fixes as a Windows component, so the move is rarely an emergency, but new development and libraries increasingly target modern .NET only. A successful migration starts with a dependency and technology assessment, then moves the application incrementally, with automated tests protecting behaviour at every step.
Why Migrate
- Platform direction. Microsoft's new features, performance work and most new library versions target modern .NET. .NET Framework 4.8.1 is the final major version.
- Hosting flexibility. Modern .NET runs on Linux and in containers, which can reduce hosting costs and simplify cloud deployment.
- Performance. Many workloads run faster with lower memory use on modern runtimes.
- Talent. Developers prefer current tooling, which helps hiring and retention.
Plan around Microsoft's support policy: modern .NET has long-term support (LTS) releases with three years of support and standard-term releases with shorter support. Target a current LTS version and budget for upgrading between versions every few years. Check the .NET support policy for current dates.
Step 1: Assess the Application
Build an inventory:
- Project types: ASP.NET MVC, Web API, Web Forms, WCF services, Windows services, WinForms or WPF desktop apps, class libraries.
- NuGet packages and whether modern versions or replacements exist.
- Windows-specific dependencies: registry access, COM components, Windows authentication, GDI+ drawing.
- Data access: Entity Framework 6, ADO.NET, stored procedures.
- Configuration and deployment: web.config transforms, IIS settings, scheduled tasks.
Microsoft's .NET Upgrade Assistant and portability analysis tools help identify incompatible APIs and packages.
Step 2: Understand the Hard Parts
| Technology | Situation in modern .NET | Typical path |
|---|---|---|
| ASP.NET MVC / Web API | Replaced by ASP.NET Core | Port controllers and views; rework middleware, auth and configuration |
| ASP.NET Web Forms | Not available | Rewrite pages in Razor Pages, MVC or Blazor, usually incrementally |
| WCF server | Not included | Move to gRPC or REST, or use the community CoreWCF project |
| Entity Framework 6 | EF6 can run on modern .NET; EF Core is the forward path | Keep EF6 initially, migrate to EF Core later if worthwhile |
| WinForms / WPF | Supported on Windows | Port project files and dependencies; stays Windows-only |
| System.Web dependencies | Not available | Replace with ASP.NET Core equivalents |
Web Forms and heavy WCF use usually dominate the effort.
Step 3: Choose a Strategy
- In-place upgrade. Suitable for class libraries and well-structured MVC or Web API apps. Convert project files to SDK style, multi-target where helpful, fix incompatibilities and switch.
- Incremental side-by-side migration. Run a new ASP.NET Core application next to the old one and move routes or features one at a time, with a proxy sending traffic to whichever app owns each route. Microsoft documents this approach using YARP for ASP.NET applications. This is the strangler-fig pattern applied to .NET.
- Rewrite. Justified when the application needs substantial redesign anyway, but carries the highest risk. Our article on modernising legacy applications without disruption explains why incremental approaches are usually safer.
Step 4: Build a Safety Net
Before changing code, add automated tests around critical behaviour: integration tests for key endpoints, characterisation tests that capture current outputs, and tests for reports and calculations. Where unit tests are impractical, record request and response pairs from staging and replay them against the new version.
Step 5: Move Shared Code First
Convert class libraries to .NET Standard 2.0 or multi-target them so both old and new applications can use them during the transition. This avoids maintaining two copies of business logic.
Step 6: Plan Hosting and Operations
Decide whether to stay on Windows and IIS initially or move to Linux containers. Update logging, configuration (moving from web.config to appsettings and environment variables), health checks and deployment pipelines. If you are also moving to the cloud, sequence the two changes rather than doing both at once; see cloud migration planning.
Step 7: Cut Over Gradually
Release migrated components behind routing rules or feature flags, monitor errors and performance, and keep the ability to route traffic back. Retire old components only when the new ones have run reliably.
Cost and Timeline Considerations
Small, well-tested MVC or API applications can sometimes move in weeks. Large applications with Web Forms, WCF and many Windows dependencies often take months and are best done in phases. The main cost drivers are the amount of UI to rewrite, the state of automated tests, third-party dependencies without modern versions and how much the business wants to change while migrating. Avoid adding major new features during the migration unless they replace legacy screens.
Recommendations
- Inventory project types, dependencies and Windows-specific APIs.
- Add tests around critical behaviour before porting.
- Move shared libraries first and multi-target them.
- Use incremental side-by-side migration for web applications.
- Target a current LTS release and plan regular upgrades afterwards.
How Webespire Consulting Can Help
Our legacy modernisation team assesses .NET codebases, plans phased migrations and does the porting work, while our cloud technology solutions team handles hosting changes. For the business case, read legacy software modernisation costs and benefits.
Frequently Asked Questions
Is .NET Framework being discontinued?
.NET Framework 4.8.x continues to receive security updates as part of supported Windows versions, but it is not getting new features. Modern .NET is where development continues.
Can Web Forms run on modern .NET?
No. Web Forms pages need to be rewritten, typically as Razor Pages, MVC or Blazor components.
Do we have to move to Linux?
No. Modern .NET runs on Windows too. Linux and containers are options, not requirements.
Can AI tools do the migration for us?
Tools can speed up repetitive changes and suggest fixes, but engineers still need to handle design decisions and verify behaviour with tests.
How do we keep the old app running during migration?
Use side-by-side hosting with a proxy that routes each URL to the old or new application until migration finishes.
Conclusion
A .NET Framework migration is a modernisation project, not a recompile. Assess dependencies honestly, protect behaviour with tests, migrate incrementally and plan for regular upgrades afterwards. Done this way, the move reduces risk and opens up hosting and development options rather than disrupting the business.
Planning a move off .NET Framework? Email info@webespire.com or visit webespire.com.



