Guide for upgrading .NET Framework to .NET 7, including understanding project architecture, updating .csproj, solving breaking changes and upgrading dependencies.

Our Journey to .NET 7

These days most engineers are working on upgrading their code base from .NET Framework to .NET 7. I believe you are not alone, and almost every engineer has experienced something similar at some point in their career. This post is part guide, part how-to. The main focus here is on upgrading the back-end to .NET 7, but this will be useful if you need to upgrade any .NET Framework code to .NET 7. Of course, if you do have many breaking changes, this could be very painful if your team does not have proper unit, functional, and other tests that will save your life. :-)
<h2 id="lets-start">Let's start</h2>
You might have an older legacy system running the .NET Framework 4.X.X. It's probably a confused mess with .NET Framework, .NET Standard, and .NET Core libraries crowded. Some of your code may be ready to run, while others may need to be first solved by breaking changes. From personal experience, it is best to take things slowly at the outset. As a result, it is necessary first to understand the relationship between your projects and domain and then proceed in that order.
Keep going even if your project can't be compiled right away. It's pretty standard. For instance, in 99% of my cases, it was not compiled the first time. As a result, you must begin with a project without any dependencies on others. It's prevalent to call it Common, Shared, SharedKernel, Kernel, or whatever, but your projects mustn't have any internal dependencies.
<h2 id="review-your-project-architecture">Review your project architecture</h2>
One of the most important things is that you will have to look at each project individually and make crucial decisions. The good news is that we often don't have time for comprehensive codebase analysis, so you may find that you don't need some code elements. You will be able to remove them.
However, you must decide what to do with the necessary code and, most importantly, consult with the original code owners if they can help you make a decision. Another option is to look through the references and see where the potential code is used to find the source of the problem.
Under refactoring the code base, existing code has to be upgraded to run in a new environment under .NET 7. With multi-targeting, it will most likely also target the .NET Framework. As a result, you'll have to rewrite some things, which means writing the code from scratch. The new code is unlikely to run on the .NET Framework, so the only goal is to write the code that will run under .NET 7.
<h2 id="lets-start-with-the-first-step">Let's start with the first step</h2>
Let's assume that we have a relatively simple architecture that is divided into multiple projects, like in the image below. The first step is to find the root project without dependencies marked with red and try to first work on it. The first step will be downloading the official .NET 7 SDK from the Microsoft site. <a href="https://dotnet.microsoft.com/en-us/download/dotnet/7.0">https://dotnet.microsoft.com/en-us/download/dotnet/7.0</a>
<img src="https://pnzdemostorageaccount.blob.core.windows.net/cappy/0c0d4de10f9c497caaedec75bb1c0d75.jpg" alt="diagram" />
Open project.csproj and make the following adjustments to the target framework:
<pre><code class="lang-xml hljs">&lt;PropertyGroup&gt;
 &lt;TargetFramework&gt;net7.0&lt;/TargetFramework&gt;
 &lt;DockerDefaultTargetOS&gt;Linux&lt;/DockerDefaultTargetOS&gt;
&lt;/PropertyGroup&gt;
</code></pre>
In the event that you are using containers, you will need to upgrade your base images, such as:
<pre><code class="lang-docker hljs dockerfile">FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
...
</code></pre>
This means we'll be using BCL from .NET 7, but the most challenging part is figuring out which dependencies we have under this project and attempting to upgrade them. If a specific dependency does not yet support .NET 7, you must wait for the library's author to make it compatible, or you can remove it if you believe your project can work without it.
Once you have completed this section and you are able to successfully compile it, it is time to repeat the process for each project, but first, you must verify the finished project using your test project(s), which also means you must upgrade it to .NET 7 and all dependencies.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/cappy/75634104d734462da653783e87f944e3.jpg" alt="diagram" />
<h2 id="solve-breaking-changes">Solve breaking changes</h2>
As previously explained, using a newer .NET version, such as .NET 7, will cause compilation errors and issues. Some .NET Framework libraries could be incompatible in .NET 7 edition. So the bad news is that you must resolve all code issues that come up in your code base, but this is also an opportunity for you to take ownership of this piece of code and better understand what it is doing for you.
Let's imagine that the library you use in the .NET Framework is not accessible in .NET 7. In that case, you will need to find an alternative or write the code yourself. The fastest option is to find a more recently supported library and replace the existing code with a new one. Otherwise, you'll have to use <code>#if</code> statements to make a distinctive code base to target different paths.
<pre><code class="lang-charp">#if NETSTANDARD2_0
 ...
#else
 ...
#endif
</code></pre>
You may also use partial classes, with the main class in one file and two different versions for .NET 7 and other .NET Frameworks. You can, based on conditions, include or exclude files dependent on the framework target. Pretty much the same story for the NuGet package.
<h2 id="what-about-your-database">What about your database?</h2>
This may be the most difficult phase of your trip to .NET 7. Use Dapper or another (O)RM like RepoDB. There is probably not much difference between the older .NET Frameworks and .NET 6 or .NET 7. Entity Framework (Classic), on the other hand, is not the same as Entity Framework Core. Some EF will compile for EF Core, yet it will provide different results and run different SQL. This is why testing is critical. You should write a set of database tests to check that the new .NET 7 database access code accomplishes the same as the .NET Framework code.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/cappy/0e0b8d16566945ecbecabcfbf495c5ec.jpg" alt="diagram" />
<h2 id="branch-strategy-during-the-upgrade">Branch strategy during the upgrade?</h2>
The reality is that you must supply new features, and the world cannot stop till you finish your update. Therefore, you must design a really practical approach in terms of branching strategy. This is very dependent on team size and whether the project architecture is monolithic, hexagonal, microservice or even specific for your organization; however, I can share some of my advices.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/cappy/2017211cebee4d948c891d542cf2bf45.jpg" alt="application" />
Based on my experience, the ideal approach is to prioritize projects that are critical to your organization and improve them first. Of course, this is risky, but you want to reduce the amount of time you spend working on code that is not in production since you have to deliver .NET 7 to your clients as soon as possible, at least the most used features. If you keep your code on a branch for a long time, it will become non-production code, and you will have to deal with more and more merge conflicts. Trust me - this is a nightmare for engineers and a paradise for bugs.
<h2 id="conclusion">Conclusion</h2>
I would love to share a magic recipe to solve this problem with you, but there is no such thing. However, if your team does not communicate, understand the decisions, and make guesses without strong arguments, you will be very close to feeling pain.
We tested after the upgrade and noticed immediate improvements. The diagrams below show that we can handle &gt;63K RPS in less than 20 minutes.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/cappy/be6f5ec19d5444ebbfb750ae6b6426fd.jpg" alt="chart, line chart" />
If you believe we can assist you, please contact us and we would love to share our experience, especially since we are already running on .NET 7.
Best Luck!

The .NET 7 has been released, and with it come performance enhancements that will help your applications run faster. Whether you're new to .NET or have been using it for years, there are many great features in this release worth exploring.

Discover the ACID principles that make online transactions secure and reliable. From Atomicity to Durability, learn how Penzle System ensures each click counts in your financial transfers.

Unlock the Secrets of Secure Online Transactions with ACID - Penzle System

Ever been caught in the suspenseful moment of making an online payment and the internet blatantly bails on you? The dilemma of 'Did it, didn't it?' sounds familiar, doesn't it? We're cutting through the jargon and diving deep into the pulse of online transactions. Let's unravel what makes our digital world spin flawlessly.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/app/b7838dca0da5430b931e96b05bf26f0b.jpeg" alt="a red and white puzzle" width="3790" height="2868" />
<h2>The Slippery Concept of a Transaction</h2>
Let's begin with the basics. What is a transaction exactly? In its simplest sense, it's just a sequence of operations executed as a single unit, just like making a sandwich. You can't just slap some mayo on bread and call it a day; you must add lettuce, turkey, and cheese to complete it. Similarly, in the digital space, a transaction would, by definition, be a set of steps or activities, all of which must happen for it to be considered 'done.'
Have you ever found yourself mid-way transferring money from savings to checking and wondered what happens when things go wrong?
Visualize this - you're shifting cash around in your accounts. A sequence of events unfolds. Verifying sufficient funds in savings, then decreasing those reserves. Simultaneously, your checking account swells.
But let's pause. What happens if a hiccup occurs in this process? Ideally, the transaction should reverse. Pretend it was a mirage, never materialized. Here, the term 'transaction' begins to appear 'slippery.' It's not merely about undertaking actions but ensuring a complete success or a coherent failure.
<h2>The Meaning of ACID</h2>
ACID isn't as scary as it sounds. It's just four principles that keep your transactions ticking over smoothly. Let me break it down.
Atomicity: It's all or nothing, like Mercedes: "The Best Or Nothing". Transactions are only successful if every operation goes to plan. One hiccup? The whole transaction quits.
Consistency: A little like a brilliant cleaner, this principle ensures databases transition from one spick-and-span state to another.
Isolation: Everyone needs their space. Transactions are no exception. They run concurrently, without any interference.
Durability: This is the keeper of promises. A committed transaction is always committed, no matter how many systems fail or go under.
Now that you've unlocked the code of ACID, dare you apply it to your tech solutions with Penzle.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/app/4823014bda5d4b26b9785132a6a4fba7.png" alt="diagram" />
<h2>Sleep Easy with Online Transactions</h2>
Have you ever had a heart-thumping moment during an online money transfer? Here's why ACID has your back: Moving from one account to another? Point A to Point B - no halfway houses. That's Atomicity.
Are you worried about your account balance teetering off point? ACID keeps the digital scales balanced - before and after the transaction. That's Consistency.
A queue of transactions? No jostling allowed. Each deal has its VIP lane. Say hello to Isolation. A system crash at the bank? Your money doesn't vanish into a digital black hole. It's secured with Durability.
Your transactions are safe even if the system takes a nosedive. Isn't it time you slept better knowing ACID has your back which core of Penzle System?
<h2>For the end</h2>
Behind every button click online, a symphony of ACID (Atomicity, Consistency, Isolation, Durability) works tirelessly. Mind-boggling? Perhaps.
But fear not - ACID transforms this digital labyrinth into a walk in the park. Think of it the next time you breeze through an online transaction, savoring the smoothness.
<img src="https://pnzdemostorageaccount.blob.core.windows.net/app/e19b1cc68fda4f71a5802b1a31ac16ac.jpg" alt="a child in a shopping cart" />
Have you ever wondered who's got your back when transferring money online? That's ACID, making each click count. Quite the unsung hero, right?
Ready to dive deep into the ACID magic? Turn slippery concepts into hard facts and unravel the mystery. You're just a click away!
Cheers! 👋

Ever been caught in the suspenseful moment of making an online payment and the internet blatantly bails on you? The dilemma of ‘Did it, didn’t it?’ sounds familiar, doesn’t it? We’re cutting through the jargon and diving deep into the pulse of online transactions.

Admir Mujkic

Digital Assets Management

Content Hub

Resources

Company