.NET Framework to .NET Core Migration Services

Technical Deep Dive

1. The WebForms Dead End

• Legacy: ASP.NET WebForms relies on System.Web, a massive library tightly coupled to IIS. It uses "ViewState" (hidden base64 strings) to fake statefulness.
• Modern: .NET Core does not have System.Web.
• The Fix: You cannot port this. You must rewrite the UI.
  • Option A (Stay in C#): Migrate to Blazor Server or Blazor WASM. The component model is similar, but the lifecycle is different.
  • Option B (Modernize): Rewrite the frontend in React/Angular and convert the backend to ASP.NET Core Web API.

2. WCF to gRPC / CoreWCF

• Legacy: WCF was the "do everything" communication framework.
• Modern: Microsoft recommends gRPC for internal microservices (fast, binary) and Web API (REST) for public APIs.
• The Trap: Don't use CoreWCF unless you absolutely have to (e.g., SOAP clients you can't control). It is a community project, not a first-class citizen like gRPC.

3. Entity Framework 6 -> EF Core

• Legacy: EF6 allowed "Database First" with .edmx visual designers.
• Modern: EF Core is "Code First" focused.
• The Fix: You will likely need to regenerate your data models. Be careful of "Client-Side Evaluation" changes - EF Core will throw exceptions for queries that EF6 would silently run in memory (slowly).

When NOT to Migrate to .NET Core

Not every app needs to be modernized.

1. Stable Intranet WebForms Apps

If you have an internal HR portal used by 50 people, built in WebForms, and it works... leave it alone. The cost to rewrite the UI in Blazor will never be recouped by hosting savings. Isolate it on a secure Windows Server and let it run.

2. Heavy Desktop Apps (WPF/WinForms) on Windows Only

.NET Core supports WPF/WinForms, but only on Windows. If you don't plan to move to Mac/Linux, the benefit of migrating a stable WPF app from Framework 4.8 to .NET 8 is marginal (mostly performance). If it's not broken, don't fix it.

3. Apps Depending on Legacy Third-Party DLLs

If your mission-critical app uses a PDF generation library from 2012 that the vendor stopped updating, you cannot migrate. .NET Core cannot load those legacy assemblies if they depend on GDI+ or other Windows internals that changed.

Total Cost of Ownership: Windows vs Linux

The biggest financial driver for this migration is licensing.

Break-Even Analysis:

• Migration Cost: $150k (Rewrite UI)
• Hosting Savings: $30k/year (Switching 10 VMs to Containers)
• Dev Productivity: +20% (Faster builds, better tools)
• Break-Even: ~3-4 Years (This is a long-term play, not a quick win)

Vendor Intelligence: Case Studies

If you are a Fortune 500: Avanade or EPAM.

• Avanade: Assessed a portfolio of 1,000+ .NET apps for a global insurer. Identified 40% for retirement, 30% for "Lift & Shift" to Azure App Service, and 30% for rewrite. Scale is their superpower.
• EPAM: Re-platformed a massive retail monolith. 500K+ LOC. Converted WCF to gRPC. Timeline: 18 months. Cost: $2M+.

If you have complex "Math/Science" Code: Abto Software.

• Migrated a desktop healthcare analysis tool (WPF) to the web (Blazor WASM). 300K LOC. Kept the C# calculation engine (shared library) but rewrote the UI. Performance was critical.

If you are a SaaS Scale-up: CSHARK.

• FinTech client. Migrated .NET Framework 4.5 monolith to .NET 6 Microservices. Used "Strangler Fig" pattern to peel off services one by one. Zero downtime cutover.

Red Flags:

• Vendors who say "We can run WebForms on .NET Core." (They are lying or using unsupported hacks).
• Vendors who don't mention Docker/Linux. If they migrate you to .NET Core but keep you on IIS/Windows VMs, they missed 50% of the value.
• No mention of Database Migration. Moving from SQL Server on-prem to Azure SQL often requires schema changes.

Migration Roadmap: The "Strangler Fig" Pattern

Don't rewrite from scratch. Use the Strangler Fig pattern.

Phase 1: The Facade (Weeks 1-4)

• Put a YARP (Yet Another Reverse Proxy) in front of your legacy IIS app.
• All traffic goes to YARP. YARP forwards to IIS.
• Goal: Control the entry point.

Phase 2: Peel Off Services (Months 2-6)

• Identify a vertical slice (e.g., "User Profile").
• Build it in ASP.NET Core (running on Linux/Docker).
• Update YARP to route /profile to the new app.
• Goal: Production validation of the new stack with low risk.

Phase 3: The UI Rewrite (Months 6-12)

• For WebForms, this is the hard part.
• Build new pages in Blazor or React.
• Route traffic page-by-page.
• Goal: Incremental retirement of .aspx pages.

FAQ

1. Can I automate the migration?

No. Tools like the .NET Upgrade Assistant are helpful for analyzing dependencies and upgrading project files (.csproj), but they cannot rewrite your architecture. They cannot turn UpdatePanel into React components.

2. Should I use Blazor or React?

• Choose Blazor if your team is 100% C# developers and you want to avoid the JavaScript ecosystem complexity.
• Choose React if you want to hire from the massive pool of frontend devs and want a clear separation between frontend and backend.

3. What about my SQL Server Stored Procedures?

You can keep them, but modern .NET development favors moving logic out of the database and into the application layer (C#) for better testability and scaling. Consider migrating logic gradually.

Risk Factors

The 'WebForms' Dead End

ASP.NET WebForms has NO migration path to .NET Core. It relies on System.Web.dll which is tightly coupled to IIS. You cannot 'port' it; you must rewrite the UI layer (Blazor, Razor Pages, or React).

WCF Incompatibility

Windows Communication Foundation (WCF) is not fully supported in .NET Core. While CoreWCF exists, it's a community project with limitations. The official Microsoft recommendation is a rewrite to gRPC or Web API.

Entity Framework 6 vs Core

EF Core is a total rewrite of EF6. Legacy features like edmx (visual designer) are gone. Complex LINQ queries that worked in EF6 may throw runtime errors in Core due to different evaluation logic.

Feasibility Analysis

Ideal candidates

• ASP.NET MVC 5 apps (High compatibility)
• WCF Services (Good candidates for gRPC)
• Console Apps / Windows Services (Easy port)

Break-even cost: $50k/year in licensing & hosting savings Talent risk: Medium. .NET Framework devs need upskilling for Core/Linux.