Belitsoft is the turnkey partner for organizations upgrading legacy .NET Framework portfolios to .NET 8/10. The company combines strategic planning, automated tooling, re-architecture expertise, and performance tuning — delivering a frictionless migration path.
Why modernize
Modernizing .NET Framework applications to .NET 8/10 is a strategic investment that leads to improved performance and long‑term maintainability.
Microsoft still supports .NET Framework, but innovation has moved to .NET (Core), now simply called .NET. Modern .NET versions are cross‑platform and deliver significant performance, scalability and security improvements. .NET 8 (2023) and .NET 10 (2025) are Long‑Term Support (LTS) releases. Migrating applications prepares companies for cloud‑native architectures, containerization and microservices while reducing technical debt and aligning with future frameworks.
Migration to .NET 8, and 10 – differences and new features
.NET 8 (LTS)
Microsoft released .NET 8 on November 14, 2023, as a Long-Term Support version. That means until November 10, 2026, it will receive only security fixes and critical bug patches — no new features or breaking changes. Your existing .NET 8 apps will keep running exactly the same way, so you can schedule upgrades on your own timetable instead of rushing yearly updates.
Frozen Public APIs
The set of public methods and classes you use in .NET 8 is locked at release. Any code you build today will compile and run the same way through November 2026, avoiding surprises from shifting interfaces.
Native AOT Compilation
You can turn on <PublishAot>true</PublishAot> to compile your code into a standalone machine-code executable. That skips just-in-time work, so your app starts up about 50–60 percent faster and runs on machines without .NET installed.
Automatic Profile-Guided Optimization
.NET 8 watches which parts of your code run most often, then automatically re-optimizes those “hot” methods on the fly. You get around a 15 percent throughput gain without writing any profiling scripts.
SIMD/Vector Instruction Support
New low-level APIs let your code use modern CPU vector instructions (like AVX-512) to process many data elements in one step. That speeds up tasks such as image processing, encryption, or large math calculations.
JIT and Garbage Collector Tweaks
The runtime now inlines small methods more often, removes needless array checks, and restructures loops. Meanwhile, the garbage collector adjusts heap size to actual usage and sweeps memory in the background to reduce pause times.
Blazor WebAssembly Streaming
Instead of downloading the entire WebAssembly DLL before showing anything, the browser now streams UI components in pieces. Users see parts of the page faster, especially on slow connections.
Faster HTTP/2 Parsing in Kestrel
The web server skips extra steps when reading HTTP/2 frames and uses vectorized scanning. That cuts CPU work per request and improves throughput for high-traffic APIs.
Precompiled Routing
Route patterns for minimal APIs and MVC controllers are turned into optimized decision trees at startup. This makes URL matching nearly instant, so requests get handled faster.
Reduced Model-Binding Allocations
When reading JSON or form data, ASP.NET Core now reuses internal memory buffers instead of creating new collections. That lowers short-lived object counts and eases garbage-collector pressure.
EF Core LINQ Translation
More LINQ methods (including math functions and complex filters) now convert directly into SQL on the database side. That cuts down redundant data transfer and speeds up queries.
Granular Concurrency Control in EF Core
EF Core 8 embeds version tokens in update and delete statements so the database can detect conflicts at the column level. This reduces failed updates under heavy multiuser load.
.NET 10 (LTS)
Microsoft plans to release .NET 10 as a long-term support (LTS) version in November 2025, with security patches and fixes guaranteed through November 2028. This update delivers targeted runtime optimizations, expanded library APIs, enhanced SDK tools, modern web framework features, and productivity improvements in C# 14.
JIT Inlining
The Just-In-Time (JIT) compiler now embeds the machine code of frequently invoked methods directly at their call sites, eliminating extra jumps and reducing CPU cycles for hot code paths by up to 15 percent.
Method Devirtualization
When the runtime can determine a method’s exact implementation at compile time, it replaces indirect (virtual) calls with direct calls, eliminating dynamic lookup overhead and improving throughput in object-oriented workloads
Stack Allocation Enhancements
Small, short-lived data structures (such as transient arrays) can now be allocated on the thread’s call stack instead of the garbage-collected heap, lowering memory fragmentation and reducing pause times in high-volume transaction scenarios
AVX10.2 Instruction Support
New hardware intrinsics in System.Runtime.Intrinsics.X86.Avx10v2 let managed code execute 256- and 512-bit vector operations on CPUs that support AVX10.2, accelerating data-parallel tasks such as image processing and encryption loops.
Library and Security APIs
.NET 10 adds modern cryptography classes (AesCng, RsaPss) with safe defaults, enforces strict JSON serialization rules (such as disallowing trailing commas), and exposes post-quantum algorithms (Kyber, Dilithium) to protect against future quantum attacks.
Container Image Publishing
The dotnet publish –container command automatically produces a ready-to-run Docker image, embedding the runtime and application in a minimal Linux container and eliminating manual Dockerfile maintenance.
CLI Tab Completion
The .NET CLI now ships with pre-generated completion scripts for Bash, Zsh, and PowerShell, showing valid commands and options as you type and reducing onboarding time for new developers.
Blazor WebAssembly Pre-Loading
A <LinkPreload /> component lets the browser download core WebAssembly assets proactively during initial page rendering, reducing wait time before interactive content appears in single-page applications.
Passkey Authentication in ASP.NET Core
Built-in FIDO2/WebAuthn support enables users to log in with hardware or platform authenticators (such as fingerprint or TPM keys), reducing phishing risk and simplifying compliance with modern security standards
C# 14 Language Updates
New C# 14 features include compiler-generated backing fields (via the field keyword), expanded nameof support for generic and nested expressions, seamless conversions to and from Span<T>, and user-defined compound operators — all of which reduce boilerplate and improve code clarity.
Assessment & planning
Inventory existing applications and dependencies
Document each application (web app, desktop client, library, service/API), its .NET Framework version, third‑party libraries, data access technologies (ADO.NET, Entity Framework 6), and platform dependencies such as Windows API calls. Use the .NET Portability Analyzer to evaluate how much of the code can run on .NET 8/10 and to identify APIs that do not exist in .NET.
Upgrade to at least .NET Framework 4.7.2 and adopt SDK‑style project format
Retargeting to .NET Framework 4.7.2 exposes newer APIs that ease migration. Convert the project file to the SDK‑style format, which is used by modern .NET and also works for .NET Framework projects.
Decide on a target
Choose .NET 8/10 (LTS) for production workloads. Desktop apps (WPF/WinForms) should target .NET 6 or later for improved performance and still remain Windows‑only. Libraries shared with .NET Framework should target .NET Standard 2.0 or multi‑target both .NET Framework and .NET.
Choose a migration strategy
For web and large applications, incremental migration following the Strangler Fig pattern is preferred. Small apps may be migrated “in place”, but this requires accepting down‑time or cut‑over. Migration of ASP.NET Framework to ASP.NET Core is complex because of System.Web dependencies, different hosting models, session state APIs and middleware pipeline differences.
Engage stakeholders and plan budgets
Determine which applications have high business impact. Discuss less actual technologies (ASP.NET Web Forms, Windows Communication Foundation (WCF), Windows Workflow Foundation (WF)) and decide whether rewriting or re‑architecting is justified.
Establish test coverage
Create automated unit and integration tests to capture existing behaviour. This is critical for verifying that the migrated application behaves correctly.
Tools to assist migration
- .NET Upgrade Assistant. A command-line or Visual Studio tool automates the upgrade of Windows Forms, WPF, ASP.NET MVC, Web API, and class library projects to .NET. It converts projects to SDK style, updates NuGet packages, and installs analyzers.
- Try-convert. The tool is used as the underlying conversion engine by the .NET Upgrade Assistant. However, it is not guaranteed to fully convert a project into a 100% working state so expert support may be required.
- GitHub Copilot App Modernization – Upgrade for .NET extension. A Visual Studio Ai-based extension to upgrade projects to newer .NET versions, update dependencies, and apply code fixes.
- Azure Migrate application & code assessment / GitHub Copilot app modernization. Provides application analysis and migration recommendations for moving .NET applications to Azure, helping assess configuration and dependencies before migration.
Platform compatibility analyzer. An analyzer that checks for APIs which throw PlatformNotSupportedException or behave differently on .NET, helping ensure compatibility during migration. The Platform compatibility analyzer is a legitimate Microsoft tool. - Microsoft.Windows.Compatibility NuGet package. Provides approximately 20,000 additional APIs from the .NET Framework for .NET applications. Microsoft officially recommends installing this package when porting existing code to .NET or .NET Standard, especially if you encounter missing APIs after migration.
General migration guidelines
Foundational Steps
- Retarget to an SDK-style TFM. Moving from <TargetFrameworkVersion> to <TargetFramework> signals the SDK to load the correct compiler, libraries, and references.
- Align all NuGet packages with your TFM. Aligning all NuGet packages to the same Target Framework Moniker ensures libraries are built against the correct runtime
- Multi-target libraries when you need it. Configuring libraries to target multiple .NET frameworks in one package expands compatibility. Consumers on different .NET versions can use the same package without workarounds.
- Migrate from packages.config to <PackageReference>. Migrating to PackageReference centralizes dependency management within your project files.
Address unsupported technologies
Web Forms and WF
These technologies are not available in modern .NET. Migrating a Web Forms app generally requires rewriting the UI layer using ASP.NET Core MVC, Razor Pages, or Blazor – there is no automatic porting. For WF workflows, consider using CoreWF (community project) or re‑implement workflows with state machines or orchestrators like Durable Functions.
WCF
.NET no longer includes WCF server components. Recommended paths are ASP.NET Core gRPC or CoreWCF. gRPC uses HTTP/2 and Protobuf, offers high performance and full duplex streaming, has strong multi‑language support and is widely adopted. CoreWCF is a community port of WCF for .NET and can help maintain compatibility with existing clients but supports only a subset of WCF features.
Remoting & AppDomains
.NET removes application domains and the remoting. Use separate processes or containers for isolation, and use inter‑process communication (pipes, memory mapped files) or gRPC/REST for remote calls.
Code Access Security (CAS) and System.EnterpriseServices
These security models are not supported. Rely on OS‑level isolation and virtualization.
Analyze third‑party dependencies
Ensure that NuGet packages are available for .NET 8/10. Update or replace packages. If the package only targets .NET Framework, check whether a newer version supports .NET or whether the functionality can be replaced with built‑in APIs.
Testing
Run your existing test suite after each migration step. Create regression tests for critical business flows. Use dotnet test and integrate tests into CI/CD pipelines. For library migrations, multi‑target the test project to run against both .NET Framework and .NET to ensure behavioural parity.
Performance & profiling
After migrating, monitor performance to identify regressions. For example, .NET 10 provides profiling improvements and built-in diagnostics (dotnet-counters, dotnet-trace) and support improved JIT inlining, method de‑virtualization and AVX10.2 instructions. Use these tools to tune performance.
Deployment
Update build and deployment pipelines to use the new dotnet SDK. For containerized applications, use official ASP.NET Core runtime images. Note that .NET 10 container images default to Ubuntu and have changed behaviours (refer to breaking changes documentation). Use side‑by‑side deployment when performing incremental migrations and route traffic via reverse proxy (for example, YARP) to the new service.
Documentation
Document the migration plan, decisions and code patterns.
Migration strategy for multiple applications
- Incremental releases and CI/CD. Implement continuous integration and continuous delivery (CI/CD). Use feature flags or routing rules (YARP, reverse proxy) to direct traffic to migrated services while older services continue to run. Monitor metrics and error rates.
- Centralized testing. Create shared test libraries and infrastructure. Use test automation frameworks (xUnit, MSTest, NUnit) and integrate performance tests.
- Deployment and monitoring. Standardize container images or VM configurations across projects. Use Application Insights, Prometheus or OpenTelemetry. Configure alerts on performance.
- Documentation and knowledge sharing. Maintain migration guides, code samples and architecture decision records.
- Future‑proofing. Keep up with yearly .NET releases. Increase release velocity by automating build and deployment to minimize the effort of future migrations.
Key recommendations for CTOs
- Adopt LTS versions (.NET 8 or .NET 10) for production workloads. Evaluate STS releases like .NET 9 in a controlled environment to prepare for features that will become mainstream.
- Use automated tools. Make .NET Upgrade Assistant the default tool for upgrades. Supplement it with platform analyzers. Experiment with GitHub Copilot modernization tools to speed up code fixes.
- Plan for unsupported frameworks. If your applications rely on Web Forms, WCF or WF, treat migration as a re‑architecture project. Evaluate Blazor, Razor Pages, gRPC or CoreWCF as replacements.
- Invest in testing. Quality gates ensure that refactoring does not break functionality. Build a comprehensive test harness before migrating.
- Keep security in mind. Modern .NET provides stronger cryptography, support for HTTP/2/3, TLS improvements and built‑in support for OpenTelemetry. Update authentication flows and enable automatic HTTPS and HSTS.
- Monitor breaking changes. Check the compatibility pages for .NET 8 and .NET 10 to identify binary and behavioural changes that may affect your code. Test your applications against preview versions to catch issues early.
