This year we attended NDC London as a sponsor for ABP. The conference was held at the same place Queen Elizabeth II as previous years. I guess this is the best conf for .NET developers around the world (thanks to the NDC team). And we attend last 5 years. It was 3 full days started from 28 to 30 January 2026. As an exhibitor we talked a lot with the attendees who stopped by our booth or while we were eating or in the conf rooms.

This is the best opportunity to know what everyone is doing in software society. While I was explaining ABP to the people who first time heard, I also ask about what they do in their work. Developers mostly work on web platforms. And as you know, there's an AI transformation in our sector. That's why I wonder if other people also stick to the latest AI trend! Well... not as I expected. In Volosoft, we are tightly following AI trends, using in our daily development, injecting this new technology to our product and trying to benefit this as much as possible.

This new AI trend is same as the invention of printing (by Johannes Gutenberg in 1450) or it's similar to invention of calculators (by William S. Burroughs in 1886). The countries who benefit these inventions got a huge increase in their welfare level. So, we welcome this new AI invention in software development, design, devops and testing. I also see this as a big wave in the ocean, if you are prepared and develop your skills, you can play with it 🌊 and it's called surfing or you'll die against the AI wave in this ocean. But not all the companies react this transformation quickly. Many developers use it like ChatGpt conversation (copy-paste from it) or using GitHub Co-Pilot in a limited manner. But as I heard from Steven Sanderson's session and other Microsoft employees, they are already using it to reproduce the bugs reported in the issues or creating even feature PRs via Co-Pilot. That's a good!

Here're some pictures from the conf and that's me on the left side with brown shoes :)

Another thing I see, there's a decrease in the number of attendees'. I don't know the real reason but probably the IT companies cut the budget for conferences. As you also hear, many companies layoff because of the AI replaces some of the positions.

The food was great during the conference. It was more like eating sessions for me. Lots of good meals from different countries' kitchen. In the second day, there was a party. People grabbed their beers, wines, beverages and did some networking.

I was expecting more AI oriented sessions but it was less then my expectations. Even though I was an exhibitor, I tried to attend some of the session. I'll tell you my notes.

Here's a quick video from the exhibitors' area on the 3rd floor and our ABP booth's Xbox raffle:

Video 1: NDC Conference 2026 Environment 👉 https://youtu.be/U1kiYG12KgA

Video 2: Our raffle for XBOX 👉 https://youtu.be/7o0WX70qYw0

Sessions / Talks

The Dangers of Probably-Working Software | Damian Brady

The first session and keynote was from Damian Brady. He's part of Developer Advocacy team at GitHub. And the topic was "The dangers of probably-working software". He started with some negative impact of how generative AI is killing software, and he ended like this a not so bad, we can benefit from the AI transformation. First time I hear "sleepwalking" term for the development. He was telling when we generate code via AI, and if we don't review well-enough, we're sleepwalkers. And that's correct! and good analogy for this case. This talk centers on a powerful lesson: “Don’t ship code you don’t truly understand.” Damian tells a personal story from his early .NET days when he implemented a Huffman compression algorithm based largely on Wikipedia. The code “worked” in small tests but failed in production. The experience forced him to deeply understand the algorithm rather than relying on copied solutions. Through this story, he explores themes of trust, complexity, testing, and mental models in software engineering.

Notes From This Session

• “It seems to work” is not the same as “I understand it.”
• Code copied from Wikipedia or StackOverflow or AI platforms is inherently risky in production.
• Passing tests on small datasets does not guarantee real-world reliability (happy path ~= unhappy results)
• Performance issues often surface only in edge cases.
• Delivery pressure can discourage deep understanding — to the detriment of quality.
• Always ask: “When does this fail?” — not just “Why does this work?”

Playing The Long Game | Sheena O'Connell

Sheena is a former software engineer who now trains and supports tech educators. She talks about AI tools... AI tools are everywhere but poorly understood; there’s hype, risks, and mixed results. The key question is how individuals and organisations should play the long game (long-term strategy) so skilled human engineers—especially juniors—can still grow and thrive. She showed some statistics about how job postings on Indeed platform dramatically decreasing for software developers. About AI generated-code, she tells, it's less secure, there might be logical problems or interesting bugs, human might not read code very well and understanding/debugging code might sometimes take much longer time.

Being an engineer is about much more than a job title — it requires systems thinking, clear communication, dealing with uncertainty, continuous learning, discipline, and good knowledge management. The job market is shifting: demand for AI-skilled workers is rising quickly and paying premiums, and required skills are changing faster in AI-exposed roles. There’s strength in using a diversity of models instead of locking into one provider, and guardrails improve reliability.

AI is creating new roles (like AI security, observability, and operations) and new kinds of work, while routine attrition also opens opportunities. At the same time, heavy AI use can have negative cognitive effects: people may think less, feel lonelier, and prefer talking to AI over humans.

Organizations are becoming more dynamic and project-based, with shorter planning cycles, higher trust, and more experimentation — but also risk of “shiny new toy” syndrome. Research shows AI can boost productivity by 15–20% in many cases, especially in simpler, greenfield projects and popular languages, but it can actually reduce productivity on very complex work. Overall, the recommendation is to focus on using AI well (not just the newest model), add monitoring and guardrails, keep flexibility, and build tools that allow safe experimentation.

We’re in a messy, fast-moving AI era where LLM tools are everywhere but poorly understood. There’s a lot of hype and marketing noise, making it hard even for technical people to separate reality from fantasy. Different archetypes have emerged — from AI-optimists to skeptics — and both extremes have risks. AI is great for quick prototyping but unreliable for complex work, so teams need guardrails, better practices, and a focus on learning rather than “writing more code faster.” The key question is how individuals and organizations can play the long game so strong human engineers — especially juniors — can still grow and thrive in an AI-driven world.

Crafting Intelligent Agents with Context Engineering | Carly Richmond

Carly is a Developer Advocate Lead at Elastic in London with deep experience in web development and agile delivery from her years in investment banking. A practical UI engineer. She brings a clear, hands-on perspective to building real-world AI systems. In her talk on “Crafting Intelligent Agents with Context Engineering,” she argues that prompt engineering isn’t enough — and shows how carefully shaping context across data, tools, and systems is key to creating reliable, useful AI agents. She mentioned about the context of an AI process. The context consists of Instructions, Short Memory, Long Memory, RAG, User Prompts, Tools, Structured Output.

Modular Monoliths | Kevlin Henney

Kevlin frames the “microservices vs monolith” debate as a false dichotomy. His core argument is simple but powerful: problems rarely come from being a monolith — they come from being a poorly structured one. Modularity is not a deployment choice; it is an architectural discipline.

Notes from the Talk

• A monolith is not inherently bad; a tangled (intertwined, complex) monolith is.
• Architecture is mostly about boundaries, not boxes.
• If you cannot draw clean internal boundaries, you are not ready for microservices.
• Dependencies reveal your real architecture better than diagrams.
• Teams shape systems more than tools do.
• Splitting systems prematurely increases complexity without increasing clarity.
• Good modular design makes systems easier to change, not just easier to scale.

So As a Developer;

• Start with a well-structured modular monolith before considering microservices.
• Treat modules as real first-class citizens: clear ownership, clear contracts.
• Make dependency direction explicit — no circular graphs.
• Use internal architectural tests to prevent boundary violations.
• Organize code by capability, not by technical layer.
• If your team structure is messy, your architecture will be messy — fix people, not tech.

AI Coding Agents & Skills | Steve Sanderson

Being productive with AI Agents

In this session, Steve started how Microsoft is excessively using AI tools for PRs, reproducing bug reports etc... He's now working on GitHub Co-Pilot Coding Agent Runtime Team. He says, we use brains and hands less then anytime.

In 1 Week 293 PRs Opened by the help of AI

He created a new feature to Copilot with the help of Copilot in minutes

Code is cheap! Prototypes are almost free!

And he summarized the AI assisted development into 10 outlines. These are Subagents, Plan Mode, Skills, Delegate, Memories, Hooks, MCP, Infinite Sessions, Plugins and Git Workflow. Let's see his statements for each of these headings:

1. Subagents

• Break big problems into smaller, specialized agents.
• Each subagent should have a clear responsibility and limited scope.
• Parallel work is better than one “smart but slow” agent.
• Reduces hallucination by narrowing context per agent.
• Easier to debug: you can inspect each agent’s output separately.

2. Plan Mode

• Always start with a plan before generating code.
• The plan should be explicit, human-readable, and reviewable.
• You'll align your expectations with the AI's next steps.
• Prevents wasted effort on wrong directions.
• Encourages structured thinking instead of trial-and-error coding.

3. Skills

• These are just Markdown files but (can be also tools, scripts as well)
• Skills are reusable capabilities for AI agents.
• You cannot just give all the info (as Markdown) to the AI context (limited!), skills are being used when necessary (by their Description field)
• Treat skills like APIs: versioned, documented, and shareable.
• Prefer many small skills over one big skill set.
• Store skills in Git, not in chat history.
• Skills should integrate with real tools (CI, GitHub, browsers, etc.).

3.1 Skill > Test Your Project Skill

4. Delegate

didn't mention much about this topic

• “Delegate” refers to offloading local work to the cloud.
• Using remote computers for AI stuff not your local resources (agent continues the task remotely)

Ralph Force Do While Over and Over Until It Finishes

https://awesomeclaude.ai/ralph-wiggum

Who knows how much tokens it uses :)

5. Memories

didn't mention much about this topic

• It's like don't write tests like this but write like that, and AI will remember it among your team members.

• Copilot Memory allows Copilot to learn about your codebase, helping Copilot coding agent, Copilot code review, and Copilot CLI to work more effectively in a repository.

• Treat memory like documentation that evolves over time.

• Copilot Memory is turned off by default

• https://docs.github.com/en/copilot/how-tos/use-copilot-agents/copilot-memory

6. Hooks

didn't mention much about this topic

• Execute custom shell commands at key points during agent execution.
• Examples: pre-commit checks, PR reviews, test triggers.
• Hooks make AI proactive instead of reactive.
• They reduce manual context switching for developers.
• https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/use-hooks

7. MCP

• Talk to external tools.

• Enables safe, controlled access to systems (files, APIs, databases).

• Prevents random tool usage; everything is explicit.

8. Infinite Sessions

• AI should remember the “project context,” not just the last message.
• Reduces repetition and re-explaining.
• Enables deeper reasoning over time.
• Memory + skills + hooks together make “infinite sessions” possible.
• https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-best-practices#3-leverage-infinite-sessions

9. Plugins

• Extend AI capabilities beyond core model features.
• https://github.com/marketplace?type=apps&copilot_app=true

10. Git Workflow

• AI should operate inside your existing Git process.
• Generate small, focused commits — not giant changes.
• Use AI for PR descriptions and code reviews.
• Keep humans in the loop for design decisions.
• Branching strategy still matters; AI doesn’t replace it.
• Treat AI like a junior teammate: helpful, but needs supervision.
• CI + tests remain your primary safety net, not the model.
• Keep feedback loops fast: generate → test → review → refine.

Copilot as SDK

You can wrap GitHub CoPilot into your app as below:

As a Developer What You Need to Get from Steve's Talk;

• Coding agents work best when you treat them like programmable teammates, not autocomplete tools.
• “Skills” are the right abstraction for scaling AI assistants across a team.
• Treat skills like shared APIs: version them, review them, and store them in source control.
• Skills can be installed from Git repos (marketplaces), not just created locally.
• Slash commands make skills fast, explicit, and reproducible in daily workflow.
• Use skills to bridge AI ↔ real systems (e.g., GitHub Actions, Playwright, build status).
• Automation skills are most valuable when they handle end-to-end flows (browser + app + data).
• Let the agent discover the right skill rather than hard-coding every step.
• Skills reduce hallucination risk by constraining what the agent is allowed to do.

My Personal Notes about AI

• This is your code tech stack for a basic .NET project:

  • Assembly > MSIL > C# > ASP.NET Core > ...ABP... >NuGet + NPM > Your Handmade Business Code

    When we ask a development to an AI assisted IDE, AI never starts from Assembly or even it's not writing an existing NPM package. It basically uses what's there on the market. So we know frameworks like ASP.NET Core, ABP will always be there after AI evolution.

• Software engineer is not just writing correct syntax code to explain a program to computer. As an engineer you need to understand the requirements, design the problem, make proper decisions and fix the uncertainty. Asking AI the right questions is very critical these days.

• Tesla cars already started to go autonomous. As a driver, you don't need to care about how the car is driven. You need to choose the right way to go in the shortest time without hussle.

• I talk with other software companies owners, they also say their docs website visits are down. I talked to another guy who's making video tutorials to Pluralsight, he's telling learning from video is decreasing nowadays...

• Nowadays, developers big new issue is Reviewing the AI generated-code. In the future, developers who use AI, who inspect AI generated code well and who tells the AI exactly what's needed will be the most important topics. Others (who's typing only code) will be naturally eliminated. Invest your time for these topics.

• We see that our brain is getting lazier, our coding muscles gets weaker day by day. Just like after calculator invention, we stopped calculate big numbers. We'll eventually forget coding. But maybe that's what it needs to be!

• Also I don't think AI will replace developers. Think about washing machines. Since they came out, they still need humans to put the clothes in the machine, pick the best program, take out from the machine and iron. From now on, AI is our assistance in every aspect of our life from shopping, medical issues, learning to coding. Let's benefit from it.

Software and service stocks shed $830 billion in market value in six trading days

Software stocks fall on AI disruption fears on Feb 4, 2026 in NASDAQ. Software and service stocks shed $830 billion in market value in six trading days. Scramble to shield portfolios as AI muddies valuations, business prospects.

We need to be well prepared for this war.

So you're looking for a PDF library in .NET, right? Here's the thing - just because something has a million downloads doesn't mean it's what you should use today. I'm looking at recent download momentum (how many people are actually using it NOW via NuGet) and GitHub activity (are they still maintaining this thing or did they abandon it?).

I pulled data from the last ~90 days for the main players in the .NET PDF space. Here's what's actually happening:

Popularity Comparison of .NET PDF Libraries (ordered by score)

| Library | GitHub Stars | Avg Daily NuGet Downloads | Total NuGet Downloads | Popularity Score | |---------|---------------|-----------------------------|----------------------------|---------------------| | Microsoft.Playwright | 2.9k | 23k | 39M | 71/100 | | QuestPDF | 13.7k | 8.2k | 15M | 54/100 | | PDFsharp | 862 | 9k | 47M | 48/100 | | iText | 1.9k | 17.2k | 16M | 44/100 | | PuppeteerSharp | 3.8k | 8.7k | 26M | 40/100 |

How I calculated the score: I weighted GitHub Stars (30%), Daily Downloads (40% - because that's what matters NOW), and Total Downloads (30% - for historical context). Everything normalized to 0-100 before weighting. Higher = better momentum overall.

The Breakdown - What You Actually Need to Know

PDFsharp

NuGet: PdfSharp | GitHub: empira/PDFsharp

What it does: Code-first PDF stuff - drawing, manipulating, merging, that kind of thing. Not for HTML/browser rendering though, so don't try to convert your React app to PDF with this.

What's the vibe? Stable, but kinda old school. It's got the biggest total download count (47M!) but only pulling ~9k/day now. They updated it 2 weeks ago (Jan 6) so it's alive, and it supports .NET 8-10 which is nice. The GitHub stars (862) are pretty low compared to the shiny new kids, but honestly? It's been around forever and people still use it. It's the reliable old workhorse.

Pick this if:

• You need to build PDFs from scratch with code (not HTML)
• You want to draw graphics, manipulate existing PDFs, merge files
• You don't want browser engines anywhere near your project

iText

NuGet: itext | GitHub: itext/itext-dotnet

What it does: The enterprise beast. Digital signatures, PDF compliance (PDF/A, PDF/UA), forms, all that fancy stuff. Can do HTML-to-PDF too if you need it.

What's the vibe? Actually doing pretty well! ~17.2k downloads/day (highest for code-first libs), updated literally yesterday (Jan 18). They're moving fast. 1.9k stars isn't huge but the community seems active. The catch? This is the enterprise option - check the licensing before you commit if you're doing commercial work.

Pick this if:

• You need digital signatures, PDF compliance, or advanced form stuff
• Your company is cool with licensing fees (or you're doing open source)
• You need serious PDF manipulation features
• You want HTML-to-PDF AND code-based generation in one package

Microsoft.Playwright

NuGet: Microsoft.Playwright | GitHub: microsoft/playwright-dotnet

What it does: Browser automation that can turn HTML/CSS/JS into PDFs. Uses real browser engines (Chromium, WebKit, Firefox) so your PDFs look exactly like they would in a browser.

What's the vibe? Killing it. ~23k downloads/day (highest in this whole list!). It's Microsoft-backed so you know they're not gonna abandon it anytime soon. Last commit was December 3rd but honestly that's fine, they're actively maintaining. 2.9k stars and climbing. If you need to turn web pages into PDFs, this is probably your best bet right now.

Pick this if:

• You need to convert HTML/CSS/JS to PDF and want it to look EXACTLY like the browser
• You're working with SPAs, dynamic content, or web templates
• You also need browser automation/testing (bonus!)
• Layout accuracy is critical (forms, dashboards, etc.)

PuppeteerSharp

NuGet: PuppeteerSharp | GitHub: hardkoded/puppeteer-sharp

What it does: Basically Playwright's older sibling. Uses headless Chromium to turn HTML into PDFs. Same idea, different API.

What's the vibe? Stable but losing ground. Got updated last week (Jan 12) so it's maintained, but ~8.7k/day is way less than Playwright's ~23k. 3.8k stars is decent though. It works fine, but Playwright is eating its lunch. Still, if you know Puppeteer already or only need Chromium, this might be fine.

Pick this if:

• You already know Puppeteer from Node.js and want the same vibe in .NET
• You only need Chromium (don't care about Firefox/WebKit)
• You have existing Puppeteer code you're porting

QuestPDF

NuGet: QuestPDF | GitHub: QuestPDF/QuestPDF

What it does: Build PDFs with fluent C# APIs. Think of it like building a UI layout, but for PDFs. No HTML needed - it's all code, all .NET.

What's the vibe? The community favorite. 13.7k stars (most by far!), updated yesterday (Jan 18). ~8.2k downloads/day isn't the highest but the community is clearly excited about it. Modern API, active dev, people seem to actually enjoy using it. If you're building reports/invoices from code and want something that feels modern, this is it.

Pick this if:

• You want to build PDFs with code (not HTML) and you like fluent APIs
• You're generating reports, invoices, structured documents
• You want zero browser dependencies
• You care about type safety and maintainable code
• You want something that feels modern and well-designed

Who's Winning Right Now?

Here's what the numbers are telling us:

Code-First Libraries (Building PDFs with Code)

QuestPDF - Score: 54/100 The people's choice. Most GitHub stars (13.7k), updated yesterday, community loves it. Downloads aren't the highest but the engagement is real. This is what people are excited about.

iText - Score: 44/100
Actually pulling the most daily downloads (~17.2k/day) for code-first libs, also updated yesterday. The enterprise crowd is still using this heavily. Just watch that licensing.

PDFsharp - Score: 48/100 The old reliable. 47M total downloads but only ~9k/day now. It works, it's stable, but it's not where the momentum is. Still a solid choice if you need something battle-tested.

HTML/Browser-Based Libraries (Turning Web Pages into PDFs)

Microsoft.Playwright - Score: 71/100 Winner winner. ~23k downloads/day (highest overall), Microsoft backing, actively maintained. If you need HTML-to-PDF, this is probably the move.

PuppeteerSharp - Score: 40/100 Still kicking around at ~8.7k/day but Playwright is clearly the future. Updated last week so it's not dead, just... less popular.

TL;DR - What Should You Actually Use?

Building PDFs from code (not HTML):

• QuestPDF - If you want something modern and the community is raving about it (13.7k stars!)
• iText - If you need enterprise features and can handle the licensing
• PDFsharp - If you want the battle-tested option that's been around forever

Converting HTML/web pages to PDF:

• Playwright - Just use this. It's winning right now (~23k/day), Microsoft-backed, actively maintained. Game over.
• PuppeteerSharp - Only if you really need Chromium-only or you're migrating from Node.js Puppeteer

Bottom line: For HTML-to-PDF, Playwright is dominating. For code-first, QuestPDF has the hype but iText has the downloads. Choose your fighter.

Numbers from GitHub and NuGet as of January 19, 2026. Daily downloads are from the last 90 days.

Is Google AntiGravity Going to Replace Your Main Code Editor?

Today, I tried the new code-editor AntiGravity by Google. "It's beyond a code-editor" by Google 🙄 When I first launch it, I see the UI is almost same as Cursor. They're both based on Visual Studio Code. That's why it was not hard to find what I'm looking for.

First of all, the main difference as I see from the Cursor is; when I type a prompt in the agent section AntiGravity first creates a Task List (like a road-map) and whenever it finishes a task, it checks the corresponding task. Actually Cursor has a similar functionality but AntiGravity took it one step further.

Second thing which was good to me; AntiGravity uses Nano Banana 🍌. This is Google's AI image generation model... Why it's important because when you create an app, you don't need to search for graphics, deal with image licenses. AntiGravity generates images automatically and no license is required!

Third exciting feature for me; AntiGravity is integrated with Google Chrome and can communicate with the running website. When I first run my web project, it installed a browser extension which can see and interact with my website. It can see the results, click somewhere else on the page, scroll, fill up the forms, amazing 😵

Another feature I loved is that you can enter a new prompt even while AntiGravity is still generating a response 🧐. It instantly prioritizes the latest input and adjusts the ongoing process if needed. But in Cursor, if you add a prompt before the cursor finishes, it simply queues it and runs it later 😔.

And lastly, AntiGravity is working very good with Gemini 3.

Well, everything was not so perfect 😥 When I tried AntiGravity, couple of times it stucked AI generation and Agent stopped. I faced errors like this 👇

Debugging .NET Projects via AntiGravity

⚠ There's a crucial development issue with AntiGravity (and also for Cursor, Windsurf etc...) 🤕 you cannot debug your .NET application with AntiGravity 🥺. This is Microsoft's policy! Microsoft doesn't allow debugging for 3rd party IDEs and shows the below error... That's why I cannot say it's a downside of AntiGravity. You need to use Microsft's original VS Code, Visual Studio or Rider for debugging. But wait a while there's a workaround for this, I'll let you know in the next section.

What does this error mean?

AntiGravity, Cursor, Windsurf etc... are using Visual Studio Code and the C# extension for VS Code includes the Microsoft .NET Core Debugger "vsdbg". VS Code is open-source but "vsdbg" is not open-source! It's working only with Visual Studio Code, Visual Studio and Visual Studio for Mac. This is clearly stated at Microsoft's this link.

Ok! How to resolve debugging issue with AntiGravity? and Cursor and Windsurf...

There's a free C# debugger extension for Visual Studio Code based IDEs that supports AntiGravity, Cursor and Windsurf. The extension name is C#. You can download this free C# debugger extension at 👉 open-vsx.org/extension/muhammad-sammy/csharp/. For AntiGravity open Extension window (Ctrl + Shift + X) and search for C#, there you'll see this extension.

After installing, I restarted AntiGravity and now I can see the red circle which allows me to add breakpoint on C# code.

Another Extension For Debugging .NET Apps on VS Code

Recently I heard about DotRush extension from the folks. As they say DotRush works slightly faster and support Razor pages (.cshtml files). Here's the link for DotRush https://github.com/JaneySprings/DotRush

Finding Website Running Port

When you run the web project via C# debugger extension, normally it's not using the launch.json therefore the website port is not the one when you start from Visual Studio / Rider... So what's my website's port which I just run now? Normally for ASP.NET Core the default port is 5000. You can try navigating to http://localhost:5000/. Alternatively you can write the below code in Program.cs which prints the full address of your website in the logs. If you do the steps which I showed you, you can debug your C# application via AntiGravity and other VS Code derivatives.

How Much is AntiGravity? 💲

Currently there's only individual plan is available for personal accounts and that's free 👏! The contents of Team and Enterprise plans and prices are not announced yet. But Gemini 3 is not free! I used it with my company's Google Workspace account which we normally pay for Gemini.

More About AntiGravity

There have been many AI assisted IDEs like Windsurf, Cursor, Zed, Replit and Fleet. But this time it's different, this is backed by Google. As you see from the below image AntiGravity, uses a standard grid layout as others based on VS Code editor. It's very similar to Cursor, Visual Studio, Rider.

Supported LLMs 🧠

Antigravity offers the below models which supports reasoning: Gemini 3 Pro, Claude Sonnet 4.5, GPT-OSS

Antigravity uses other models for supportive tasks in the background:

• Nano banana: This is used to generate images.
• Gemini 2.5 Pro UI Checkpoint: It's for the browser subagent to trigger browser action such as clicking, scrolling, or filling in input.
• Gemini 2.5 Flash: For checkpointing and context summarization, this is used.
• Gemini 2.5 Flash Lite: And when it's need to make a semantic search in your code-base, this is used.

AntiGravity Can See Your Website

This makes a big difference from traditional IDEs. AntiGravity's browser agent is taking screenshots of your pages when it needs to check. This is achieved by a Chrome Extension as a tool to the agent, and you can also prompt the agent to take a screenshot of a page. It can iterate on website designs and implementations, it can perform UI Testing, it can monitor dashboards, it can automate routine tasks like rerunning CI. This is the link for the extension 👉 chromewebstore.google.com/detail/antigravity-browser-exten/eeijfnjmjelapkebgockoeaadonbchdd. AntiGravity will install this extension automatically on the first run.

MCP Integration

When Do We Need MCP in a Code Editor?

Simply if we want to connect to a 3rd party service to complete our task we need MCP. So AntiGravity can connect to your DB and write proper SQL queries or it can pull in recent build logs from Netlify or Heroku. Also you can ask AntiGravity to to connect GitHub for finding the best authentication pattern.

AntiGravity Supports These MCP Servers

Airweave, AlloyDB for PostgreSQL, Atlassian, BigQuery, Cloud SQL for PostgreSQL, Cloud SQL for MySQL, Cloud SQL for SQL Server, Dart, Dataplex, Figma Dev Mode MCP, Firebase, GitHub, Harness, Heroku, Linear, Locofy, Looker, MCP Toolbox for Databases, MongoDB, Neon, Netlify, Notion, PayPal, Perplexity Ask, Pinecone, Prisma, Redis, Sequential Thinking, SonarQube, Spanner, Stripe and Supabase.

Agent Settings ⚙️

The major settings of Agent are:

• Agent Auto Fix Lints: I enabled this setting because I want the Agent automatically fixes its own mistakes for invalid syntax, bad formatting, unused variables, unreachable code or following coding standards... It makes extra tool calls that's why little bit expensive 🥴.
• Auto Execution: Sometimes Agent tries to build application or writing test code and running it, in these cases it executes command. I choose "Turbo" 🤜 With this option, Agent always runs the terminal command and controls my browser.
• Review Policy: How much control you are giving to agent 🙎. I choose "Always Proceed" 👌 because I mostly trust AI 😀. The Agent will never ask for review.

Differences Between Cursor and AntiGravity

While Cursor was the champion of AI code editors, Antigravity brings a different philosophy.

1. "Agent-First 🤖" vs "You-First 🤠"

• Cursor: It acts like an assistant; it predicts your next move, auto-completes your thoughts, and helps you refactor while you type. You are still the driver; Cursor just drives the car at 200 km/h.
• Antigravity: Antigravity is built to let you manage coding tasks. It is "Agent-First." You don't just type code; you assign tasks to autonomous agents (e.g., "Fix the bug in the login flow and verify it in the browser"). It behaves more like a junior developer that you supervise.

2. The Interface

• Cursor: Looks and feels exactly like VS Code. If you know VS Code, you know Cursor.

• Antigravity: Introduces 2 major layouts:

  • Editor View: Similar to a standard IDE
  • Manager View: A dashboard where you see multiple "Agents" working in parallel. You can watch them plan, execute, and test tasks asynchronously.

3. Verification & Trust

• Cursor: You verify by reading the code diffs it suggests.
• Antigravity: Introduces Artifacts... Since the agents work autonomously, they generate proof-of-work documents, screenshots of the app running, browser logs and execution plans. So you can verify what they did without necessarily reading every line of code immediately.

4. Capabilities

• Cursor: Best-in-class Autocomplete ("Tab" feature) and Composer (multi-file editing). It excels at "Vibe Coding". It's getting into a flow state where the AI writes the boilerplate and you direct the logic.
• Antigravity: Is good at Autonomous Execution. It has a built-in browser and terminal that the Agent controls. The Agent can write code, run the server, open the browser, see the error, and fix it 😎

5. AI Models (Brains 🧠)

• Cursor: Model Agnostic. You can switch between Claude 3.5 Sonnet -mostly the community uses this-, GPT-4o, and others.
• Antigravity: Built deeply around Gemini 3 Pro. It leverages Gemini's massive context window (1M+ tokens) to understand huge mono repos without needing as much "RAG" as Cursor.

Try It Yourself Now 🤝

If you are ready to experience the new AI code editor by Google, download and use 👇 Launch Google AntiGravity

Alright, so this debate pops up every few months on dev subreddits and forums

Should you use return codes or exceptions for error handling?

And honestly, there’s no %100 right answer here! Both have pros/cons, and depending on the language or context, one might make more sense than the other. Let’s see...

1. Return Codes --- Said to be "Old School Way" ---

Return codes (like 0 for success, -1 for failure, etc.) are the OG method. You mostly see them everywhere in C and C++. They’re super explicit, the function literally returns the result of the operation.

➕ Advantages of returning codes:

• You always know when something went wrong
• No hidden control flow — what you see is what you get
• Usually faster (no stack unwinding, no exception overhead)
• Easy to use in systems programming, embedded stuff, or performance-critical code

➖ Disadvantages of returning codes:

• It’s easy to forget to check the return value (and boom, silent failure 😬)
• Makes code noisy... Everry function call followed by if (result != SUCCESS) gets annoying
• No stack trace or context unless you manually build one

For example:

try
{
	await SendEmailAsync();
}
catch (Exception e)
{
    Log.Exception(e.ToString());
	return -1;
}

Looks fine… until you forget one of those if conditions somewhere.

2. Exceptions --- The Fancy & Modern Way ---

Exceptions came in later, mostly with higher-level languages like Java, C#, and Python. The idea is that you throw an error and handle it somewhere else.

➕ Advantages of throwing exceptions:

• Cleaner code... You can focus on the happy path and handle errors separately
• Can carry detailed info (stack traces, messages, inner exceptions...)
• Easier to handle complex error propagation

➖ Disadvantages of throwing exceptions:

• Hidden control flow — you don’t always see what might throw
• Performance hit (esp. in tight loops or low-level systems)
• Overused in some codebases (“everything throws everything”)

Example:

try
{
	await SendEmailAsync();
}
catch (Exception e)
{
	Log.Exception(e.ToString());
    throw e;
}

Way cleaner, but if SendEmailAsync() is deep in your call stack and it fails, it can be tricky to know exactly what went wrong unless you log properly.

And Which One’s Better? ⚖️

Depends on what you’re building.

• Low-level systems, drivers, real-time stuff 👉 Return codes. Performance and control matter more.
• Application-level, business logic, or high-level APIs 👉 Exceptions. Cleaner and easier to maintain.

And honestly, mixing both sometimes makes sense. For example, you can use return codes internally and exceptions at the boundary of your API to surface meaningful errors to the user.

Conclusion

Return codes = simple, explicit, but messy.t Exceptions = clean, powerful, but can bite you. Use what fits your project and your team’s sanity level 😅.

6) Telemetry (Logs, Metrics, Traces)

The below code adds OpenTelemetry to collect app logs, metrics, and traces in .NET.

builder.Services.AddOpenTelemetry()
  .UseOtlpExporter()
  .WithMetrics(m => m.AddAspNetCoreInstrumentation().AddHttpClientInstrumentation())
  .WithTracing(t => t.AddAspNetCoreInstrumentation().AddHttpClientInstrumentation());

• UseOtlpExporter() Tells it where to send telemetry. Usually that’s an OTLP collector (like Grafana , Jaeger, Tempo, Azure Monitor). So you can visualize metrics and traces in dashboards.
• WithMetrics() means it'll collects metrics. These metrics are Request rate (RPS), Request duration (latency), GC pauses, Exceptions, HTTP client timings.
• .WithTracing(...) means it'll collect distributed traces. That's useful when your app calls other APIs or microservices. You can see the full request path from one service to another with timings and bottlenecks.

.NET Diagnostic Tools

When your app is on-air, you should know about the below tools. You know in airplanes there's black box recorder which is used to understand why the airplane crashed. For .NET below are our black box recorders. They capture what happened without attaching a debugger.

| Tool | What It Does | When to Use | | --------------------- | --------------------------------------- | ---------------------------- | | dotnet-counters | Live metrics like CPU, GC, request rate | Monitor running apps | | dotnet-trace | CPU sampling & performance traces | Find slow code | | dotnet-gcdump | GC heap dumps (allocations) | Diagnose memory issues | | dotnet-dump | Full process dumps | Investigate crashes or hangs | | dotnet-monitor | HTTP service exposing all the above | Collect telemetry via API |

7) Build & Run .NET App in Docker the Right Way

A multi-stage build is a Docker technique where you use one image for building your app and another smaller image for running it. Why we do multi-stage build, because the .NET SDK image is big but has all the build tools. The .NET Runtime image is small and optimized for production. You copy only the published output from the build stage into the runtime stage.

# build
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY . .
RUN dotnet restore
RUN dotnet publish -c Release -o /app/out -p:PublishTrimmed=true -p:PublishSingleFile=true -p:ReadyToRun=true

# run
FROM mcr.microsoft.com/dotnet/aspnet:9.0
WORKDIR /app
ENV ASPNETCORE_URLS=http://+:8080
EXPOSE 8080
COPY --from=build /app/out .
ENTRYPOINT ["./YourApp"]  # or ["dotnet","YourApp.dll"]

I'll explain what these Docker file commands;

Stage1: Build

• FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build Uses the .NET SDK image including compilers and tools. The AS build name lets you reference this stage later.

• WORKDIR /src Sets the working directory inside the container.

• COPY . . Copies your source code into the container.

• RUN dotnet restore Restores NuGet packages.

• RUN dotnet publish ... Builds the project in Release mode, optimizes it for production, and outputs it to /app/out. The flags;

  • PublishTrimmed=true -> removes unused code
  • PublishSingleFile=true -> bundles everything into one file
  • ReadyToRun=true -> precompiles code for faster startup

Stage 2: Run

• FROM mcr.microsoft.com/dotnet/aspnet:9.0 Uses a lighter runtime image which no compiler, just the runtime.
• WORKDIR /app Where your app will live inside the container.
• ENV ASPNETCORE_URLS=http://+:8080 Makes the app listen on port 8080 (and all network interfaces).
• EXPOSE 8080 Documents the port your container uses (for Docker/K8s networking).
• COPY --from=build /app/out . Copies the published output from the build stage to this final image.
• ENTRYPOINT ["./YourApp"] Defines the command that runs when the container starts. If you published as a single file, it’s ./YourApp. f not, use dotnet YourApp.dll.

8) Security

HTTPS Everywhere Even Behind Proxy

Even if your app runs behind a reverse proxy like Nginx, Cloudflare or a load balancer, always enforce HTTPS. Why? Because internal traffic can still be captured if you don't use SSL and also cookies, HSTS, browser APIs require HTTPS. In .NET, you can easily enforce HTTPS like this:

app.UseHttpsRedirection();

Use HSTS in Production

HSTS (HTTP Strict Transport Security) tells browsers:

Always use HTTPS for this domain — don’t even try HTTP again!

Once you set, browsers cache this rule, so users can’t accidentally hit the insecure version. You can easily enforce this as below:

if (!app.Environment.IsDevelopment())
{
    app.UseHsts();
}

When you use HSTS, it sends browser this HTTP header: Strict-Transport-Security: max-age=31536000; includeSubDomains. Browser will remember this setting for 1 year (31,536,000 seconds) that this site must only use HTTPS. And includeSubDomains option applies the rule to all subdomains as well (eg: api.abp.io, cdn.abp.io, account.abp.io etc..)

Store Secrets on Environment Variables or Secret Stores

Never store passwords, connection strings, or API keys in your code or Git. Then where should we keep them?

• Best/practical way is Environment variables. You can easily sett an environment variable in a Unix-like system as below:

  • export ConnectionStrings__Default="Server=...;User Id=...;Password=..."
    

• And you can easily access these environment variables from your .NET app like this:

  • var conn = builder.Configuration.GetConnectionString("Default");
    

Or Secret stores like: Azure Key Vault, AWS Secrets Manager, HashiCorp Vault

Add Rate-Limiting to Public Endpoints

Don't forget there'll be not naive guys who will use your app! We've many times faced this issue in the past on our public front-facing websites. So protect your public APIs from abuse, bots, and DDoS. Use rate-limiting!!! Stop brute-force attacks, prevent your resources from exhaustion...

In .NET, there's a built-in rate-limit feature for .NET (System.Threading.RateLimiting):

builder.Services.AddRateLimiter(_ => _
    .AddFixedWindowLimiter("default", options =>
    {
        options.PermitLimit = 100;
        options.Window = TimeSpan.FromMinutes(1);
    }));

app.UseRateLimiter();

• Also there's an open-source rate-limiting library -> github.com/stefanprodan/AspNetCoreRateLimit
• Another one -> nuget.org/packages/Polly.RateLimiting

Secure Cookies

Cookies are often good targets for attacks. You must secure them properly otherwise you can face cookie stealing or CSRF attack.

options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
options.Cookie.SameSite = SameSiteMode.Strict; // or Lax

• SecurePolicy = Always -> only send cookies over HTTPS
• SameSite=Lax/Strict -> prevent CSRF (Cross-Site Request Forgery)
  • Strict = safest
  • Lax = good balance for login sessions

9) Startup/Cold Start

Keep Tiered JIT On

The JIT (Just-In-Time) compiler converts your app’s Intermediate Language (IL) into native CPU instructions when the code runs. Tiered JIT means the runtime uses 2 stages of compilation. Actually this setting is enabled by default in modern .NET. So just keep it on.

1. Tier 0 (Quick JIT): Fast, low-optimization compile → gets your app running ASAP. (Used at startup.)
2. Tier 1 (Optimized JIT): Later, the runtime re-compiles hot methods (frequently used ones) with deeper optimizations for speed.

Use PGO (Profile-Guided Optimization)

PGO lets .NET learn from real usage of your app. It profiles which functions are used most often, then re-optimizes the build for that pattern. You can think of it as the runtime saying:

I’ve seen what your app actually does... I’ll rearrange and optimize code paths accordingly.

In .NET 8+, you don’t have to manually enable PGO (Profile-Guided Optimization). The JIT collects runtime profiling data (e.g. which types are common, branch predictions) and uses it to generate more optimized code later. In .NET 9, PGO has been improved: the JIT uses PGO data for more patterns (like type checks / casts) and makes better decisions.

10) Graceful Shutdown

When we break up with our lover, we often argue and regret it later. When an application breaks up with an operating system, it should be done well 😘 ... When your app stops, maybe you deploy a new version or Kubernetes restarts a pod... the OS sends a signal called SIGTERM (terminate). A graceful shutdown means handling that signal properly, finishing what’s running, cleaning up, and exiting cleanly (like an adult)!

var app = builder.Build();
var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();
lifetime.ApplicationStopping.Register(() =>
{
    // stop accepting, finish in-flight, flush telemetry
});
app.Run();

On K8s, set terminationGracePeriodSeconds and wire readiness/startup probes.

11) Load Test

Sometimes arguing with our lover is good. We can see her/his face before marrying 😀 Use k6 or bombardier and test with realistic payloads and prod-like limits. Don't be surprise later when your app is running on prod! These topics should be tested: CPU % , Time in GC , LOH Allocations , ThreadPool Queue Length and Socket Exhaustion.

About K6

• A modern load testing tool, using Go and JavaScript.

• 29K stars on GitHub

• GitHub address: https://github.com/grafana/k6

About Bombardier

• Fast cross-platform HTTP benchmarking tool written in Go.

• 7K stars on GitHub

• GitHub address: https://github.com/codesenberg/bombardier

Summary

In summary, I listed 11 items for optimizing a .NET application for production; Covering build configuration, hosting setup, runtime behavior, data access, telemetry, containerization, security, startup performance and reliability under load. By applying the checklist from Part 1 and Part 2 of this series, leveraging techniques like trimmed releases, server GC, minimal payloads, pooled DbContexts, OpenTelemetry, multi-stage Docker builds, HTTPS enforcement, and proper shutdown handling—you’ll improve your app’s durability, scalability and maintainability under real-world traffic and production constraints. Each item is a checkpoint and you’ll be able to deliver a robust, high-performing .NET application ready for live users.

🎉 Want top-tier .NET performance without the headaches? Try ABP Framework for best-performance and skip all the hustles of .NET app development.

I see way too many .NET apps go to prod like it’s still “F5 on my laptop.” Here’s the checklist I wish someone shoved me years ago. It’s opinionated, pragmatic, copy-pasteable.

1) Publish Command and CSPROJ Settings

Never go to production with debug build! See the below command which publishes properly a .NET app for production.

dotnet publish -c Release -o out -p:PublishTrimmed=true -p:PublishSingleFile=true -p:ReadyToRun=true

csproj for the optimum production publish:

<PropertyGroup>
  <PublishReadyToRun>true</PublishReadyToRun>
  <PublishTrimmed>true</PublishTrimmed>
  <InvariantGlobalization>true</InvariantGlobalization>
  <TieredCompilation>true</TieredCompilation>
</PropertyGroup>

• PublishTrimmed It's trimmimg assemblies. What's that!? It removes unused code from your application and its dependencies, hence it reduces the output files.

• PublishReadyToRun When you normally build a .NET app, your C# code is compiled into IL (Intrmediate Language). When your app runs, the JIT Compiler turns that IL code into native CPU commands. But this takes much time on startup. When you enable PublishReadyToRun, the build process precompiles your IL into native code and it's called AOT (Ahead Of Time). Hence your app starts faster... But the downside is; the output files are now a bit bigger. Another thing; it'll compile only for a specific OS like Windows and will not run on Linux anymore.

• Self-contained When you publish your .NET app this way, it ncludes the .NET runtime inside your app files. It will run even on a machine that doesn’t have .NET installed. The output size gets larger, but the runtime version is exactly what you built with.

2) Kestrel Hosting

By default, ASP.NET Core app listen only localhost, it means it accepts requests only from inside the machine. When you deploy to Docker or Kubernetes, the container’s internal network needs to expose the app to the outside world. To do this you can set it via environment variable as below:

ASPNETCORE_URLS=http://0.0.0.0:8080

Also if you’re building an internall API or a containerized microservice which is not multilngual, then add also the below setting. it disables operating system's globalization to reduce image size and dependencies..

DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1

Clean Program.cs startup! Here's a minimal Program.cs which includes just the essential middleware and settings:

var builder = WebApplication.CreateBuilder(args);

builder.Logging.ClearProviders();
builder.Logging.AddConsole();

builder.Services.AddResponseCompression();
builder.Services.AddResponseCaching();
builder.Services.AddHealthChecks();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/error");
    app.UseHsts();
}

app.UseResponseCompression();
app.UseResponseCaching();

app.MapHealthChecks("/health");
app.MapGet("/error", () => Results.Problem(statusCode: 500));

app.Run();

3) Garbage Collection and ThreadPool

GC Memory Cleanup Mode

GC (Garbage Collection) is how .NET automatically frees memory. There are two main modes:

• Workstation GC: good for desktop apps (focuses on responsiveness)
• Server GC: good for servers (focuses on throughput)

The below environment variable is telling the .NET runtime to use the Server Garbage Collector (Server GC) instead of the Workstation GC. Because our ASP.NET Core app must be optmized for servers not personal computers.

COMPlus_gcServer=1

GC Limit Memory Usage

Use at max 60% of the total available memory for the managed heap (the memory that .NET’s GC controls). So if your container or VM has, let's say 4 GB of RAM, .NET will try to keep the GC heap below 2.4 GB (60% of 4 GB). Especially when you run your app in containers, don’t let the GC assume host memory:

COMPlus_GCHeapHardLimitPercent=60

Thread Pool Warm-up

When your .NET app runs, it uses a thread pool. This is for handling background work like HTTP requests, async tasks, I/O things... By default, the thread pool starts small and grows dynamically as load increases. That’s good for desktop apps but for server apps it's too slow! Because during sudden peek of traffic, the app might waste time creating threads instead of handling requests. So below code keeps at least 200 worker threads and 200 I/O completion threads ready to go even if they’re idle.

ThreadPool.SetMinThreads(200, 200);

4) HTTP Performance

HTTP Response Compression

AddResponseCompression() enables HTTP response compression. It shrinks your outgoing responses before sending them to the client. Making smaller payloads for faster responses and uses less bandwidth. Default compression method is Gzip. You can also add Brotli compression. Brotli is great for APIs returning JSON or text. If your CPU is already busy, keep the default Gzip method.

builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<BrotliCompressionProvider>();
    options.EnableForHttps = true;
});

HTTP Response Caching

Use caching for GET endpoints where data doesn’t change often (e.g., configs, reference data). ETags and Last-Modified headers tell browsers or proxies skip downloading data that hasn’t changed.

• ETag = a version token for your resource.
• Last-Modified = timestamp of last change.

If a client sends If-None-Match: "abc123" and your resource’s ETag hasn’t changed, .NET automatically returns 304 Not Modified.

HTTP/2 or HTTP/3

These newer protocols make web requests faster and smoother. It's good for microservices or frontends making many API calls.

• HTTP/2 : multiplexing (many requests over one TCP connection).
• HTTP/3 : uses QUIC (UDP) for even lower latency.

You can enable them on your reverse proxy (Nginx, Caddy, Kestrel)... .NET supports both out of the box if your environment allows it.

Minimal Payloads with DTOs

The best practise here is; Never send/recieve your entire database entity, use DTOs. In the DTOs include only the fields the client actually needs by doing so you will keep the responses smaller and even safer. Also, prefer System.Text.Json (now it’s faster than Newtonsoft.Json) and for very high-traffic APIs, use source generation to remove reflection overhead.

//define your entity DTO
[JsonSerializable(typeof(MyDto))]
internal partial class MyJsonContext : JsonSerializerContext { }

//and simply serialize like this    
var json = JsonSerializer.Serialize(dto, MyJsonContext.Default.MyDto)

5) Data Layer (Mostly Where Most Apps Slow Down!)

Reuse DbContext via Factory (Pooling)

Creating a new DbContext for every query is expensive! Use IDbContextFactory<TContext>, it gives you pooled DbContext instances from a pool that reuses objects instead of creating them from scratch.

services.AddDbContextFactory<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

Then inject the factory:

using var db = _contextFactory.CreateDbContext();

Also, ensure your database server (SQL Server, PostgreSQL....) has connection pooling enabled.

N+1 Query Problem

The N+1 problem occurs when your app runs one query for the main data, then N more queries for related entities. That kills performance!!!

Bad-Practise:

var users = await context.Users.Include(u => u.Orders).ToListAsync();

Good-Practise: Project to DTOs using .Select() so EF-Core generates a single optimized SQL query:

var users = await context.Users.Select(u => new UserDto
   {
        Id = u.Id,
        Name = u.Name,
        OrderCount = u.Orders.Count
    }).ToListAsync();

Indexes

Use EF Core logging, SQL Server Profiler, or EXPLAIN (Postgres/MySQL) to find slow queries. Add missing indexes only where needed. For example at this page, he wrote an SQL query which lists missing index list (also there's another version at Microsoft Docs). This perf improvement is mostly applied after running the app for a period of time.

Migrations

In production run migrations manually, never do it on app startup. That way you can review schema changes, back up data and avoid breaking the live DB.

Resilience with Polly

Use Polly for retries, timeouts and circuit breakers for your DB or HTTP calls. Handles short outages gracefully

To keep the article short and for the better readability I spitted it into 2 parts 👉 Continue with the second part here...

So since .NET 8 there's been one feature that’s quietly a game-changer for performance nerds is Native AOT (Ahead-of-Time compilation). If you’ve ever fought with sluggish cold starts (especially in containerized or serverless environments), or dealt with memory pressure from bloated apps, Native AOT might just be your new best friend.

What is Native AOT?

Normally, .NET apps ship as IL (Intermediate Language) and JIT-compile at runtime. That’s flexible, but it takes longer startup time and memory. Native AOT flips the script: your app gets compiled straight into a platform-specific binary before it ever runs.

As a result;

• No JIT overhead at startup.
• Smaller memory footprint (no JIT engine or IL sitting around).
• Faster startup (especially noticeable in microservices, functions, or CLI tools).

Advantages of AOT

• Broader support → More workloads and libraries now play nice witt.h AOT.
• Smaller output sizes → Trimmed down runtime dependencies.
• Better diagnostics → Easier to figure out why your build blew up (because yes, AOT can be picky).
• ASP.NET Core AOT → Minimal APIs and gRPC services actually benefit massively here. Cold starts are crazy fast.

Why you should care

If you’re building:

• Serverless apps (AWS Lambda, Azure Functions, GCP Cloud Run) → Startup time matters a LOT.
• Microservices → Lightweight services scale better when they use less memory per pod.
• CLI tools → No one likes waiting half a second for a tool to boot. AOT makes them feel “native” (because they literally are).

And yeah, you can get Go-like startup performance in .NET now.

The trade-offs (because nothing’s free)

Native AOT isn’t a silver bullet:

• Build times are longer (the compiler does all the heavy lifting upfront).
• Less runtime flexibility (no reflection-based magic, dynamic codegen, or IL rewriting).
• Debugging can be trickier.

Basically: if you rely heavily on reflection-heavy libs or dynamic runtime stuff, expect pain.

Quick demo (conceptual)

# Regular publish
dotnet publish -c Release

# Native AOT publish
dotnet publish -c Release -r win-x64 -p:PublishAot=true

Boom. You get a native executable. On Linux, drop it into a container and watch that startup time drop like a rock.

Conclusion

• Native AOT in .NET 8 = faster cold starts + lower memory usage.
• Perfect for microservices, serverless, and CLI apps.
• Comes with trade-offs (longer builds, less dynamic flexibility).
• If performance is critical, it’s absolutely worth testing.

Whether you’re building enterprise apps, microservices, or SaaS platforms, using the right libraries can help you ship faster and scale effortlessly. Here are some high-performance .NET libraries you might not know but definitely should.

1. BenchmarkDotNet – Measure before you optimize

BenchmarkDotNet makes it simple to benchmark .NET code with precision.

• Easy setup with [Benchmark] attributes
• Generates detailed performance reports
• Works with .NET Core, .NET Framework, and Mono

Perfect for spotting bottlenecks in APIs, background services, or CPU-bound operations.

• NuGet (40M downloads) 🔗 https://www.nuget.org/packages/BenchmarkDotNet
• GitHub (11k stars) 🔗 https://github.com/dotnet/BenchmarkDotNet

2. MessagePack – Fastest JSON serializer

Need speed beyond System.Text.Json or Newtonsoft.Json? MessagePack is the fastest serializer for C# (.NET, .NET Core, Unity, Xamarin). MessagePack has a compact binary size and a full set of general-purpose expressive data types. Ideal for high-traffic APIs, IoT data processing, and microservices.

• NuGet (204M downloads) 🔗 https://www.nuget.org/packages/messagepack
• GitHub (6.4K stars) 🔗 https://github.com/MessagePack-CSharp/MessagePack-CSharp

3. Polly – Resilience at scale

In distributed systems, failures are inevitable. Polly provides a fluent way to add retry, circuit-breaker, and fallback strategies.

• Handle transient faults gracefully
• Improve uptime and user experience
• Works seamlessly with HttpClient and gRPC

A must-have for cloud-native .NET applications.

• NuGet (1B downloads) 🔗 https://www.nuget.org/packages/polly/
• GitHub (14K stars) 🔗 https://github.com/App-vNext/Polly

4. MemoryPack – Zero-cost binary serialization

If you need blazing-fast serialization for in-memory caching or network transport, MemoryPack is a game-changer.

• Zero-copy, zero-alloc serialization
• Perfect for high-performance caching or game servers
• Strongly typed and version-tolerant

Great for real-time multiplayer games, chat apps, or financial systems.

• NuGet (5.3M downloads) 🔗 https://www.nuget.org/packages/MemoryPack
• GitHub (4K stars) 🔗 https://github.com/Cysharp/MemoryPack

5. WolverineFx – Ultra-low latency messaging

MediatR was one of the best mediator libraries, but now it's a paid library. Wolverine is a toolset for command execution and message handling within .NET applications. The killer feature of Wolverine is its very efficient command execution pipeline that can be used as:

• An inline "mediator" pipeline for executing commands
• A local message bus for in-application communication
• A full-fledged asynchronous messaging framework for robust communication and interaction between services when used in conjunction with low-level messaging infrastructure tools like RabbitMQ
• With the WolverineFx.Http library, Wolverine's execution pipeline can be used directly as an alternative ASP.NET Core Endpoint provider

image below is from codecrash.net

WolverineFx is great for cleanly separating business logic from controllers while unifying in-process mediator patterns with powerful distributed messaging in a single, high-performance .NET library.

• NuGet (1.5M downloads) 🔗 https://www.nuget.org/packages/WolverineFx
• GitHub (1.7K stars) 🔗 https://github.com/JasperFx/wolverine

6. Disruptor-net – Next generation free .NET mediator

The Disruptor is a high-performance inter-thread message passing framework. A lock-free ring buffer for ultra-low latency messaging. Features are:

• Zero memory allocation after initial setup (the events are pre-allocated).

• Push-based consumers.

• Optionally lock-free.

• Configurable wait strategies.

• NuGet (1.2M downloads) 🔗 https://www.nuget.org/packages/Disruptor/
• GitHub (1.3K stars) 🔗 https://github.com/disruptor-net/Disruptor-net

7. CliWrap - Running command-line processes

CliWrap makes it easy to run and manage external CLI processes in .NET.

• Fluent, task-based API for starting commands
• Streams standard input/output and error in real time
• Supports cancellation, timeouts, and piping between processes

Ideal for automation, build tools, and integrating external executables.

• NuGet (14.1M downloads) 🔗 https://www.nuget.org/packages/CliWrap
• GitHub (4.7K stars) 🔗 https://github.com/Tyrrrz/CliWrap

Hidden Libs from the Community

Sylvan.Csv & Sep

• Sylvan.Csv: Up to 10× faster and 100× less memory allocations than CsvHelper, making CSV processing lightning-fast. (Reddit)
• Sep: Even faster than Sylvan, but trades off some flexibility. Great when performance matters more than API richness. (Reddit)

String Parsing: csFastFloat

• Parses float and double around 8–9× faster than .Parse methods—perfect for high-volume parsing tasks. (Reddit)

CySharp’s Suite: MemoryPack, MasterMemory, SimdLinq

• MemoryPack: One of the fastest serializers available, with low allocations and high throughput. Ideal for Web APIs or microservices. (Reddit)
• MasterMemory: Designed for databases or config storage. Claims 4,700× faster than SQLite with zero-allocations per query. (Reddit)
• SimdLinq: SIMD-accelerated LINQ operations supporting a broader set of methods than .NET's built-in SIMD. Works when slight floating-point differences are acceptable. (Reddit)

Jil – JSON Deserializer

• Ultra-fast JSON (de)serializer with low memory overhead, used in high-scale systems. (Performance is a Feature!)

StackExchange.NetGain – WebSocket Efficiency

• High-performance WebSocket server library designed for low-latency IO scenarios. (Now mostly replaced by Kestrel's built-in support, but worth knowing.) (GitHub)

Math Libraries: Math.NET Numerics & ILNumerics

• Math.NET Numerics: Core numerical methods and matrix math, similar to BLAS/LAPACK. (Wikipedia)
• ILNumerics: Efficient numerical arrays with parallelized processing, loop unrolling and cache optimizations. Great for scientific computing. (Wikipedia)

The next version of .NET is .NET 10 and it is coming with Long-Term Support (LTS), scheduled for November 2025.

On September 9, 2025, Microsoft released .NET 10 Release Candidate 1 (RC1), which supports go-live usage and is compatible with Visual Studio 2026 Insider and Visual Studio Code Insider via the C# Dev Kit extension.

.NET 10 Runtime Enhancements

• JIT Speed-ups: Enhanced struct argument handling—members now go directly into registers, reducing memory load/store operations.
• Advanced Loop Optimization: New graph-based loop inversion improves precision and boosts further optimizations.
• Array Interface De-virtualization: Critical for performance, now array-based enumerations inline and skip virtual calls including de-abstraction of array enumeration and small-array stack allocation.
• General JIT Improvements: Better code layout and branch reduction support overall efficiency.

Language & Library Upgrades

C# 14 Enhancements

• Field-backed properties: easier custom getters/setters.
• nameof for unbound generics like List<>.
• Implicit conversions for Span<T> and ReadOnlySpan<T>.
• Lambda parameter modifiers (ref, in, out).
• Partial constructors/events.
• extension blocks for static extension members.
• Null-conditional assignment (?.=) and custom compound/increment operators.

F# & Visual Basic Enhancements

• F# improvements via <LangVersion>preview</LangVersion>, updated FSharp.Core, and compiler fixes.
• VB compiler supports unmanaged generics and respects OverloadResolutionPriorityAttribute for performance and overload clarity.

.NET Libraries & SDK

Libraries:

• Better ZipArchive performance (lazy entry loading).
• JSON improvements, including JsonSourceGenerationOptions and reference-handling tweaks.
• Enhanced OrderedDictionary, ISOWeek date APIs, PEM data and certificate handling, CompareOptions.NumericOrdering

SDK & CLI:

• No major new SDK features in RC1—you should expect stability fixes rather than additions.
• Earlier previews brought JSON support improvements (e.g., PipeReader for JSON, WebSocketStream, ML-DSA crypto, AES KeyWrap), TLS 1.3 for macOS

ASP.NET Core & Blazor

Blazor & Web App Security:

Enhanced OIDC and Microsoft Entra ID integration, including encrypted token caching and Key Vault use.

UI Enhancements:

• QuickGrid gains RowClass for conditional styling.
• Scripts now served as static assets with compression and fingerprinting.
• NavigationManager no longer scrolls to top for same-page updates.

API Improvements:

Full support for OpenAPI 3.1 (JSON Schema draft 2020-12), and metrics for authentication/authorization events (e.g., sign-ins, logins) .

.NET MAUI

Updates include multiple file selection, image compression, WebView request interception, and support for Android API 35/36.

EF Core

LINQ enhancements, performance boosts, better Azure Cosmos DB support, and more flexible named query filters.

Breaking Changes in .NET 10

ASP.NET Core - Breaking Changes in .NET 10:

.NET 10 Preview 7 brings several deprecations + behavior changes, while RC1 removes the old WebHost model.

• Cookie login redirects disabled → Redirects no longer occur for API endpoints; APIs now return 401/403. (Behavioral change)
• WithOpenApi deprecated → Extension method removed; use updated OpenAPI generator features. (Source incompatible)
• Exception diagnostics suppressed → When TryHandleAsync returns true, exception details aren’t logged. (Behavioral change)
• IActionContextAccessor obsolete → Marked obsolete; may break code depending on it. (Source/behavioral change)
• IncludeOpenAPIAnalyzers deprecated → Property and MVC API analyzers removed. (Source incompatible)
• IPNetwork & KnownNetworks obsolete → Old networking APIs removed in favor of new ones. (Source incompatible)
• ApiDescription.Client package deprecated → No longer maintained; migrate to other tools. (Source incompatible)
• Razor run-time compilation obsolete → Disabled at runtime; precompilation required. (Source incompatible)
• WebHostBuilder, IWebHost, WebHost obsolete → Legacy hosting model deprecated; use WebApplicationBuilder. (Source incompatible, RC1)

EF Core - Breaking Changes in .NET 10:

You can find the complete list at Microsoft EF Core 10 Breaking Changes page. Here's the brief summary:

EF Core - SQL Server

• JSON column type by default (Azure SQL / compat level ≥170). Primitive collections and owned types mapped to JSON now use SQL Server’s native json type instead of nvarchar(max). A migration may alter existing columns. Mitigate by setting compat level <170 or explicitly forcing nvarchar(max).
• ExecuteUpdateAsync signature change. Column setters now take a regular Func<…> (not an expression). Dynamic expression-tree code won’t compile; replace with imperative setters inside the lambda.

Microsoft.Data.Sqlite

• GetDateTimeOffset (no offset) assumes UTC. Previously assumed local time. You can temporarily revert via AppContext.SetSwitch("Microsoft.Data.Sqlite.Pre10TimeZoneHandling", true).
• Writing DateTimeOffset to REAL stores UTC. Conversion now happens before writing; revertable with the same switch.
• GetDateTime (with offset) returns UTC DateTime (DateTimeKind.Utc). Was Local before. Same temporary switch if needed.

Who’s most affected

• Apps on Azure SQL / SQL Server 2025 using JSON mapping.
• Codebases building expression trees for bulk updates.
• Apps using SQLite with date/time parsing or REAL timestamp storage.

Quick mitigations

• Set SQL Server compatibility <170 or force column type.
• Rewrite ExecuteUpdateAsync callers to use the new delegate form.
• For SQLite, update handling to UTC or use the temporary AppContext switch while transitioning.

Containers - Breaking Changes in .NET 10:

Default .NET images now use Ubuntu.

Core Libraries - Breaking Changes in .NET 10:

ActivitySource behavior tweaks; generic math shift behavior aligned; W3C trace context is default; DriveInfo reports Linux FS types; InlineArray size rules tightened; System.Linq.AsyncEnumerable included in core libs...

Cryptography - Breaking Changes in .NET 10:

Stricter X500 name validation; OpenSSL primitives unsupported on macOS; some key members nullable/renamed; env var rename to DOTNET_OPENSSL_VERSION_OVERRIDE.

Extensions - Breaking Changes in .NET 10:

Config preserves nulls; logging/package/trim annotations changes; some trim-unsafe code annotations removed.

Globalization & Interop - Breaking Changes in .NET 10:

ICU env var renamed; single-file apps stop probing executable dir for native libs; DllImport search path tightened.

Networking:

HTTP/3 disabled by default when trimming; default cert revocation check now Online; browser clients stream responses by default; URI length limits removed.

SDK & MSBuild/NuGet - Breaking Changes in .NET 10:

dotnet --interactive defaults to true; tool packages are RID-specific; workload sets default; dotnet new sln uses SLNX; restore audits transitives; local tool install creates manifest by default; project.json not supported; stricter NuGet validation/errors.

WinForms/WPF:

Multiple API obsoletions/parameter renames; rendering/behavior tweaks; stricter XAML rules (e.g., disallow empty row/column definitions or incorrect usage of DynamicResource will crash).

Support Policy for .NET 10

As you can see from the picture below, .NET 10 has long term support therefore it will be maintained for 3 years until November 2028.

Download .NET10

Click 👉 https://dotnet.microsoft.com/en-us/download/dotnet/10.0 to download the latest release candidate (currently RC.1).

Also to use the latest features, download/update your Visual Studio to the latest 👉 https://visualstudio.microsoft.com/downloads/

Introduction

AutoMapper has been one of the most popular mapping library for .NET apps. It has been free and open-source since 2009. On 16 April 2025, Jimmy Bogard (the owner of the project) decided to make it commercial for his own reasons. You can read this announcement about what happened to AutoMapper.

Why AutoMapper’s licensing change matters

In ABP Framework we have been also using AutoMapper for object mappings. After its commercial transition, we also needed to replace it. Because ABP Framework is open-source and under LGPL-3.0 license.

TL;DR

That's why, we decided to replace AutoMapper with Mapperly.

In this article, we'll discuss the alternatives of AutoMapper so that you can cut down on costs and maximize performance while retaining control over your codebase. Also I'll explain why we chose Mapperly.

Also AutoMapper uses heavily reflection. And reflection comes with a performance cost if used indiscriminately, and compile-time safety is limited. Let's see how we can overcome these...

Cost-Free Alternatives to AutoMapper

Check out the comparison table for key features vs. AutoMapper.

| | AutoMapper (Paid) | Mapster (Free) | Mapperly (Free) | AgileMapper (Free) | Manual Mapping | | ------------------- | ----------------------------------------------- | ----------------------------------------- | -------------------------------------------- | ------------------------------------------- | ------------------------------------------------ | | License & Cost | Paid/commercial | Free, MIT License | Free, MIT License | Free, Apache 2.0 | Free (no library) | | Performance | Slower due to reflection & conventions | Very fast (runtime & compile-time modes) | Very fast (compile-time code generation) | Good, faster than AutoMapper | Fastest (direct assignment) | | Ease of Setup | Easy, but configuration-heavy | Easy, minimal config | Easy, but different approach from AutoMapper | Simple, flexible configuration | Manual coding required | | Features | Rich features, conventions, nested mappings | Strong typed mappings, projection support | Strong typed, compile-time safe mappings | Dynamic & conditional mapping | Whatever you code | | Maintainability | Hidden mappings can be hard to debug | Explicit & predictable | Very explicit, compiler-verified mappings | Readable, good balance | Very explicit, most maintainable | | Best For | Large teams used to AutoMapper & willing to pay | Teams wanting performance + free tool | Teams prioritizing type-safety & performance | Developers needing flexibility & simplicity | Small/medium projects, performance-critical apps |

There are other libraries such as ExpressMapper (308 GitHub stars), ValueInjecter (258 GitHub stars), AgileMapper (463 GitHub stars). These are not very popular but also free and offer a different balance of simplicity and features.

Why We Chose Mapperly

We filtered down all the alternatives into 2: Mapster and Mapperly.

The crucial factor was maintainability! As you see from the screenshots below, Mapster is already stopped development. Mapster’s development appears stalled, and its future maintenance is uncertain. On the other hand, Mapperly regularly gets commits. The community support is valuable.

We looked up different alternatives of AutoMapper also, here's the initial issue of AutoMapper replacement github.com/abpframework/abp/issues/23243.

The ABP team started Mapperly integration with this initial commit github.com/abpframework/abp/commit/178d3f56d42b4e5acb7e349470f4a644d4c5214e. And this is our Mapperly integration package : github.com/abpframework/abp/tree/dev/framework/src/Volo.Abp.Mapperly.

Here are some considerations for developers who are used to ABP and AutoMapper.

Mapster:

• ✔ It is similar to AutoMapper, configuring mappings through code.
• ✔ Support for dependency injection and complex runtime configuration.
• ❌ It is looking additional Mapster maintainers (Call for additional Mapster maintainers MapsterMapper/Mapster#752)

Mapperly:

• ✔ It generates mapping code( source generator) during the build process.
• ✔ It is actively being developed and maintained.
• ❌ It is a static map method, which is not friendly to dependency injection.
• ❌ The configuration method is completely different from AutoMapper, and there is a learning curve.

Mapperly → generates mapping code at compile time using source generators.

Mapster → has two modes:

• By default, it uses runtime code generation (via expression trees and compilation).

• But with Mapster.Tool (source generator), it can also generate mappings at compile time.

This is important because it guarantees the mappings are working well. Also they provide type safety and improved performance. Another advantages of these libraries, they eliminate runtime surprises and offer better IDE support.

When Mapperly Will Come To ABP

Mapperly integration will be delivered with ABP v10. If you have already defined AutoMapper configurations, you can still keep and use them. But the framework will use Mapperly. So there'll be 2 mapping integrations in your app. You can also remove AutoMapper from your final application and use one mapping library: Mapperly. It's up to you! Check AutoMapper pricing table.

Migrating from AutoMapper to Mapperly

In ABP v10, we will be migrating from AutoMapper to Mapperly. The document about the migration is not delivered by the time I wrote this article, but you can reach the document in our dev docs branch

• github.com/abpframework/abp/blob/dev/docs/en/release-info/migration-guides/AutoMapper-To-Mapperly.md.

Also for ABP, you can check out how you will define DTO mappings based on Mapperly at this document

• github.com/abpframework/abp/blob/dev/docs/en/framework/infrastructure/object-to-object-mapping.md

Mapping Code Examples for AutoMapper, Mapster, AgileMapper

AutoMapper vs Mapster vs Mapperly Performance

Here are concise, drop-in side-by-side C# snippets that map the same model with AutoMapper, Mapster, AgileMapper, and manual mapping.

Models used in all examples

We'll use these models to show the mapping examples for AutoMapper, Mapster, AgileMapper.

public class Order
{
    public int Id { get; set; }
    public Customer Customer { get; set; } = default!;
    public List<OrderLine> Lines { get; set; } = new();
    public DateTime CreatedAt { get; set; }
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public string? Email { get; set; }
}

public class OrderLine
{
    public int ProductId { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
}

public class OrderDto
{
    public int Id { get; set; }
    public string CustomerName { get; set; } = "";
    public int ItemCount { get; set; }
    public decimal Total { get; set; }
    public string CreatedAtIso { get; set; } = "";
}

AutoMapper Example (Paid)

public sealed class OrderProfile : Profile
{
    public OrderProfile()
    {
        CreateMap<Order, OrderDto>()
            .ForMember(d => d.CustomerName, m => m.MapFrom(s => s.Customer.Name))
            .ForMember(d => d.ItemCount,   m => m.MapFrom(s => s.Lines.Sum(l => l.Quantity)))
            .ForMember(d => d.Total,       m => m.MapFrom(s => s.Lines.Sum(l => l.Quantity * l.UnitPrice)))
            .ForMember(d => d.CreatedAtIso,m => m.MapFrom(s => s.CreatedAt.ToString("O")));
    }
}

// registration
services.AddAutoMapper(typeof(OrderProfile));

// mapping
var dto = mapper.Map<OrderDto>(order);

// EF Core projection (common pattern)
var list = dbContext.Orders
    .ProjectTo<OrderDto>(mapper.ConfigurationProvider)
    .ToList();

NuGet Packages:

• https://www.nuget.org/packages/AutoMapper
• https://www.nuget.org/packages/AutoMapper.Extensions.Microsoft.DependencyInjection

Mapperly (Free, Apache-2.0)

This is compile-time generated mapping.

[Mapper] // generates the implementation at build time
public partial class OrderMapper
{
    // Simple property mapping: Customer.Name -> CustomerName
    [MapProperty(nameof(Order.Customer) + "." + nameof(Customer.Name), nameof(OrderDto.CustomerName))]
    public partial OrderDto ToDto(Order source);

    // Update an existing target (like MapToExisting)
    [MapProperty(nameof(Order.Customer) + "." + nameof(Customer.Name), nameof(OrderDto.CustomerName))]
    public partial void UpdateDto(Order source, OrderDto target);

    public OrderDto Map(Order s)
    {
        var d = ToDto(s);
        AfterMap(s, d);
        return d;
    }

    public void Map(Order source, OrderDto d)
    {
        UpdateDto(source, d);
        AfterMap(source, d);
    }

    private void AfterMap(Order source, OrderDto d)
    {
        d.ItemCount = source.Lines.Sum(l => l.Quantity);
        d.Total = source.Lines.Sum(l => l.Quantity * l.UnitPrice);
        d.CreatedAtIso = source.CreatedAt.ToString("O");
    }
}


//USAGE
var mapper = new OrderMapper();
var order = new Order
{
    Id = 1,
    Customer = new Customer { Id = 1, Name = "John Doe", Email = "johndoe@abp.io" },
    Lines =
    [
        new OrderLine {ProductId = 1, Quantity = 2, UnitPrice = 10.0m},
        new OrderLine {ProductId = 2, Quantity = 1, UnitPrice = 20.0m}
    ]
};

// Map to a new object
var dto = mapper.Map(order);

// Map to an existing object
var target = new OrderDto();
mapper.Map(order, target);

NuGet Packages:

• https://www.nuget.org/packages/Riok.Mapperly/

Mapster Example (Free, MIT)

TypeAdapterConfig<Order, OrderDto>.NewConfig()
    .Map(d => d.CustomerName, s => s.Customer.Name)
    .Map(d => d.ItemCount,    s => s.Lines.Sum(l => l.Quantity))
    .Map(d => d.Total,        s => s.Lines.Sum(l => l.Quantity * l.UnitPrice))
    .Map(d => d.CreatedAtIso, s => s.CreatedAt.ToString("O"));

// one-off
var dto = order.Adapt<OrderDto>();

// DI-friendly registration
services.AddSingleton(TypeAdapterConfig.GlobalSettings);
services.AddScoped<IMapper, ServiceMapper>();

// EF Core projection (strong suit)
var mappedList = dbContext.Orders
    .ProjectToType<OrderDto>()   // Mapster projection
    .ToList();

NuGet Packages:

• https://www.nuget.org/packages/Mapster
• https://www.nuget.org/packages/Mapster.DependencyInjection
• https://www.nuget.org/packages/Mapster.SourceGenerator (for performance improvement)

AgileMapper Example (Free, Apache-2.0)

var mapper = Mapper.CreateNew(cfg =>
{
    cfg.WhenMapping
       .From<Order>()
       .To<OrderDto>()
       .Map(ctx => ctx.Source.Customer.Name).To(dto => dto.CustomerName)
       .Map(ctx => ctx.Source.Lines.Sum(l => l.Quantity)).To(dto => dto.ItemCount)
       .Map(ctx => ctx.Source.Lines.Sum(l => l.Quantity * l.UnitPrice)).To(dto => dto.Total)
       .Map(ctx => ctx.Source.CreatedAt.ToString("O")).To(dto => dto.CreatedAtIso);
});

var mappedDto = mapper.Map(order).ToANew<OrderDto>();

NuGet Packages:

• https://www.nuget.org/packages/AgileObjects.AgileMapper

Manual (Pure) Mapping (no library)

Straightforward, fastest, and most explicit. Good for simple applications which doesn't need long term maintenance. Hand-written mapping is faster, safer, and more maintainable. And for tiny mappings, you can still use manual mapping.

• Examples of when manual mapping is better than libraries.

public static class OrderMapping
{
    public static OrderDto ToDto(this Order s) => new()
    {
        Id = s.Id,
        CustomerName = s.Customer.Name,
        ItemCount = s.Lines.Sum(l => l.Quantity),
        Total = s.Lines.Sum(l => l.Quantity * l.UnitPrice),
        CreatedAtIso = s.CreatedAt.ToString("O")
    };
}

// usage
var dto = order.ToDto();

// EF Core projection (best for perf + SQL translation)
var mappedList = dbContext.Orders.Select(s => new OrderDto
    {
        Id = s.Id,
        CustomerName = s.Customer.Name,
        ItemCount = s.Lines.Sum(l => l.Quantity),
        Total = s.Lines.Sum(l => l.Quantity * l.UnitPrice),
        CreatedAtIso = s.CreatedAt.ToString("O")
    }).ToList();

Conclusion

If you rely on AutoMapper today, it’s time to evaluate alternatives. For ABP Framework, we chose Mapperly due to active development, strong community, and compile-time performance. But your team may prefer Mapster for flexibility or even manual mapping for small apps. Your requirements might be different, your project is not a framework so you decide the best one for you.

In this article I'll show you how to optimize your ABP website localization with a URL parameter. URL Paths are commonly being used to change the current UI culture. This method makes our website SEO-Friendly as you structuring the URLs for multiple languages. And you can also share the link of your website with a specific language. Let's see implementing multi-language support with URL parameters in an ABP project.

Mastering Website Localization: Language Codes in URLs Explained

Enhancing UX with URL-Based website localization is mainly done with ASP.NET Core's routing system. Also we need to automatically redirect the links without language code parameter. Our URL structures for the localization will be as following:

• https://mywebsite.com/en/dashboard (English)
• https://mywebsite.com/tr/dashboard (Turkish)

Routing

Before starting to explain how to do this, you can see this commit which implements this functionality. The routing module consists of these fundamental classes:

1. MultiLanguageSupportMetaData.cs

This class is used to add a language parameter to route templates. For example, it changes the /about route to /language/about.

2. MultiLanguageRedirectRequiredMetaData.cs

This class is used to redirect users to the correct language version. If a user visits the /about page and the current culture is "tr-TR", this class will redirect them to /tr-TR/about.

3. UrlNormalizer.cs

This static class is used to normalize URLs by adding language information and improving performance using caching.

public static string NormalizeUrl(EndpointDataSource endpointDataSource, HttpContext httpContext, string url)
{
    // Normalize the URL and cache it
    return Cache.GetOrAdd(url, (key) =>
    {
        var absoluteUrl = GetAbsoluteUrl(key);
        var multiLanguageRedirectRequiredMetaData =
            GetMultiLanguageRedirectRequiredMetaData(endpointDataSource, absoluteUrl);
        return multiLanguageRedirectRequiredMetaData?.ReBuildUrl(httpContext, key) ?? key;
    });
}

4. MyLinkGenerator.cs

This class extends ASP.NET Core’s LinkGenerator class to automatically add language information to all generated links.

5. MyRouteDataRequestCultureProvider.cs

This class determines the current culture using the language parameter in the URL. For example, it extracts the "tr-TR" culture from the /tr-TR/about URL.

6. RoutingMiddleware.cs

This middleware processes HTTP requests and redirects users to the correct language version when necessary.

public override Task InvokeAsync(HttpContext context, RequestDelegate next)
{
    var endpoint = context.GetEndpoint();
    if(endpoint is not RouteEndpoint)
    {
        return next(context);
    }
    
    // Redirect if necessary
    var redirectMetaData = endpoint.Metadata.GetMetadata<IRedirectMetaData>();
    if (redirectMetaData is not null)
    {
        redirectMetaData.Redirect(context);
        return Task.CompletedTask;
    }

    // ...
}

CultureAnchorTagHelper.cs

This Tag Helper processes <a> tags in a Razor page and automatically adds language information to URLs if it's missing.

[HtmlTargetElement("a", Attributes = "href", TagStructure = TagStructure.NormalOrSelfClosing)]
public class CultureAnchorTagHelper(EndpointDataSource endpointDataSource, IHttpContextAccessor contextAccessor)
    : TagHelper, ITransientDependency
{
    public override void Process(TagHelperContext context, TagHelperOutput output)
    {
        var href = output.Attributes["href"].Value.ToString();
        if (href != null)
        {
            output.Attributes.SetAttribute("href",
                UrlNormalizer.NormalizeUrl(endpointDataSource, contextAccessor.HttpContext!, href));
        }
    }
}

How This Tag Helper Works:

• Finds all <a href="..."> tags within your Razor pages.
• Retrieves the href attribute of each link.
• Uses the UrlNormalizer.NormalizeUrl() method to normalize the URL with the current culture information.
• Replaces the original URL with the normalized one.

For example, if the current culture is "tr" and a page contains <a href="/about">, this Tag Helper will transform it into <a href="/tr-TR/about">.

Sample Project

Salih Özkara from ABP team created a sample working project which implements URL localization. He used ABP free tier MVC template and MongoDB. You can check out the related commit which implements URL localization:

https://github.com/salihozkara/MultiLangRoute/commit/09e40cfd751562dec0dab890e54e0c5ca9ee256c

And full working demo is available at:

https://github.com/salihozkara/MultiLangRoute

You can download the demo project at:

UrlLocalizationSampleProject.zip

Summary

This implementation extends ASP.NET Core’s routing mechanism and utilizes caching for improved performance. It ensures multilingual support by normalizing URLs, redirecting users to the appropriate language version, and automatically handling language-specific links.

Step 1: Remove the Existing Localization Middleware

Open your web project's module class file—this is typically in BookStoreModule.cs if you’re using the no-layer template. Or if your project is multi-layered, it's BookStoreWebModule.cs. Find the below line and remove it:

app.UseAbpRequestLocalization();

The reason is that the localization middleware depends on the database, which does not yet exist! We'll add this middleware conditionally in the next step.

Step 2: Conditionally Use the Localization Middleware

We only want AbpRequestLocalizationMiddleware for routes other than our new migration endpoint (/api/migrate). To achieve this, we use Middleware Branching. Our new controller will work on /api/migrate endpoint, so let's add a condition for this specific URL.

app.UseWhen(httpContext =>
    !httpContext.Request.Path.StartsWithSegments("/api/migrate", StringComparison.OrdinalIgnoreCase),
    appBuilder =>
    {
        appBuilder.UseAbpRequestLocalization();
    }
);

This ensures all requests except /api/migrate will still use AbpRequestLocalization middleware.

Step 3: Create the Migration Controller

Create a new file named MigrationController.cs under your Controllers folder or wherever you store controllers. Then copy-paste the following class:

using Microsoft.AspNetCore.Mvc;
using Volo.Abp.AspNetCore.Mvc;
using Volo.Abp.Data;
using Volo.Abp.Identity;
using Volo.Abp.MultiTenancy;
using Volo.Saas.Tenants;

namespace Acme.BookStore.Web.Controllers //TODO: you may need to fix this namespace!
{
    [Route("api")]
    [IgnoreAntiforgeryToken]
    public class MigrationController : AbpController
    {
        private const string DefaultAdminEmail = "admin@admin.com";
        private const string DefaultAdminPassword = "My-Admin-Password";

        private readonly IDataSeeder _dataSeeder;
        private readonly ITenantRepository _tenantRepository;
        private readonly ICurrentTenant _currentTenant;
        private readonly IEnumerable<DbSchemaMigrator> _dbSchemaMigrators;

        public MigrationController(
            IDataSeeder dataSeeder,
            ITenantRepository tenantRepository,
            ICurrentTenant currentTenant,
            IEnumerable<DbSchemaMigrator> dbSchemaMigrators)
        {
            _dataSeeder = dataSeeder;
            _tenantRepository = tenantRepository;
            _currentTenant = currentTenant;
            _dbSchemaMigrators = dbSchemaMigrators;
        }

        [HttpGet]
        [Route("migrate")]
        public async Task<IActionResult> MigrateAsync(CancellationToken cancellationToken)
        {
            try
            {
                Logger.LogInformation("Started database migrations...");

                await MigrateDatabaseSchemaAsync();
                await SeedDataAsync();

                Logger.LogInformation("Successfully completed host database migrations. Started migrating tenant databases...");

                if (_currentTenant.IsAvailable) // or check MultiTenancyConsts.IsEnabled
                {
                    await MigrateTenantDatabases(cancellationToken);
                }

                Logger.LogInformation("Successfully completed all database migrations.");
                return Ok("Migration and seed completed successfully.");
            }
            catch (Exception ex)
            {
                return BadRequest($"An error occurred during migration: {ex.Message}");
            }
        }

        private async Task MigrateTenantDatabases(CancellationToken cancellationToken)
        {
            var tenants = await _tenantRepository.GetListAsync(includeDetails: true, cancellationToken: cancellationToken);

            var migratedDatabaseSchemas = new HashSet<string>();
            foreach (var tenant in tenants)
            {
                using (_currentTenant.Change(tenant.Id))
                {
                    if (tenant.ConnectionStrings.Any())
                    {
                        var tenantConnectionStrings = tenant.ConnectionStrings
                            .Select(x => x.Value)
                            .ToList();

                        if (!migratedDatabaseSchemas.IsSupersetOf(tenantConnectionStrings))
                        {
                            await MigrateDatabaseSchemaAsync(tenant);
                            migratedDatabaseSchemas.AddIfNotContains(tenantConnectionStrings);
                        }
                    }

                    await SeedDataAsync(tenant);
                }

                Logger.LogInformation($"Successfully completed {tenant.Name} tenant database migrations.");
            }
        }

        private async Task MigrateDatabaseSchemaAsync(Tenant tenant = null)
        {
            Logger.LogInformation($"Migrating schema for {(tenant == null ? "host" : tenant.Name + " tenant")} database...");
            foreach (var migrator in _dbSchemaMigrators)
            {
                await migrator.MigrateAsync();
            }
        }

        private async Task SeedDataAsync(Tenant tenant = null)
        {
            Logger.LogInformation($"Executing {(tenant == null ? "host" : tenant.Name + " tenant")} database seed...");

            await _dataSeeder.SeedAsync(
                new DataSeedContext(tenant?.Id)
                    .WithProperty(IdentityDataSeedContributor.AdminEmailPropertyName, DefaultAdminEmail)
                    .WithProperty(IdentityDataSeedContributor.AdminPasswordPropertyName, DefaultAdminPassword)
            );
        }
    }
}

Step 4: Navigate to the Migration URL

Build and run your web application. Then visit:

https://your-website.com/api/migrate

If your database did not exist, it will be created, and the default data will be seeded. If you enabled multi-tenancy, the tenant databases will also be migrated in this solution.

That’s all there is to it! By adding a simple controller and selectively applying the localization middleware, you can migrate your ABP app’s database with a single URL.

Happy coding 😊

In the ABP Framework, Background Jobs and Background Workers serve different purposes but can sometimes seem interchangeable. Sometimes it can be confusing. Let’s clarify their differences, and I'll show you some real-world cases to help you understand how to decide between these two. We have official documents for these:

📕 Background Workers ABP Document https://abp.io/docs/latest/framework/infrastructure/background-workers

📘 Background Jobs ABP Document https://abp.io/docs/latest/framework/infrastructure/background-jobs

I posted this article because recently, I came across this support ticket on the ABP support website. I thought these terms could be confusing for devs. He has two tasks and is asking whether he needs to use Background Worker or Background Job.

• The first one is FileRecievedActivity. He says it's running 2 times a day. So, it's a recurring activity that needs to run in the background. So FileRecievedActivity is a "Background Worker".
• The second one is ProcessQueueFiles. It sounds like a polling task. It runs whenever a new file comes to the directory. So, it's also a recurring task that needs to be scheduled every 1 minute. Hence the ProcessQueueFiles is also "Backgrounder Worker."

Background Workers 🔄 /Looping/

The background workers are stateless and runs in-memory as long as the application is up and ready.

• Purpose: Long-running, periodic tasks that run continuously in the background. They are queued and executed asynchronously.
• Lifetime: Runs throughout the application's lifetime.
• Scheduling: Executes on a fixed schedule, like every X minutes / hours...
• Infrastructure: ABP uses an in-memory implementation for running background workers. You can also use the 3rd party tools for running your background worker:
  • Quartz + ABP integration
  • Hangfire + ABP integration

Use Cases: Use background workers for any task that needs to run repeatedly at fixed intervals. For example "Health checks", "Periodic cleanup tasks", "Monitoring tasks", "Processing daily data"... In the last section, you will find real-world examples.

In Microsoft Docs, this topic is called "Background Tasks". Check out Microsoft's official doc for running background tasks.

Background Jobs ▶ /One time/

• Purpose: One-time tasks that need to be queued and can be executed in the background. Here the main goal is not to block the application to run the task.

• Lifetime: Executes one time and completes.

• Scheduling: Can be delayed/scheduled for a specific time.

• Infrastructure: ABP uses in-memory implementation but you can also use the below 3rd party tools:

  • Hangfire + ABP implementation

  • RabbitMQ + ABP implementation

  • Quartz + ABP implementation

Use Cases: Use background jobs to send emails, process uploaded files, generating reports, any fire-and-forget tasks or tasks that need retry mechanisms.

In Microsoft docs this topic is called as "Background Tasks". Check out Microsoft's official background jobs doc.

When to Use Which?

Use Background Workers when:

• You need continuous, recurring execution

• The task should run as long as the application is running

• You don't need persistence in task state

• You want in-memory, efficient execution

Use Background Jobs when:

• You need one-time execution

• The task should survive application restarts

• You need guaranteed execution

• You want built-in retry mechanisms

• You need to queue multiple instances of the same task

Technical Differences

// A Background Worker Example
public class MyBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{
    public MyBackgroundWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory) 
        : base(timer, serviceScopeFactory)
    {
        Timer.Period = 5000; // Runs every 5 seconds
    }
}

// A Background Job Example
public class MyBackgroundJob : AsyncBackgroundJob<MyArgs>
{
    public override async Task ExecuteAsync(MyArgs args)
    {
        // Executes once when triggered
    }
}

// Triggering a Background Job
await _backgroundJobManager.EnqueueAsync(
    new MyArgs { /* ... */ },
    delay: TimeSpan.FromHours(2)
);

While background workers no additional infrastructure needed, background jobs requires a database to persist jobs (or a distributed cache/message broker depending on the implementation)

🚩 Background Worker Examples

1) Querying an external API

• Scenario: Continuously fetch data from an external API at regular intervals.
• Why a Background Worker?: You need a long-running process to poll the API and handle the results.

public class ApiPollingWorker : AsyncPeriodicBackgroundWorkerBase
{
    private readonly IAmazonPriceService _apiService;

    public ApiPollingWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory, IAmazonPriceService apiService)
        : base(timer, serviceScopeFactory)
    {
        _apiService = apiService;
        Timer.Period = 60000; // Run every 1 minute
    }

    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
    {
        var data = await _apiService.FetchPricesAsync();
        // Process the data
    }
}

Here are practical examples of Background Workers that demonstrate how to use them effectively within the ABP Framework. Background Workers are ideal for long-running or periodic tasks that require stateful or persistent execution.

2) Polling an External API

• Scenario: Continuously fetch data from an external API at regular intervals.
• Why a Background Worker?: You need a long-running process to poll the API and handle the results.

csharpCopy codepublic class ApiPollingWorker : AsyncPeriodicBackgroundWorkerBase
{
    private readonly IApiService _apiService;

    public ApiPollingWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory, IApiService apiService)
        : base(timer, serviceScopeFactory)
    {
        _apiService = apiService;
        Timer.Period = 60000; // Run every 1 minute
    }

    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
    {
        var data = await _apiService.FetchDataAsync();
        // Process the data
    }
}

3) Processing a Queue

• Scenario: Continuously process items from a queue, such as Azure Service Bus or RabbitMQ.
• Why a Background Worker?: This requires a stateful, persistent process to monitor and handle the queue.

public class QueueProcessingWorker : AsyncBackgroundWorker
{
    private readonly IQueueService _queueService;

    public QueueProcessingWorker(IServiceScopeFactory serviceScopeFactory, IQueueService queueService)
        : base(serviceScopeFactory)
    {
        _queueService = queueService;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var message = await _queueService.GetNextMessageAsync();
            if (message != null)
            {
                await _queueService.ProcessMessageAsync(message);
            }
            await Task.Delay(1000, stoppingToken); // Delay for throttling
        }
    }
}

4) Maintaining a Database

• Scenario: Perform periodic database maintenance, rebuild indices or cleanup tasks.
• Why a Background Worker?: These are recurring tasks requiring regular execution.

public class DatabaseCleanupWorker : AsyncPeriodicBackgroundWorkerBase
{
    private readonly ICleanupService _cleanupService;

    public DatabaseCleanupWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory, ICleanupService cleanupService)
        : base(timer, serviceScopeFactory)
    {
        _cleanupService = cleanupService;
        Timer.Period = 3600000; // Run every hour
    }

    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
    {
        await _cleanupService.DeleteOldRecordsAsync();
    }
}

5) Running a Health Check Service

• Scenario: Periodically check the health of connected services and log their status.
• Why a Background Worker?: Periodic health checks are naturally suited to background workers.

public class HealthCheckWorker : AsyncPeriodicBackgroundWorkerBase
{
    private readonly IHealthCheckService _healthCheckService;

    public HealthCheckWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory, IHealthCheckService healthCheckService)
        : base(timer, serviceScopeFactory)
    {
        _healthCheckService = healthCheckService;
        Timer.Period = 60000; // Run every minute
    }

    protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
    {
        await _healthCheckService.PerformChecksAsync();
    }
}

🚩 Background Job Examples

1) Email Notifications

• Scenario: Sending a welcome email to new users.
• Why a Background Job?: The email sending process doesn’t need to block the main application thread. It can run in the background, and failed jobs can be retried.

public class SendWelcomeEmailJob : IBackgroundJob<string>
{
    private readonly IEmailSender _emailSender;

    public SendWelcomeEmailJob(IEmailSender emailSender)
    {
        _emailSender = emailSender;
    }

    public async Task ExecuteAsync(string emailAddress)
    {
        await _emailSender.SendAsync(
            emailAddress,
            "Welcome!",
            "Thank you for signing up to our service."
        );
    }
}

2) Data Import/Export

• Scenario: Exporting a large dataset to a CSV file and notifying the user once complete.
• Why a Background Job?: Long-running tasks like file generation can be processed asynchronously.

public class ExportDataJob : IBackgroundJob<int>
{
    private readonly IDataExporter _dataExporter;
    private readonly INotificationService _notificationService;

    public ExportDataJob(IDataExporter dataExporter, INotificationService notificationService)
    {
        _dataExporter = dataExporter;
        _notificationService = notificationService;
    }

    public async Task ExecuteAsync(int userId)
    {
        var filePath = await _dataExporter.ExportAsync(userId);
        await _notificationService.NotifyAsync(userId, "Your data export is complete: " + filePath);
    }
}

3) Push Notifications

• Scenario: Sending push notifications to users about specific events (e.g., “Your order has been shipped!”).
• Why a Background Job?: Push notifications are non-blocking and can be handled in bulk in the background.

public class SendPushNotificationJob : IBackgroundJob<PushNotificationInput>
{
    private readonly IPushNotificationService _pushNotificationService;

    public SendPushNotificationJob(IPushNotificationService pushNotificationService)
    {
        _pushNotificationService = pushNotificationService;
    }

    public async Task ExecuteAsync(PushNotificationInput input)
    {
        await _pushNotificationService.SendAsync(input.UserId, input.Message);
    }
}

4) File Upload Processing

• Scenario: Processing a file uploaded by a user (e.g., parsing, validating, and saving to a database).
• Why a Background Job?: File processing can be offloaded to the background, ensuring quick user feedback.

public class ProcessFileUploadJob : IBackgroundJob<FileProcessingInput>
{
    private readonly IFileParser _fileParser;
    private readonly IDataService _dataService;

    public ProcessFileUploadJob(IFileParser fileParser, IDataService dataService)
    {
        _fileParser = fileParser;
        _dataService = dataService;
    }

    public async Task ExecuteAsync(FileProcessingInput input)
    {
        var parsedData = await _fileParser.ParseAsync(input.FilePath);
        await _dataService.SaveAsync(parsedData);
    }
}

Final Words

Use Background Workers for stateful, continuous operations and Background Jobs for isolated, retriable units of work.

I hope this article will clarify these terms in ABP Framework.

https://abp.io/ a complete web application platform.

Happy coding😊

What’s Swagger UI?

Swagger UI is an open-source tool that automatically generates an interactive, web-based documentation interface for WebAPIs. It supports OpenAPI standards. It was very popular tool among the ASP.NET Core developers from 2020 to 2024. Because it was a built-in tool comes with ASP.NET Core default templates. We liked this tool because it was the first tool that allows us to make WebAPI calls for testing. Now it provides paid services as well as free ones.

Previously, Swagger was included by default from .NET 5 to .NET 8 in .NET web templates.

What’s OpenAPI?

OpenAPI is a standard specification for defining REST APIs. The official website is https://www.openapis.org/. Microsoft is now using OpenAPI and here is the official documentation 👉 https://aka.ms/aspnet/openapi

Replacement of Swagger UI with OpenAPI

Swagger UI is no longer integrated into NET 9, as Microsoft wants a solution with first-class support, better control, and enhanced security. As you see in the below screenshot, Microsoft declares that it's already removed.

Why is Swagger Removed from .NET 9?

In March 2024, the ASP.NET Core team announced that they are removing the Swashbuckle.AspNetCore dependency from web templates from .NET 9 release.

This decision was influenced by the project's lack of active maintenance and the absence of an official release for .NET 8.

Microsoft team created a new package Microsoft.AspNetCore.OpenApi. It provides built-in OpenAPI document generation just like Swagger. So Microsoft doesn't depend on external tools. Because in every .NET release, they need to ask the owners of the external tool libraries to align with their new version. And sometimes these library owners cannot update their code-base according to the recent .NET changes. And it is becoming harder for Microsoft to support the 3rd party libraries under these circumstances. Basically reducing 3rd party dependencies will help Microsoft fast release cycles.

I read Reddit, GitHub discussions and YouTube reviews about this topic. As I see community members expressed concerns about the inactivity of Swashbuckle and they are discussing alternatives like contributing to or forking the project. The Microsoft team also contacted the owners of Swashbuckle and NSwag to explore potential collaborations and ensure a smooth transition for developers.

In the below GitHub issue, you can see the details of this decision:

• github.com/dotnet/aspnetcore/issues/54599

Jeremy -Product Manager- at Microsoft, answers why they took this decision in this post.

As a summary;

The change is due to a lack of maintenance of the Swagger library, although it has seen some recent updates. This aims to reduce dependency on external tools and provide a streamlined, out-of-the-box experience for generating OpenAPI documentation for ASP.NET Core Web APIs.

What are the Benefits of the New OpenAI Package?

Native Support and Reduced Dependency

The new Microsoft.AspNetCore.OpenApi package provides first-class citizen support for OpenAPI. It reduces reliance on external tools like Swashbuckle or NSwag for basic documentation needs. The native implementation leverages source generators to reduce runtime overhead.

Simplified Configuration

No need extra setup or 3rd party integrations. Just by defining controllers and endpoints, ASP.NET Core automatically generates OpenAPI specifications.

Well Integration with Minimal APIs

Minimal APIs introduced in .NET 6. There's an optimized built-in support for Minimal APIs. It automatically adds metadata for routes, request parameters, and responses.

Compatibility with Existing Tools

You can still use the output of OpenAPI with Swagger or NSwag... So it doesn't mean that in this case you have only one option when you use OpenAPI.

How to Use the New OpenAPI in .NET9?

When you create a new ASP.NET Core project, you can see the below checkbox to add OpenAPI.

I created a new .NET 9 web project, I saw that OpenAPI had already been added.

Add OpenAPI Support For Your Existing Project

Upgrade your project to .NET 9 and add the required NuGet package Microsoft.AspNetCore.OpenApi

dotnet add package Microsoft.AspNetCore.OpenApi

Add the following services and middleware in Program.cs

var builder = WebApplication.CreateBuilder();
builder.Services.AddOpenApi(); //<<-----
var app = builder.Build();
app.MapOpenApi(); //<<-----
app.MapGet("/", () => "Test");
app.Run();

Your OpenAPI document URL is https://localhost:7077/openapi/v1.json

Change the port to your active port. This is how it looks like:

Alternative 3rd Party Tool: Scalar

Scalar is an open-source API platform for RestAPI documentation. Also, it provides an interface for interacting with RESTful API. Generates interactive and user-friendly API documentation. Supports OpenAPI and Swagger specifications. It’s open-source with 7K stars on GitHub.

See the repo 👉 https://github.com/scalar/scalar.

That's all from the replacement of Swagger in .NET 9. Happy coding 👨‍💻

References

• https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-9.0?view=aspnetcore-8.0#openapi

.NET 9.0.100-rc.2 has been released on October 8, 2024. To align with the latest .NET, we also released the ABP Platform 9.0.0-rc.1 version. With this release, ABP now supports .NET 9.

The .NET 9 stable version is planned to be released on November 12, 2024 before the .NET Conf 2024 event. The ABP 9.0 stable version is planned to be released on November 19, 2024.

• Download the .NET 9 runtime and SDK from the following link:

  https://dotnet.microsoft.com/en-us/download/dotnet/9.0

• There are many enhancements and bug fixes with ABP 9.0. Read the ABP 9 announcement:

  https://abp.io/blog/announcing-abp-9-0-release-candidate

• Read our migration ABP 9.0 migration guide from the following link:

  abp.io/docs/9.0/release-info/migration-guides/abp-9-0

• The following is the PR is for the .NET 9 upgrade in the ABP source code:

  https://github.com/abpframework/abp/pull/20803

.NET 9 Releases

In the following link, you can find a list of all .NET 9 releases with direct links to release notes and announcements/discussions:

• https://github.com/dotnet/core/discussions/9234

ABP Supports Both .NET 8 & .NET 9

The ABP 9.0 version fully supports .NET 9 within our new templates and modules. For developers who want to update their ABP packages to the latest but want to keep them in .NET 8, we support both .NET 8 and .NET 9 in ABP 9. In your host application, you can choose your target framework.

So you can decide which version you want to use in your startup Host Application’s <TargetFramework> tag.

In this link you can see that netstandard2.0/2.1 and net8/9 are supported.

<Project Sdk="Microsoft.NET.Sdk">
    <TargetFrameworks>
      netstandard2.0;netstandard2.1;net8.0;net9.0
    </TargetFrameworks>
</Project>

New ASP.NET Core Middleware: Static Asset Delivery

MapStaticAssets is a new middleware that helps optimize the delivery of static assets in any ASP.NET Core app, including Blazor apps. With this change, some JavaScript/CSS/Images files exist in the Virtual File System, but the new ASP.NET Core 9 MapStaticAssets can't handle them. You need to add StaticFileMiddleware to serve these files. In ABP 9, we added MapAbpStaticAssetsan extension method to support the new MapStaticAssets. You can read about this new feature at this link. ABP’s new extension method is available here.

How to Upgrade from .NET 8 to .NET 9:

Install the latest .NET 9 SDK from this link. Upgrade dotnet-ef tool version with the following command:

dotnet tool uninstall --global dotnet-ef && dotnet tool install --global dotnet-ef

1. Change all TargetFramework tags from net8.0 to net9.0.
2. Upgrade all Microsoft NuGet packages to 9.0.0.
3. If you have global.json, update dotnetversion to 9.0.0 .
4. Replaceapp.UseStaticFiles() to app.MapAbpStaticAssets() in your module classes and startup projects. See the related changes in the repository.

What’s new with .NET 9

.NET 9 Blazor New Features

• https://abp.io/community/articles/asp.net-core-blazor-9.0-new-features-summary--x0fovych

.NET 9 Performance Improvements Summary

• https://abp.io/community/articles/.net-9-performance-improvements-summary-gmww3gl8

What’s new in .NET 9 (Microsoft’s post)

• https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-9/overview

We Are Eating Our Own Dog Food

Before we release any version of ABP, we test our upcoming version on our sample apps and live website https://abp.io. The ABP.io website is also built on top of the ABP Framework, and you can see that we have already started to use .NET 9-rc.2 on our live website.

Microsoft .NET Support Policy

Lastly, I want to mention Microsoft's .NET support policy.

• .NET 7 support has been finished on May 2024.
• .NET 8 will be supported until November 2026.
• .NET 9 is on the standard term support, which means Microsoft will release patches until May 2026.

Find detailed information about the .NET support policy at this link.

Finally

.NET 9 is making a significant impact. It introduces features like Native AOT for faster applications, enhanced AI integration and improved tools for cloud-native and cross-platform development, all aimed at simplifying developers’ work. Whether you’re handling small projects or large-scale enterprise applications, it offers enhancements that elevate your productivity by just upgrading your .NET version to 9.0

Cookies vs Local Storage

When you want to save client-side data on browsers, you can use Cookies or Local Storage of the browser. While these methods look similar, they have different behaviors. You need to decide based on the specific use-case, security concerns and the data size being stored. I'll clarify the differences between these methods.

When to use Cookies 🍪?

1. Server Communication (e.g: Authentication Tokens): Cookies are ideal when you need to send data automatically with HTTP requests to the server, such as authentication tokens (JWTs) or session IDs. Cookies can be configured to be sent only to specific domains or paths, making them useful for session management.
2. Cross-Domain Communication: Cookies can be shared across subdomains, which is useful when working with multiple subdomains under the same parent domain for microservice architecture.
3. Expiration Control: Cookies come with built-in expiration times. You don’t need to manually remove them after a certain period that should expire.
4. Security: Cookies can be marked as HttpOnly which makes them accessible only via the server, not via JavaScript! Also, when you set a cookie attribute, Secure it can be sent only over HTTPS, which forces enhanced security for sensitive data.

Considerations for Cookies

• Size Limitation: Cookies are generally limited to around 4KB of data.
• Security Risks: Cookies are susceptible to cross-site scripting (XSS) attacks unless marked HttpOnly.

When to use Local Storage🗄️?

1. Client-Side Data Storage: Local storage is ideal for storing large amounts of data (up to 5–10 MB) that doesn’t need to be sent to the server with every request. For example; user preferences, settings, or cached data.
2. Persistence: Data in local storage persists even after the browser is restarted. This behavior makes it useful for long-term storage needs.
3. No Automatic Server Transmission: Local storage data is never automatically sent to the server, which can be a security advantage if you don’t want certain data to be exposed to the server or included in the requests.

Considerations for Local Storage

• Security Risks: Local storage is accessible via JavaScript, making it vulnerable to XSS attacks. Sensitive data should not be stored in local storage unless adequately encrypted.

• No Expiration Mechanism: Local storage does not have a built-in expiration mechanism. You must manually remove the data when it’s no longer needed.

Summary

Use Cookies

• For data that needs to be sent to the server with HTTP requests, particularly for session management or authentication purposes.

Use Local Storage

• For storing large amounts of client-side data that doesn’t need to be automatically sent to the server and for data that should persist across browser sessions.

In many cases, you might use both cookies and local storage, depending on the specific requirements of different parts of your application. There are also other places where you can store the client-side data. You can check out this article for more information.

Happy coding 🧑🏽‍💻

With every release, .NET becomes faster & faster! You get these improvements for free by just updating your project to the latest .NET!

It’s very interesting that 20% of these improvements are implemented by open-source volunteers rather than Microsoft employees. These improvements mostly focus on cloud-native and high-throughput applications. I’ll briefly list them below.

1. Dynamic PGO with JIT Compiler

• What is dynamic PGO?

  With “Profile Guided Optimization” the compiler optimizes the code, based on the flow and the way the code executes. It is predicated on the idea that every potential behavior of the code will always transpire.

• What’s Improved?

  The tiered compilation, inlining, and dynamic PGO are three ways that .NET 9 optimizes the JIT compiler. This enhances runtime performance and speeds up the time for apps to launch.

• Performance Gains

  CPU use is lower during execution; therefore, startup times are about 15% faster.

• As a Developer

  Faster, smoother deployments with reduced warm-up times... These enhancements reduce latency for applications with complex workflows, particularly in microservices and high-throughput environments.

• How to activate Dynamic PGO?

  Add the following to your csproj file, or if you have several csproj files, you can add it once in Directory.Build.props file. Check out this link to understand PGO.

  <PropertyGroup>
    <TieredPGO>true</TieredPGO>
  </PropertyGroup>

2. Library Improvements

• What’s Improved?

  LINQ and JSON serialization, collections and libraries are significantly improved with .NET 9.

• Performance Gains

  JSON serialization performance increases by about 35%. This helps with heavy data parsing and API requests. Less memory is allocated to Span operations as well, and LINQ techniques such as Where and Select are now faster.

• As a Developer

  This means that apps will be faster, especially those that handle data primarily in JSON or manipulate data with LINQ.

3. ASP.NET Core

• What’s Improved?

  Kestrel server has undergone significant modifications, mostly in processing the HTTP/2 and HTTP/3 protocols.

• Performance Gains

  Now, Kestrel handles requests up to 20% faster and has a 25% reduction in average latency. Improved connection management and SSL processing also result in overall efficiency gains.

• As a Developer

  These modifications result in less resource use, quicker response times for web applications, and more seamless scaling in high-traffic situations.

4. Garbage Collection & Memory Management

• What’s Improved?

  NET 9’s garbage collection (GC) is more effective, especially for apps with high allocation rates.

• Performance Gains

  Applications experience smoother garbage collection cycles with 8–12% less memory overhead, which lowers latency and delays.

• As a Developer

  The performance will be more reliable and predictable for developers as there will be fewer memory-related bottlenecks, particularly in applications that involve frequent object allocations.

5. Native AOT Compilation

• What’s Improved?

  Native AOT (Ahead-of-Time) compilation is now more efficient by lowering memory footprint and cold-start times. This leads to better support for cloud-native applications.

• Performance Gains

  Native AOT apps now have faster cold launches and use 30–40% less memory. This improvement focuses on containerized applications.

References:

• Microsoft .NET blog post.
• What’s new in the .NET 9 runtime?

In this article, I’ll highlight the latest .NET 9 SignalR updates for ASP.NET Core 9.0.

SignalR Hub Accepts Base Classes

SignalR Hub class can now get a base class of a polymorphic class. As you see in the example below, I can send Animal to Process method. Before .NET 9, we could only pass the derived classes: Cat and Dog.

/*** My Base Class is Animal ***/
[JsonPolymorphic]
[JsonDerivedType(typeof(Cat), nameof(Cat))]
[JsonDerivedType(typeof(Dog), nameof(Dog))]
private class Animal
{
    public string Name { get; set; }
}

/*** CAT derived from Animal ***/
private class Cat : Animal
{
    public CatTypes CatType  { get; set; }
}

/*** DOG derived from Animal ***/
private class Dog : Animal
{
    public DogTypes DogType { get; set; }
}


public class MyHub : Hub
{
    /*** We can use the base type Animal here  ***/
    public void Process(Animal animal)
    {
        if (animal is Cat) { ... }
        else if (animal is Dog) { ... }
    }
}

Better Diagnostics and Telemetry

Microsoft focuses mainly on .NET Aspire nowadays. That’s why SignalR now integrates more deeply with the .NET Activity API, which is commonly used for distributed tracing. The enhancement is implemented for better monitoring in .NET Aspire Dashboard. To support this feature:

1- Add these packages to yourcsproj:

<PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.9.0" />
<PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.9.0" />
<PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.9.0" />

2- Add the following startup code to your host project:

builder.Services.AddSignalR();
/* After AddSignalR use AddOpenTelemetry() */
builder
    .Services
    .AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        if (builder.Environment.IsDevelopment())
        {         
            tracing.SetSampler(new AlwaysOnSampler()); //for dev env monitor all traces
        }

        tracing.AddAspNetCoreInstrumentation();
        tracing.AddSource("Microsoft.AspNetCore.SignalR.Server");
    });

builder.Services.ConfigureOpenTelemetryTracerProvider(tracing => tracing.AddOtlpExporter());

Finally, you’ll see the SignalR Hub events on the Aspire Dashboard:

Trimming and Native AOT Support

With .NET 9, trimming and native Ahead Of Time compilation are supported. This will improve our application performance. To support AOT, your SignalR object serialization needs to be JSON, and you must use the System.Text.Json source generator. Also on the server side, you shouldn't use IAsyncEnumerable<T> and ChannelReader<T> where T is a ValueType (struct) for Hub method arguments. One more limitation; Strongly typed hubs aren't supported with Native AOT (PublishAot). And you should use only Task, Task<T>, ValueTask, ValueTask<T> for async return types.

That's all the new features coming to SignalR in .NET 9! Happy coding 🧑🏽‍💻

In this article, I will mention the differences between Promise and Observable . They are used in TypeScript (Angular) for handling async operations but have different use cases and behaviors. Let's see these six differences...

1. Eager or Lazy Evaluation

• Promise: A promise is eager! This means that as soon as a promise is created, it executes the operation, like initiating immediately an HTTP request. You can't control the execution start time; it begins right away!

• Observable: An observable is a lazy operation! It doesn't start executing until you subscribe to it. This allows you to define an observable without triggering the actual operation until it's needed.

2. Handling Value Count

• Promise: A promise is designed to handle a single async value. Once the operation completes, it either resolves with a value or rejects with an error, and that's it! You can't emit multiple values with a single promise.

• Observable: An observable can emit multiple values over time. It can have several values, and it can continue to do so until it either completes or errors out. So observable is ideal for event streams or data streams.

3. Cancellablity

• Promise: Once a promise is created and the operation has started**, you cannot cancel it!** The promise will resolve or reject eventually, and there's no way to stop it from being executed.

• Observable: An observable can be canceled. If you unsubscribe from an observable, it stops emitting values and can clean up any resources like canceling an ongoing HTTP request. This makes observable more flexible in scenarios where you need to abort an operation.

4. Chaining and Composition

• Promise: It supports chaining using .then() for handling the result and .catch() for handling errors. This is straightforward but can become complex for more advanced scenarios.

• Observable: It supports powerful operators like map, filter, merge, switchMap. This allows for complex composition and transformation of data streams and makes it suitable for handling complex async scenarios.

5. Error Handling:

• Promise: Error handling in promise is done usually using .catch(). However, if an error occurs, the promise will reject, and the chain will stop.

• Observable: It has more robust error-handling mechanisms. You can handle errors using operators like catchError and decide whether to recover, continue or retry the process. It can also be completed successfully after an error is handled.

6. Built-In or RxJS

• Promise: It’s a built-in feature of JavaScript and a part of the ECMAScript. Almost all browsers support it.
• Observable: It’s not a built-in feature of JavaScript. In Angular, it’s provided by the RxJS library.

Use Cases

Promise:

• Simple async operations that return a single result, like fetching data from a Web API.
• Scenarios where you don’t need to cancel the operation.
• Handling a single event or action.

Observable:

• Operations that might emit multiple values over time, such as WebSocket connections, user input events, or real-time data streams.
• When you need the ability to cancel the operation.
• Complex async flows require composition, transformation, or error handling.

Examples

Promise Example

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Promise is resolved!');
  }, 1000);
});

myPromise.then(value => console.log(value)).catch(error => console.error(error));

Observable Example

import { Observable } from 'rxjs';

const myObservable = new Observable(observer => {
  setTimeout(() => {
    observer.next('Value-1 retrieved!');
    observer.next('Value-2 retrieved!');
    observer.complete(); // No more values after this
  }, 1000);
});

const subscription = myObservable.subscribe({
  next: value => console.log(value),
  error: error => console.error(error),
  complete: () => console.log('Observable finished!')
});

/* 
  You can unsubscribe to cancel the observable as below:
  subscription.unsubscribe();
*/

Summary

• A promise is simple and suitable for operations that return a single value or need to handle a single event. It’s eager and can’t be canceled.
• An observable is more flexible, especially for handling multiple values over time, allowing for complex data manipulation, and providing the ability to cancel operations. It supports lazy operations via RxJS.

In this article, I'll highlight .NET 9's Blazor updates and important features for ASP.NET Core 9.0. These features are based on the latest .NET 9 Preview 7.

.NET MAUI Blazor Hybrid App and Web App solution template

There's a new solution template to create .NET MAUI native and Blazor web client apps. This new template allows to choose a Blazor interactive render mode, it uses a shared Razor class library to maintain the UI's Razor components.

For more info:

• learn.microsoft.com > maui blazor web app tutorial
• reddit.com/r/Blazor/comments/1dabyzk/net_8_blazor_hybrid_maui_app_web_hosting/

A new middleware: MapStaticAssets

This new middleware optimizes the delivery of static assets in any ASP.NET Core app, also for Blazor. Basically it compresses assets via Gzip, fingerprints for all assets at build time with a Base64 and removes caches when Visual Studio Hot Reload (development time) is in action.

For more info:

• learn.microsoft.com > optimizing static web assets
• learn.microsoft.com > fundamentals of static files

Simplifying the process of querying component states at runtime

1. Finding the component's current execution location: This can be especially helpful for component performance optimization and debugging.
2. Verifying whether the component is operating in a dynamic environment by checking: This can be useful for parts whose actions vary according to how their surroundings interact.
3. Obtaining the render mode allocated to the component: Comprehending the render mode can aid in enhancing the rendering procedure and augmenting the component's general efficiency.

For more info:

• learn.microsoft.com > detect rendering location interactivity & render mode runtime

Detecting component's location, interactivity support and render mode

The ComponentBase.RendererInfo and ComponentBase.AssignedRenderMode now allows to detect the following actions:

• RendererInfo.Name returns the location where the component is executing
• RendererInfo.IsInteractive indicates if the component supports interactivity at the time of rendering.
• ComponentBase.AssignedRenderMode exposes the component's assigned render mode

Better server-side reconnection

• When the previous app is disconnected and the user navigates to this app, or browser put this app in sleep mode, Blazor runs reconnection mechanism.

• When reconnection is not successful because your server killed connection, it automatically makes a full page refresh.

• With the new below config, you can adjust your reconnection retry time:

  • Blazor.start({
      circuit: {
        reconnectionOptions: {
          retryIntervalMilliseconds: (previousAttempts, maxRetries) => 
            previousAttempts >= maxRetries ? null : previousAttempts * 1000
        },
      },
    });
    

Simple serialization for authentication

The new APIs in ASP.NET make it easier to add authentication to existing Blazor Web Apps. These APIs, now part of the Blazor Web App project template, allow authentication state to be serialized on the server and deserialized in the browser, simplifying the process of integrating authentication. This removes the need for developers to manually implement or copy complex code, especially when using WebAssembly-based interactivity.

For more info:

• learn.microsoft.com > blazor Identity UI individual accounts
• learn.microsoft.com > manage authentication state

Easily add static server-side rendering pages

With .NET 9, adding static server-side rendering (SSR) pages to globally interactive Blazor Web Apps has become simpler. The new [ExcludeFromInteractiveRouting] attribute allows developers to mark specific Razor component pages that require static SSR, such as those relying on HTTP cookies and the request/response cycle. Pages annotated with this attribute exit interactive routing and trigger a full-page reload, while non-annotated pages default to interactive rendering modes like InteractiveServer. This approach enables flexibility between static and interactive rendering depending on the page's requirements.

For more info:

• learn.microsoft.com > render-modes

Constructor Injection in Razor Components

Razor components support constructor injection, allowing services like NavigationManager to be injected directly into a component's constructor. This can be used to manage navigation actions, such as redirecting the user upon an event like a button click.

For more info:

• learn.microsoft.com> dependency-injection

Configuring WebSocket Compression and Frame-Ancestors CSP in Interactive Server Components

By default, Interactive Server components enable WebSocket compression and set a frame-ancestors Content Security Policy (CSP) to self, restricting embedding the app in <iframe>. Besides, compression can be disabled to improve security by setting ConfigureWebSocketOptions to null, though this may reduce performance. To prevent embedding the app in any iframe while maintaining WebSocket compression, set the ContentSecurityFrameAncestorsPolicy to 'none'.

For more info:

• learn.microsoft.com > websocket compression
• learn.microsoft.com > interactive server-side rendering when compression enabled

Tracking Composition State with KeyboardEventArgs.IsComposing

The new KeyboardEventArgs.IsComposing property indicates whether a keyboard event is part of a composition session, which is essential for properly handling international character input methods.

Configuring Row Overscan in QuickGrid with new OverscanCount parameter

The QuickGrid component now includes an OverscanCount property, which controls how many extra rows are rendered before and after the visible area when virtualization is enabled. By default, OverscanCount is set to 3, but it can be adjusted as below to 5.

<QuickGrid ItemsProvider="itemsProvider" Virtualize="true" OverscanCount="5">...</QuickGrid>

Range Input Support in InputNumber<TValue> Component

The InputNumber<TValue> component now supports the type="range" attribute, allowing for range inputs like sliders or dials. This feature supports model binding and form validation, offering a more interactive way to input numerical data compared to the traditional text box.

<EditForm>
     <InputNumber @bind-Value="Model.ProductCount" max="999" min="1" step="1" type="range" />
</EditForm>

@code {
    public class MyModel
    {
        [Required, Range(minimum: 1, maximum: 999)]
        public int ProductCount { get; set; }
    }
}

This article discusses whether you need a multi-tenancy architecture for your next project. Answer my critical questions to decide if multi-tenancy suits your application or not!

What’s Multi-tenancy?

It’s an architectural approach to building SaaS solutions. In this model, the hardware and software resources are shared between tenants, and application data is virtually or physically isolated between tenants. Here, the main goal is minimizing costs and maximizing customer count.

An ideal multi-tenant application should be;

• A multi-tenancy system should be designed to work seamlessly and make your application code multi-tenancy aware as much as possible.
• When a customer wants to separate their database, it should also be deployable to on-premise.

Multi-tenant Development is Hard - Reconsider!

Developing a multi-tenant application is harder compared to non-multi-tenant applications. You add TenandId to all your shared entities. And each time you make a query, you need to filter by TenantId. There is an increased risk of security breaches if one tenant's data is compromised. Multi-tenancy can limit the extent of customization available to each tenant since they all operate on the same core infrastructure. Also, in a microservice environment, things get two times more complicated. So you should carefully consider if you need multi-tenancy or not. Sometimes, I got questions like;

No! These are not multi-tenant applications. It just needs a simple filtering by your different branches/faculties/departments/holding sub-companies/ groups or whatever hierarchy is… You are confusing "grouping" with "resource sharing".

Do I Really Need Multi-tenancy?

Ask yourself the following questions if you cannot decide whether your app needs multi-tenancy or not;

1. Can a user be shared among other tenants?
2. Any tenant needs to see other tenant's data?
3. Does your application break when you physically move one of the tenants?
4. Do your customers need higher security and better GDPR enforcement?
5. Do you need cumulative queries over your tenants?

Let's answer these questions;

1. Can a user be shared among other tenants?

If you need to share a user among other tenants, or in other words, users can be members of different tenants, then your application is definitely not multi-tenant! Multi-tenancy means a tenant’s data is always isolated, even if it’s logically separated. You cannot share a user among your tenants. The reason is simple: In the future, if you move a tenant to on-premise, then your application will break!

2. Does any tenant need to see other tenants' data?

If your answer is YES, then your application is not multi-tenant. In multi-tenant apps, the tenant's data cannot be shared in any circumstances among the other tenants. Business decision-makers sometimes want to share some entities with other tenants. If there's this requirement, you shouldn't start a multi-tenant architecture. You can simply group these tenants manually. Again, reply to this question; In the future, if I move a tenant physically to another environment, will my app still work properly? In this case, it will not!

Let's say your app is Amazon.com and you have a product entity iPhone that you want to share with other sellers. This requirement violates the multi-tenant rule. While your Amazon.com is still SaaS, it shouldn't be multi-tenant.

On the other hand, if you serve several online shopping websites dedicated to different brands. Let's say Nike and Adidas want to have their own e-commerce websites. And your Amazon.com provides these companies with their own subdomains: nike.amazon.com and adidas.amazon.com. In this architecture, these companies will have their own user, roles, settings. Also these companies will have their own branding like custom login screen, custom logo, different theme layouts, menu items, language options, payment gateways etc... Hence, this is %100 multi-tenant.

3. Does your application break when you physically move one of the tenants?

If your answer is YES, you should stop making it multi-tenant. It is not a multi-tenant app! This means your tenants are tightly coupled with the application's infrastructure or database, and this requirement prevents you from making it multi-tenant because it disrupts the entire system when you take out a tenant.

4. Do your customers need higher security and better GDPR enforcement?

If your answer is YES, you should not make it multi-tenancy. When a hacker gets into your server, he can steal all your client data. Also, if you have a security hole, a tenant can gain access to other tenants' data. Especially your tenants' data is being shared in the same database... On the other hand, some customers, for example, government agencies or banks, may be required to locate the database in their own geo-location and make it unreachable from the main application. In this case, you should go with a single-tenant architecture. Another difficulty is that some tenants may have different data retention policies, so you must implement different strategies for each tenant. In this case, you should also consider making it a single-tenant.

5. Do you need cumulative queries over your tenants?

This question is not a clear decision parameter for multi-tenancy. But it can be a supportive parameter for your decision. Actually, this is a common feature in multi-tenant systems where aggregated reporting or analytics across tenants is required. In a virtually isolated multi-tenant environment, you can easily do this by just disabling the multi-tenancy filter. However, when some of your tenants have separate databases or application instances, it becomes harder to get aggregate reports.

Do you need cumulative queries over your tenants? If your answer is YES, then you should keep all your tenants' data in a shared database to easily query them. But if you still need to physically move some of the tenants, then you have the following strategies:

• First, all your databases need to be on the same network so that you can gather data from different databases.
• Second, in some cases, according to the GDPR requirements or government agency regulations, you must locate the database in their geo-location. And you cannot connect to these databases. In this case, you can create a Web API in your application that gives you a report for this specific tenant. Later, you'll gather the reports from all your tenants like this and merge them.
• Third; When the tenant databases are in different geo-location (inaccessible), then each tenant can send their report to your central server. So you can generate cumulative reports.

Conclusion

• It's important to decide on the first day whether your application needs to be multi-tenant. To decide this, consider these topics;

  • Do my tenants really have a relationship with each other? No, they have nothing to do in common; OK, go with multi-tenancy.
  • My tenants don't have a relationship with each other, and the only thing they have in common is sharing my application. OK, go with multi-tenancy.
  • When a tenant leaves the system (by removing their data), the other tenants also stop working This means that the tenants are coupled. Do not do multi-tenancy!

We’ve been working for a long time on multi-tenancy, microservices, modular development topics, and developing tools and frameworks for repetitive development tasks. Check out the amazing open-source ABP Framework, which provides all the alternative solutions to implement a multi-tenant architecture. The multi-tenancy logic is seamlessly done at the core level, and you can simply focus on your business code. Keep it simple, nice and neat with ABP.

ABP.IO: The Modern Way of Developing Web Apps for .NET Developers!

Alper Ebicoglu / x.com/alperebicoglu

— ABP Team

Angular Schematics is a powerful tool which is part of the Angular CLI that allows developers to automate various development tasks by generating and modifying code. Schematics provides a way to create templates and boilerplate code for Angular applications or libraries, enabling consistency and reducing the amount of repetitive work.

Key Concepts of Angular Schematics:

1. Code Generation:

   • Schematics can generate boilerplate code for various Angular artifacts, such as components, services, modules, pipes... For example, when you run a command like ng generate component my-component, Angular uses a schematic to create the component files and update the necessary modules.

2. Code Modification:

   • Schematics can also modify existing code in your project. This includes tasks like updating configuration files, adding new routes, or modifying Angular modules. They can be very useful when upgrading projects to a new version of Angular or adding new features that require changes to the existing codebase.

3. Custom Schematics:

   • Developers can create their own custom schematics to automate repetitive tasks specific to their projects. For example, if your team frequently needs to set up a certain type of service or configure specific libraries, you can create a schematic that automates these steps. In ABP Suite, we use the custom schematics templates to generate CRUD pages for Angular UI.

4. Collection of Schematics:

   • Schematics are often grouped into collections. The Angular CLI itself is a collection of schematics. You can create your own collection or use third-party schematic collections created by the Angular community.

5. Integration with Angular CLI:

   • Schematics is integrated with the Angular CLI. The ng generate and ng add commands are examples of how schematics are used in everyday Angular development. When you use these commands, the Angular CLI runs the corresponding schematic to perform the desired operation.

6. Upgrade Tasks:

   • Schematics can be used to automate the process of upgrading Angular applications. For example, the Angular Update command (ng update) uses schematics to automatically apply necessary changes to your project when upgrading to a new version of Angular.

Common Use Cases:

• Generating Components, Services, Modules.: Easily create Angular building blocks with commands like ng generate component, ng generate service, or ng generate module.

• Adding Libraries: Automatically set up and configure third-party libraries with ng add. For example, ng add @angular/material uses a schematic to install and configure Angular Material in your project.

• Automating Project Upgrades: Simplify the process of upgrading Angular versions by running ng update, which uses schematics to make necessary code changes.

• Custom Project Scaffolding: Create custom schematics to enforce your team's development standards and best practices by automating the creation of specific project structures.

How to Create a Custom Schematic:

Creating a custom schematic involves several steps:

1. Install the Schematics CLI:

   npm install -g @angular-devkit/schematics-cli
   

2. Create a New Schematic Project:

   schematics blank --name=my-schematic
   cd my-schematic
   

3. Define Your Schematic: Modify the files in the schematic project to define what your schematic will generate or modify.

4. Test Your Schematic: You can run your schematic locally using the schematics command.

5. Publish Your Schematic (Optional): Once your schematic is ready, you can publish it to npm or include it in your Angular projects.

Example:

If you want to create a custom component with specific settings or styles, you can create a schematic to automate this. Every time a developer on your team needs to create this type of component, they can run the schematic, ensuring consistency across the project.

Helpful Links

Here are the direct links for the Angular Schematics resources:

• Angular Official Documentation: Schematics Overview — angular.io

• Creating Custom Schematics — angular.io

• CLI Schematic Command — angular.io

• Devkit Schematics— github.com

• Schematics Examples — github.com

• Debugging Angular Schematics — dev.to

• Using Schematics with Nx — nx.dev

• Schematics API — angular.io

Conclusion:

Angular Schematics is a powerful tool for automating repetitive tasks, generating consistent code, and managing project upgrades. By leveraging schematics, Angular developers can save time, reduce errors, and enforce best practices across their projects.

Ahead-of-Time (AOT) Compilation

What is AOT?

• AOT compilation refers to the process of compiling your Angular application during the build phase, before the application is served to the browser.
• The Angular compiler converts your TypeScript and HTML templates into efficient JavaScript code ahead of time.

Advantages:

1. Faster Rendering: Since the compilation is done beforehand, the browser receives precompiled code, leading to faster rendering and better performance when the app loads.
2. Smaller Bundle Size: AOT eliminates the need for the Angular compiler in the client-side bundle, which reduces the overall bundle size.
3. Improved Security: AOT compilation checks your templates and bindings during the build process, catching errors early and reducing the risk of injection attacks.
4. Early Error Detection: Errors related to templates and bindings are caught during the build time rather than at runtime, leading to more robust and error-free applications.

When to Use:

• AOT is typically used in production builds because it provides better performance, smaller bundles, and more secure applications.

How to Use:

• AOT is the default when you run ng build --prod in an Angular project.

Just-in-Time (JIT) Compilation

What is JIT?

• JIT compilation occurs in the browser at runtime. The Angular compiler translates the TypeScript and HTML templates into JavaScript code just before the application runs in the browser.
• The application is compiled on the fly as the user interacts with it.

Advantages:

1. Faster Build Time: Since there’s no pre-compilation step, the build process is faster during development.
2. More Flexible Development: JIT allows for rapid iteration during development, as changes can be quickly reflected without needing to rebuild the entire application.
3. Dynamic Components: JIT allows for more flexibility in scenarios where components need to be dynamically created or compiled at runtime.

When to Use:

• JIT is typically used in development environments because it allows for quicker build times and easier debugging.

How to Use:

• JIT is the default compilation method when you run ng serve for development builds in Angular.

Comparison Summary:

| Feature | AOT (Ahead-of-Time) | JIT (Just-in-Time) | | ---------------------- | ----------------------------- | ---------------------------------- | | Compilation Timing | At build time | At runtime | | Performance | Faster application startup | Slower application startup | | Bundle Size | Smaller (no Angular compiler) | Larger (includes Angular compiler) | | Error Detection | Catches template errors early | Errors caught at runtime | | Use Case | Production | Development | | Dynamic Components | Less flexible | More flexible |

Best Practices:

• Use AOT for production builds to ensure faster load times, smaller bundle sizes, and more secure applications.
• Use JIT during development to take advantage of quicker builds and easier debugging.

Unified domain and enhanced navigation 🌍

All our services are now consolidated under a single domain; abp.io. This means you no longer need to navigate through multiple subdomains. The new mega menu makes finding what you need easier and faster.

Modern design and improved UX 🎨

The platform boasts a fresh, modern design aimed at improving both aesthetics and functionality. This redesign enhances usability, making your interaction with ABP.IO more intuitive.

Documentation in one place 📃

We’ve combined the ABP (open-source) and ABP Commercial (paid) documents into a single, comprehensive resource. This unified documentation will help you find what you're looking for more efficiently. The new documentation address is abp.io/docs. When you switch to old ABP versions before v8.3, you will see the old documents are still available.

Introducing "ABP Studio Community Edition" 🪄

We're excited to introduce the ABP Studio Community Edition, which is now available for free. This edition provides powerful tools to streamline your development process. You can easily create a new project with a configuration wizard in ABP Studio. It also provides module management, which means you can add/remove an ABP Module easily. You can also debug your microservice project and track the HTTP requests easily. Connecting your local development environment to a local or remote Kubernetes cluster is another cool feature of ABP Studio. We aim for ABP Studio to be the primary tool for ABP developers to manage their projects.

Download ABP Studio 👉 abp.io/studio.

Enhanced "ABP CLI" 🚀

ABP CLI is also renewed. The new CLI is compatible with ABP Studio. It adds new commands. The new CLI is now available on NuGet at nuget.org/packages/Volo.Abp.Studio.Cli. It's a dotnet global tool. When you install ABP Studio, the new ABP CLI is automatically installed. You can still use the old ABP CLI commands. To use the legacy ABP CLI commands just add --old parameter to your commands.

The docs of the new ABP CLI 👉 abp.io/docs/latest/cli.

20% Celebration discount 💰

To celebrate the launch of the new platform, we're offering a 20% discount for a limited time. This discount is valid for all new purchases, renewing existing licenses and buying additional developer seats.

Discounted prices 👉 abp.io/pricing.

Existing customers 🛂

In terms of licensing rules, existing customers will not be affected by this change. You can manage your license just like before at abp.io/my-organizations.

The new support website address 👉 abp.io/support.

Community Talk on the new ABP Platform

We made a community talk on YouTube on August 1st, 2024, and we explained these topics. You can watch it from the below link:

Why choose the ABP Platform? 🙄

ABP Platform simplifies modern software development with well-architected startup templates, modular design infrastructure, multi-tenancy support, comprehensive security features, and a vibrant community. If you are starting a new web project or transforming your legacy application, ABP is the perfect solution! If you still wonder why you need such a solution, see abp.io/why-choose-abp.

There are several startup ASP.NET Core templates for your requirements. Read abp.io/how-it-works page to understand ABP's approach. We have a FAQ page where you can find answers to many of your questions abp.io/faq.

Start your new ABP project -for free- 👉abp.io/get-started!

Join our community 👨‍👨‍👦

We invite developers, IT professionals, and businesses to join the ABP Community. Our community website is now abp.io/community. On this website, you can read ABP-related posts, watch live community shows and core team's fundamental video courses...

For more information, visit our newly unified platform at abp.io. We look forward to your feedback and continued support as we grow together!

Found a bug in the new platform? Or if you have an idea, write to us 👉 abp.io/contact.

📢 We're excited to announce an improvement to your ABP.IO experience! In our ongoing effort to simplify and improve your interaction with our platform, we are working on a new design for ABP.IO and its subdomains. This update isn't just about aesthetics; it's a comprehensive enhancement aimed at unifying all our services under a single platform address: https://abp.io.

Why are we making this change?

Whether you're developing with our open-source framework or using our commercial product, or looking for support; our goal is always to deliver the best experience possible. The new design will improve several aspects:

🔹Simplifying Navigation: As the ABP.IO platform has grown rapidly, navigating through numerous subdomains has become challenging. We're transitioning to a well-structured mega menu system that will make navigation tidier and more straightforward. With everything under the ABP.IO domain, finding what you need will be easier.

🎨 Enhancing User Experience: We're introducing a fresh, modern design that not only looks better but also enhances functionality and ease of use.

🔎 Better SEO: A unified domain improves our platform's discoverability, making it easier for new users to find us and for you to share resources with your peers.

Which services are being unified?

✅ The following websites will now be unified under ABP.IO:

• blog.abp.io 👉 abp.io/blog

• docs.abp.io 👉 abp.io/docs

• support.abp.io 👉 abp.io/support

• community.abp.io 👉 abp.io/community

• commercial.abp.io 👉 abp.io

⛔ The following websites will not be unified during this transition: admin.abp.io, account.abp.io, nuget.abp.io

What can you expect?

The new ABP.IO platform is designed with you in mind. Here’s what to look forward to:

• Seamless Integration: Transitioning from multiple subdomains to a single address without losing track of your favorite resources. We will keep many pages the same as before. Page-based transitions will be made over a longer period of time.

• Improved Support and Documentation: We will merge commercial and open-source docs into a single address so it'll be easier to access our documentation.

Your journey with us during this transition

We know that change is overwhelming, but we are trying to provide a smooth transition. Here's how we're making it seamless for you:

🚩 No Immediate Action Required: Your existing bookmarks and links will continue to work, automatically redirecting you to the new unified platform.

🎗 Stay Informed: We will keep you updated with guides and support during the transition.

📧 We’re Here to Help: Our support team is ready to assist you with any questions or concerns. If you have any issues, you can contact us at our Discord channel or send an email to info@abp.io.

Looking Ahead

This upgrade is another milestone in our journey together. Thank you for your support and feedback, which have been instrumental in making this transition possible. Stay tuned for more updates, and here's to a new chapter together at ABP.IO!

Happy coding 🫡

ABP.IO Team

Recently we have published ABP v8.0. With this version the ABP Framework and ABP Commercial both supports for .NET 8, aligning itself with the latest enhancements and new features of the ASP.NET's new version 8.

Here's the related PR for this upgrade. This update ensures that developers using ABP can leverage the new features and improvements of .NET 8, enhancing the capability and performance of their applications. With .NET 8 support, ABP 8.0 likely offers improved performance, enhanced security, and greater efficiency, making it a robust choice for building modern web applications. Here's the summary of .NET 8 features and enhancements:

What's new in .NET 8

.NET Aspire

.NET Aspire is a tool to observe and manage distributed web applications. It's still preview version. You can manage your containers, executables, logs, traces and metrics of your running web application. For more information see this article https://devblogs.microsoft.com/dotnet/introducing-dotnet-aspire-simplifying-cloud-native-development-with-dotnet-8/

Serialization

12 features have been implemented for System.Text.Json serialization and deserialization library with .NET 8. See these enhancements

• Built-in support for additional types
• Source generator
• Interface hierarchies
• Naming policies
• Read-only properties
• Disable reflection-based default
• New JsonNode API methods
• Non-public members
• Streaming deserialization APIs
• WithAddedModifier extension method
• New JsonContent.Create overloads
• Freeze a JsonSerializerOptions instance

Time abstraction

You may mock time in test scenarios with the new TimeProvider class and ITimer interface, which add time abstraction functionality.

UTF8 improvements

The new IUtf8SpanFormattable interface targets UTF8 and Span<byte> instead of UTF16 and Span<char>. Also the new Utf8.TryWrite methods provide a UTF8 based counterpart to the existing MemoryExtensions.TryWrite methods, which are UTF16-based.

Data validation

There are new validation attributes for cloud-native services. The new properties were added to the RangeAttribute and RequiredAttribute types. See the list below for the new validation attributes:

| New Data Attribute | Description | | ------------------------------------------------------------ | ------------------------------------------------------------ | | MinimumIsExclusive, MaximumIsExclusive | Checks whether bounds are included in the allowable range | | Length | Checks both lower and upper bounds for strings or collections. For example, [Length(5, 10)] requires at least 5 elements and at most 10 elements in a collection | | Base64String | Checks that a string is a valid Base64 format | | AllowedValues, DeniedValues | Checks if values are from the allowed or disallowed list eg: [AllowedValues("man", "woman", "child")] |

Randomness methods

The System.Random and System.Security.Cryptography.RandomNumberGenerator types present 2 new approaches to handling randomness.

Performance-focused types

• The new System.Collections.Frozen namespace includes the collection types FrozenDictionary and FrozenSet.
• Methods like MemoryExtensions.IndexOfAny look for the first occurrence of any value in the passed collection.
• The new System.Text.CompositeFormat type is useful for optimizing format strings that aren't known at compile time (for example, if the format string is loaded from a resource file).
• New System.IO.Hashing.XxHash3 and System.IO.Hashing.XxHash128 types provide implementations of the fast XXH3 and XXH128 hash algorithms.

System.Numerics and System.Runtime.Intrinsics

The System.Numerics and System.Runtime.Intrinsics namespaces introduces some hardware improvements with .NET 8. The following structs reimplemented for running with the best performance on ARM64.

Vector256, Matrix3x2, and Matrix4x4 have improved

Metrics

New APIs let you attach key-value pair tags to Meter and Instrument objects when you create them. Aggregators of published metric measurements can use the tags to differentiate the aggregated values.

Cryptography

SHA-3 (Secure Hash Algorithm 3) is the latest member of the Secure Hash Algorithm family of standards. With .NET 8 SHA-3 is being supported.

HTTPS proxy support

Before HttpClient allows hackers to make man-in-the-middle attack with .NET 8, it creates an encrypted channel between the client and the proxy so all requests can be handled with full privacy.

Stream-based ZipFile methods

The new ZipFile.ExtractToDirectory provides a stream containing a zipped file and extract its contents into the filesystem.

Hosted lifecycle services

Hosted services now have more options for execution during the application lifecycle. IHostedService provided StartAsync and StopAsync, and now IHostedLifecycleService provides these additional methods:

• StartingAsync(CancellationToken)
• StartedAsync(CancellationToken)
• StoppingAsync(CancellationToken)
• StoppedAsync(CancellationToken)

Native AOT support

The option to publish as Native AOT was first introduced in .NET 7. Publishing an app with Native AOT creates a fully self-contained version of your app that doesn't need a runtime—everything is included in a single file. .NET 8 brings the following improvements to Native AOT publishing:

| Operating system | .NET 7 | .NET 8 | | :-------------------------------------- | :------ | :------ | | Linux x64 (with -p:StripSymbols=true) | 3.76 MB | 1.84 MB | | Windows x64 | 2.85 MB | 1.77 MB |

Target iOS-like platforms with Native AOT

.NET 8 starts the work to enable Native AOT support for iOS-like platforms. You can now build and run .NET iOS and .NET MAUI applications with Native AOT on the following platforms:

• ios
• iossimulator
• maccatalyst
• tvos
• tvossimulator

Performance improvements

.NET 8 includes improvements to code generation and just-in time (JIT) compilation:

• Arm64 performance improvements
• SIMD improvements
• Support for AVX-512 ISA extensions (see Vector512 and AVX-512)
• Cloud-native improvements
• JIT throughput improvements
• Loop and general optimizations
• Optimized access for fields marked with ThreadStaticAttribute
• Consecutive register allocation. Arm64 has two instructions for table vector lookup, which require that all entities in their tuple operands are present in consecutive registers.
• JIT/NativeAOT can now unroll and auto-vectorize some memory operations with SIMD, such as comparison, copying, and zeroing, if it can determine their sizes at compile time.

.NET SDK

This section contains the following subtopics:

• CLI-based project evaluation
• Terminal build output
• Simplified output paths
• 'dotnet workload clean' command
• 'dotnet publish' and 'dotnet pack' assets
• Template engine
• Source Link
• Source-build SDK

ASP.NET composite images

As part of an effort to improve containerization performance, new ASP.NET Docker images are available that have a composite version of the runtime. This composite is built by compiling multiple MSIL assemblies into a single ready-to-run (R2R) output binary. Because these assemblies are embedded into a single image, jitting takes less time, and the startup performance of apps improves. The other big advantage of the composite over the regular ASP.NET image is that the composite images have a smaller size on disk.

Source-generated COM interop

.NET 8 includes a new source generator that supports interoperating with COM interfaces.

Minimum support baselines for Linux

The minimum support baselines for Linux have been updated for .NET 8. .NET is built targeting Ubuntu 16.04, for all architectures.

AOT compilation for Android apps

To decrease app size, .NET and .NET MAUI apps that target Android use profiled ahead-of-time (AOT) compilation mode when they're built in Release mode. Profiled AOT compilation affects fewer methods than regular AOT compilation. .NET 8 introduces the <AndroidStripILAfterAOT> property that lets you opt-in to further AOT compilation for Android apps to decrease app size even more.

Code analysis

.NET 8 includes several new code analyzers and fixers to help verify that you're using .NET library APIs correctly and efficiently. The following table summarizes the new analyzers.

NuGet

Starting in .NET 8, NuGet verifies signed packages on Linux by default. NuGet continues to verify signed packages on Windows as well.

C# Hot Reload supports modifying generics

Starting in .NET 8, C# Hot Reload supports modifying generic types and generic methods. When you debug console, desktop, mobile, or WebAssembly applications with Visual Studio, you can apply changes to generic classes and generic methods in C# code or Razor pages. For more information, see the full list of edits supported by Roslyn

References:

• https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-8

Blazor is a web framework that allows developers to build interactive web applications using .NET instead of JavaScript. The first version of Blazor was released on May 14, 2020. Since its initial release, Blazor has evolved with the new versions. Until now, six different versions have been declared. Sometimes, it can be not very clear to see the differences between these approaches. First, let's try to understand these.

• Blazor-Server: >> Loads fast at first >> In this version, heavy things are done in the server. Browsers are thin clients and download a small page for the first load. The page updates are done via SignalR connection. This was released with .NET Core 3.

• Blazor WebAssembly (WASM): >> Loads slow at first >> In this version, some binary files are being downloaded to the browser. This approach takes longer initialization time than the "Server" approach. The hard work is done on the browser.

• Blazor Hybrid: It's a combination of Blazor and Xamarin.Forms. It allows you to run your app on iOS, Android, macOS, and Windows. Blazor Hybrid uses a WebView component to host the Blazor-based user interface within the mobile app.

• Blazor Native: It runs natively on the devices and uses a common UI abstraction to render native controls for that device. This is very similar to how frameworks like Xamarin Forms or React Native work today. It has also been considered but has not reached the planning stage.

• Blazor United: Recently, Microsoft updated this name to "Fullstack web UI". Blazor-Server and Blazor WASM both have some disadvantages and advantages. So, Microsoft decided to combine these two approaches and find an optimum solution for the entire Blazor version. We can call it Best of Blazor 😀

Why is "Blazor Fullstack Web UI" the best?

These apps are a combination of both Blazor Server and Blazor WASM. It provides the advantages of Blazor Server and WASM. Developers would be able to more fine-tune the rendering mode. This approach overcomes the large binary downloads of Blazor WASM, and it resolves the Blazor Server's problem, which always needs to be connected to the server via SignalR.

Blazor Fullstack Web UI comes with the .NET 8, and it will be published on November 14, 2023.

I took the following photo from Steven Sanderson's talk at NDC Porto 2023. You can read my impressions of this conf at https://volosoft.com/blog/ndc-port-2023-impressions, but after reading this one.

There are two basic page styles:

• HTML; simple and loads fast! Eg: MVC, Razor Pages
• Single Page Apps (SPA): high interaction with the client and loads slower! Eg: Blazor WASM, Blazor Server...

HTML + SPA => Blazor Fullstack

Blazor Fullstack (formerly United) is a technology that turns Blazor Server into a SPA style.

.NET 8 will combine Blazor Server's server-side rendering and WebAssembly's client-side interaction.

You can switch between two rendering modes and even mix them on the same page. With .NET 8 there also comes amazing features like;

• Streaming rendering: With this feature, most of the page will be rendered, and long async operations on the server will still be in progress.

• Progressive enhancement of form submission & navigation: With this feature, it doesn't fully reload the page after submitting the form. This gives the user a better and smoother experience.

How it works?

Rendering on Server

You can add WebComponentRenderMode.Server to your Blazor components so that these components will run interactively. In the below example, the list editor will make AJAX requests to the server like single-page applications.

And sure, you can add WebComponentRenderMode.Server to your page level, and the complete page will be rendered as a server component. All inputs on this page can work as an interactive server component like SPA mode.

Rendering on Client

You can switch to WebAssembly mode by writing WebComponentRenderMode.WebAssembly attribute to your page. By doing so, the whole page should run interactively using WebAssembly. This time there's no server connection anymore because it loads the binaries (WebAssembly runtimes) at the page load.

Enabling the Blazor Fullstack UI?

To enable Blazor Full-stack Web UI, you need to write net8.0;net7.0-browser into the TargetFrameworks area of your csproj file. These two keywords change your app like this; net8.0 framework renders on the server, and net7.0-browser framework renders on the browser.

Let the System Decide WebAssembly or Server Approach

You can let the system decide whether it uses WebAssembly or Server. This can be done with the Auto mode of the WebComponentRenderMode. In this case, it will not load binary files (WebAssembly files) for the initial page that has WebComponentRenderMode.Server attribute, but whenever the user navigates to a page that has WebComponentRenderMode.WebAssembly, it will download the runtimes. This will allow us to load the initial page very fast, and when we need interactivity, we can switch to WebAssembly and wait for the binaries to download. But this download will be done one time because it will be cached.

Conclusion

I summarized the new generation Blazor in a very simple way. This architecture will be useful to everyone who uses Blazor.

Resources:

• You can check Dan Roth's GitHub issue 👉 github.com/dotnet/aspnetcore/issues/46636.
• Steven Sanderson's YouTube video is very good for understanding these concepts 👉 Blazor United Prototype Video.
• "Full Stack Web UI with Blazor" — .NET Conf 2023 video 👉 learn.microsoft.com/en-us/shows/dotnetconf-2023/full-stack-web-ui-with-blazor-in-dotnet-8

1. Improved Support for Interpolated Strings 🧩

With the release of C# 12, you now have the option to incorporate expressions inside interpolated strings. With the help of this functionality, You can now create dynamic values for strings using complicated expressions and techniques.

For instance, you can use code like this:

int x = 10;

string message = $"The value of x is {x}, and its square is {x*x}.";

This will result in a string value of "The value of x is 10, and its square is 100."

2. Primary Constructors 📝

You can now create primary constructors in any class and struct. With primary constructors, developers can add parameters to the class declaration and use these values inside the class body.

Primary constructors were introduced in C# 9 as part of the record positional syntax. C# 12 extends these to all structs and classes.

 public class Book(int pageSize, string authorName, IEnumerable<float> prices)

  {

      public Book(int pageSize, string authorName) : this(pageSize, authorName, Enumerable.Empty<float>()) { }

      public int pageSize => pageSize;

      public string authorName { get; set; } = authorName;

      public float totalPrice => prices.Sum();

  }

The good part is that you can avoid the pain of declaring private fields and, you know, binding parameter values to those fields in those tedious constructor bodies by using primary constructors instead.

3. Improved Lambda Expressions 🐑

Many of us are using Lambda expressions in our daily development to gain the code better readability.

With this version we see that many enhancements came to lambda expressions make them more effective.

For example, you can now create more complex expressions within lambda functions using the new and , or operators.

Besides, lambda expressions can now be transformed into expression trees, simplifying the construction of complex queries and optimizing performance.

4. Async Streams 🌐

You may iterate through asynchronous data sources thanks to the new async streams feature in C# 12.

This new iterator await foreach gains us to iterate over a set of async data.

See the following code snippet:

await foreach (var record in FetchRecordsAsyncData())

{

   Console.WriteLine(record.text);

}

This will iterate over the asynchronous data returned by the GetAsyncData() method and writes each item's text to the console.

5. Target-typed New Expressions 🎯

Target-typed new expressions, a new feature in C# 12, make it simpler to construct new objects.

You can now declare new objects using the var keyword.

The object's type is inferred from the context.

Especially when dealing with complex types, it gives us better code readability.

An alternative to writing:

AcmeClass thatObject = new AcmeClass();

You can now write:

var thatObject = new AcmeClass();

Conclusion 🎬

As always Microsoft makes developers' life easier with every release of .NET and C#.

C# 12 comes with many features and improvements.

You now have new tools at your disposal to create more effective, concise, and durable code.

You may now design more potent and reliable applications with C# thanks to the increased support for interpolated strings, records, lambda expressions, target-typed new expressions, and async streams.

Start C# 12 with the ABP Framework 📚

ABP Framework offers an opinionated architecture to build enterprise software solutions with ASP.NET Core best practices on top of the .NET and the ASP.NET Core platforms. It is also a powerful infrastructure to help you develop low-effort web-optimized applications. It provides the fundamental web application infrastructure, production-ready dotnet startup templates, modules, asp.net core ui themes, tooling, guides and documentation to implement that ASP.NET core architecture properly and automate the details and repetitive work as much as possible.

If you are starting a new ASP.NET Core project and want a fast website abp.io now...

🆓 It's FREE & OPEN-SOURCE! 🔓

Happy coding 🍿✨

I'm Alper Ebicoglu 🧑🏽‍💻\

ABP Framework Core Team Member\

Follow me for the latest news about .NET and software development:\

📌 twitter.com/alperebicoglu\

📌 github.com/ebicoglu\

📌 linkedin.com/in/ebicoglu\

📌 medium.com/@alperonline

Brief Summary:

This article is intended for .NET Core developers who wish to create a robust and useful.NET core application. It is a list of the most popular and widely used .NET Core libraries that have been carefully vetted. Go up the GitHub reference link for the DotNet libraries and see how many stars the .NET community has rewarded.

Best .NET libraries — Top useful libraries every .NET developers use

.NET Core has become one of the most popular frameworks for developing modern applications. One of the reasons for its popularity is the wide range of libraries available to developers. .NET Core got new updates in its features with lesser coding, deploying high-accomplishment, and extremely scalable applications. Making the underlying architecture functions more effective and efficient without having to reinvent the wheel will free up your time to focus on more crucial tasks, including making your application stand out from the competition.

In this article, we'll take a closer look at The Most Popular .NET Libraries Every Developer Should Know. As a software developer, you're likely familiar with the .NET framework and the many libraries it offers. With so many options available, it can be overwhelming to know which ones to choose for your project. This is the main reason I have compiled a list of the Top 10 .NET Libraries That Developers Should Use to make their development process more efficient and effective. A list of Top 10 .NET Core Libraries will let developers understand these so that they can pick appropriate libraries for their projects.

If you're a .NET Core developer, there are 10 important .NET Core libraries that you should be familiar with. While creating these Essential 10 .NET Libraries Every Developer Must Know, I used NuGet and GitHub.com popular repositories. And all the libraries listed here are also open-source. The list is filtered with only to .NET Core related libraries. Also I excluded the Microsoft .NET Core Framework libraries from this Top 10 Unique .NET Core Libraries Developers Must Utilize. So, without further ado, let’s get right into it:

Top 10 best libraries for .NET developers

Here's the list of the most popular open-source .NET tools:

1. Newtonsoft.Json: This library is widely used for working with JSON data in .NET applications. It provides high performance and ease of use, making it a go-to solution for serialization and deserialization of JSON data.

2. Dapper: It is a simple and efficient ORM that offers high performance and flexibility when working with relational databases. It is easy to use and offers a fast and efficient way to interact with databases.

3. Polly: Polly is a library that helps handle transient errors and faults in .NET applications. It offers an easy-to-use policy-based approach to handling retries, timeouts, and circuit breakers, making it a valuable tool for building reliable applications.

4. AutoMapper: This .NET Core library simplifies object-to-object mapping by automatically mapping properties from one object to another. This library is especially useful in larger projects where mapping can become time-consuming and tedious.

5. FluentValidation: It is a library that provides a fluent API for building validation rules. It makes it easy to create complex validation logic and supports a wide range of validation scenarios, making it a valuable tool for ensuring data integrity in your applications.

6. Serilog: This library is a structured logging library that makes it easy to collect and analyze logs from your application. It offers flexibility and extensibility, and supports a variety of sinks for storing logs, including Elasticsearch, SQL Server, and more.

7. Swashbuckle.AspNetCore.Swagger: This library generates OpenAPI documentation for your ASP.NET Core Web API. It makes it easy to understand the functionality of your API and allows you to easily generate client code for your API.

8. NLog: It is is a free logging platform for .NET with rich log routing and management capabilities. It makes it easy to produce and manage high-quality logs for your application regardless of its size or complexity.

9. Moq4: It is is a popular mocking framework for .NET applications. It makes it easy to create mock objects for unit testing, reducing the need for expensive and time-consuming integration testing.

10. StackExchange.Redis: This is a library for working with Redis databases in .NET applications. It provides a simple and efficient way to interact with Redis, and offers high performance and scalability.

Top 10 .NET Core Libraries List That Every Developer Must Know

Here you can see them in the table with the GitHub stars, GitHub release counts, recent release frequency, NuGet download counts and per day NuGet download counts:

| GitHub URL | NuGet URL | Stars | Releases | Last release | Downloads | Download Per Day |

| ------------------------------------------------------------ | ------------------------------------------------------------ | ----- | -------- | ------------ | --------- | ---------------- |

| Newtonsoft.Json | Newtonsoft.Json | 10K | 65 | 1 month ago | 3B | 680K |

| Dapper | Dapper | 16K | 70 | 2 years ago | 216M | 50K |

| Polly | Polly | 12K | 26 | 1 year ago | 335M | 92K |

| AutoMapper | AutoMapper | 9K | 41 | 6 months ago | 400M | 90K |

| FluentValidation | FluentValidation | 8K | 68 | 3 days ago | 250M | 56K |

| Serilog | Serilog | 6K | 15 | 1 month ago | 722M | 197K |

| Swashbuckle.AspNetCore.Swagger | Swashbuckle.AspNetCore.Swagger | 5K | 28 | 4 months ago | 386M | 168K |

| NLog | NLog | 6K | 125 | 1 week ago | 217M | 48K |

| Moq | Moq | 5K | 33 | 4 months ago | 418M | 93K |

| StackExchange.Redis | StackExchange.Redis | 5K | 34 | 11 days ago | 244M | 74K |

In conclusion, these 10 .NET Core libraries are essential tools for any .NET Core developer. They offer a wide range of functionality, from handling errors to mocking for unit testing and simplifying object mapping. Whether you're working on a large-scale enterprise application or a small project, these libraries can help you build more reliable, efficient, and effective applications.

There's also a cool GitHub page that gathers all kinds of popular .NET tools. Check out https://github.com/quozd/awesome-dotnet

What is ABP Framework?

ABP Framework offers an opinionated architecture to build enterprise software solutions with best practices on top of the .NET and the ASP.NET Core platforms. It provides the fundamental infrastructure, production-ready startup templates, modules, themes, tooling, guides and documentation to implement that architecture properly and automate the details and repetitive work as much as possible.

If you are starting a new ASP.NET Core project, try abp.io now...

IT IS FREE AND OPEN-SOURCE!

I'm Alper Ebicoglu 🧑🏽‍💻 \

ABP Framework Core Team Member\

Follow me for the latest news about .NET and software development:\

📌 twitter.com/alperebicoglu\

📌 github.com/ebicoglu\

📌 linkedin.com/in/ebicoglu\

📌 medium.com/@alperonline

ASP.NET Core Architecture Best Practices

ABP Framework is an application design framework that provides developers with a powerful set of tools to build web applications quickly and efficiently. It is an open-source, cross-platform framework supporting monolithic and microservices architectures. ABP Framework is built on top of the ASP.NET Core architecture and incorporates best practices for developing web applications.

ASP.NET Platform

The framework includes a wide range of features, such as an angular code generator with the help of ABP Suite, project templates, and web application themes. These features enable developers to create web applications that are both functional and visually appealing without spending much time on coding. Moreover, ABP Framework provides a common application framework that can be used for different applications, including SaaS, e-commerce, and social media platforms.

ABP Framework also supports the domain-driven design, which means that the framework is designed to be flexible and adaptable to different business requirements. This approach allows developers to build applications aligned with business needs, ensuring they are efficient and effective.

Open Source Dot Net Framework

One of the major advantages of ABP Framework is its open-source nature. Many developers continuously improve and update the framework, making it more reliable and secure. Moreover, the ABP Framework is compatible with multiple .NET frameworks, including ASP.NET and .NET Core. When starting your project on top of a solid Microsoft web framework, the ABP Framework is one of the best choices.

Another advantage of ABP Framework is that it provides rapid web application development tools that are easy to use. The framework includes project templates that developers can use as a starting point for their web applications, which can significantly reduce the development time. ABP Framework also provides a web app builder that developers can use to create web applications quickly and efficiently.

ASPNET Core Architecture

ABP Framework is also compatible with Microsoft's Clean Architecture, a software design pattern that promotes separation of concerns and maintainability. This integration ensures that the applications developed using ABP Framework are well-structured, easy to maintain, and scalable. Many application marketplace reviewers commented about ABP as the best web application framework. While ABP supports multiple UI choices like MVC, Angular, Blazor Web Assembly, and Blazor Server, the most downloaded one is MVC microservice architecture. If you are here to find a NET application framework for your next NET Core application, you are in the right place!

Clean Architecture is a design pattern emphasizing the separation of concerns, ensuring that the code is organized in independent layers. This helps developers to write code that is easy to maintain, test and refactor. ABP Framework uses this pattern to structure its application code and ensure it is easy to manage.

Open Source Web Framework

ABP Framework is an open-source web framework that is free to use and distribute. The framework is licensed under the MIT license, meaning developers can use it for commercial and non-commercial purposes without any restrictions.

ABP Framework provides different templates, which are ASPNET Core web app compatible with various platforms, including Windows, Linux, and macOS.

Domain Driven Design DotNet

The ABP Framework also implements Domain-Driven Design (DDD), a software design methodology that emphasizes the importance of the domain model. The framework provides a guide for implementing DDD through an implementing domain-driven design. It helps developers to create a domain model that is easy to understand, test, and maintain. As ABP is a C# framework, it supports most of the common application framework features for a core framework.

There is also a free PDF e-book for Dotnet developers that explains the Domain Driven Design principle with real-world examples. The book is written by the ABP Core Team. You can download this e-book at abp.io/books/implementing-domain-driven-design

You can also purchase the official Mastering ABP Framework book from Amazon. Check out amazon.com/Mastering-ABP-Framework-maintainable-implementing/dp/1801079242

It's a Dotnet Web Framework

ABP Framework is a dotnet web framework that is designed with C# and provides developers with a set of tools that makes it easy to build modern web applications. Whether you want to start a new dotnet monolithic solution or dotnet microservice solution, you can start with ABP. Creating your own dotnet framework architecture may be hard if you don't have many years of experience. The brain team of the ABP Framework specializes in ASP.NET framework architecture and ASP.NET application frameworks.

Essential Features of the ABP Framework:

ASP.NET Core modularity, ASP.NET Core modular development, ASP.NET Core localization, ASP.NET Core SaaS framework, ASP.NET Core distributed, event, bus, ASP.NET Core cross-cutting concerns, ASP.NET Core blob storing, ASP.NET Core audit logging, ASP.NET Core microservice, ASP.NET Core microservice solution, ASP.NET Core microservice example, ASP.NET Core API gateway, ASP.NET Core domain, driven, design, ASP.NET Core layered architecture, ASP.NET Core layering, ASP.NET Core clean architecture, ASP.NET Core authentication, ASP.NET Core authorization, ASP.NET Core UI theme, ASP.NET Core tag helpers, ASP.NET Core identity, ASP.NET Core, identity, server, ASP.NET Core IdentityServer, ASP.NET Core payment module, ASP.NET Core best practices, ASP.NET Core design patterns, ASP.NET Core background jobs, ASP.NET Core exception handling, ASP.NET Core, background, workers, ASP.NET Core repository, ASP.NET Core repository pattern, ASP.NET Core unit of work, ASP.NET Core domain services, ASP.NET Core Swagger, ASP.NET Core content management system, ASP.NET Core CMS module, ASP.NET Core user management, ASP.NET Core Role management, ASP.NET Core permission management

Open Source Web Application Framework

ABP Framework is an open-source web application development framework that is free to use and distribute. The framework is licensed under the MIT license, meaning developers can use it for commercial and non-commercial purposes without any restrictions.

C# Web Application Framework

ABP Framework is built using C#, which is a modern programming language that is widely used in the development of web applications. C# provides developers with features that make it easy to write clean and maintainable code. ABP Framework is a web framework designed to work with C# and provides developers with tools that make it easy to build modern web applications.

Key Features

The following .NET features are available in the ABP Framework:

.NET modular development, .NET localization, .NET multi-tenancy, .NET SaaS framework, .NET distributed event bus, .NET cross-cutting concerns, .NET, microservice, .NET microservice solution, .NET microservice example, .NET Domain Driven Design, .NET clean architecture, .NET authentication, .NET authorization, .NET best practices, .NET design patterns, .NET exception handling, .NET background workers, .NET unit of work, .NET domain services, .NET user management, .NET role management, .NET permission management

The following keywords best describe the ABP Framework;

Open source backend framework, open source development framework, open source web app builder, open source web applications, open source web development, web application development framework, web application framework, web application framework software, web application infrastructure, web application open source, asp net framework, asp net open source, ASP.NET application, ASP.NET software, ASP.NET web app, ASP.NET web development, web app builder open source, web app framework, Dotnet framework, Dotnet UI framework, Dotnet web application themes.

Conclusion

ABP Framework is a powerful and flexible web application framework that provides developers with the tools to build high-quality web applications quickly and efficiently. It is an open-source, cross-platform framework that supports multiple .NET frameworks, including ASP.NET and .NET Core. ABP Framework provides rapid web application development tools, project templates, and web application themes that enable developers to create visually appealing and functional applications in no time.

I'm Alper Ebicoglu 🧑🏽‍💻\

ABP Framework Core Team Member\

Follow me for the latest news about .NET and software development:\

📌 twitter.com/alperebicoglu\

📌 github.com/ebicoglu\

📌 linkedin.com/in/ebicoglu\

📌 medium.com/@alperonline

ABP Framework is a modular and extensible framework that uses clean architecture principles and is built on top of the latest .NET technologies. The framework comes with a set of pre-built modules, including user management, role management, permission management, and content management system (CMS) modules, which makes it easier for developers to create line of business applications.

Clean Architecture

When you want to start a new scratch project, you first google Dotnet Framework Architecture. There are some boilerplate dotnet startup templates, but these are only an orchestration of some popular tools. ABP is not a template, but it's a full stack open source application development framework.

When you say "Clean Architecture ASP.NET Core", the first web development framework that comes to mind is undoubtedly the ABP Framework. It is built using clean architecture principles, which help developers build scalable and maintainable applications. The clean architecture separates the application into distinct layers, each with a clear responsibility. The dotnet architecture layers include the presentation layer, application layer, domain layer, and infrastructure layer. Each layer has a clear responsibility, which helps in separating concerns and keeping the code organized. This makes ABP Framework one of the best asp net frameworks.

C# Web Framework for Web Development

ABP Framework is built using C#, which is a modern programming language that is widely used in the development of web applications. C# provides developers with a set of features that make it easy to write clean and maintainable code. ABP Framework is a web framework that is designed to work with C# and provides developers with a set of tools that makes it easy to build modern web applications. If you are looking for an ASP NET Core shared framework download, then go to https://abp.io/get-started and create your project.

Yet another ASP.NET Web Framework

There are a few full stack AspNet Core frameworks around. Many of them are one developer projects which can be risky for you to start a long running project. ABP Framework is built on top of the latest ASP NET Core Framework, which provides developers with a set of features that makes it easy to build modern web applications. And most important part is, ABP is backed with a large group of developers and it has almost 10K stars on GitHub. ASP.NET provides developers with a set of tools that makes it easy to build web applications using a model-view-controller (MVC) architecture.

Implementing Domain Driven Design with C#

ABP Framework provides developers with a set of tools that make it easy to implement domain-driven design principles. The framework comes with a set of pre-built modules, including user management, role management, permission management, and content management system (CMS) modules, which makes it easier for developers to create complex applications.

Open Source Web Application

ABP Framework is an open-source web application development framework that is free to use and distribute. The framework is licensed under the MIT license, meaning developers can use it for commercial and non-commercial purposes without any restrictions.

.NET Application Framework with Pre-Built Modules

ABP Framework is built using the latest .NET technologies and provides developers with a set of tools that makes it easy to build modern web applications. ABP contains several important modules of a line of business applications.

C# Microservice Framework

ABP Framework is a C# microservices framework that is designed to help developers build scalable and maintainable microservices. The framework is also known as .NET .net microservices framework. It provides developers with a set of tools that makes it easy to build microservices using clean architecture principles.

CRUD Tool Dotnet

ABP Framework has a commercial version as well. The paid version comes with premium support, rich themes and there's a very handy tool called ABP Suite for "CRUD page generation ASP.NET". While ABP is not a low-code or no-code platform, ABP Suite provides ASP NET rapid application development. There are many ASP.NET rapid development tools but only tools without a framework support. If you are looking for web based rapid application development tools (also open-source), ABP is the way to go!

Modular Development

One of the best sides of the ABP Framework is the modular development side. It's born as a modular system. There are several open source web frameworks around but many of them lack of modularity.

Let's see the key features of the ABP Framework:

• Multi-tenancy support

• Cross-cutting concerns implemented

• Full-stack microservice solution

• SaaS framework

• ASP.NET modular monolith

• Has an ASP.NET user management module

• Distributed events

• Layered architecture

• Free framework for website

• Several framework templates

The Essential Features of ABP

ABP Framework is an open source SaaS framework. This crucial feature distinguishes it from other open source web development frameworks.

The following essential ASP.NET features are available in the ABP Framework:

ASP.NET modularity, ASP.NET modular development, ASP.NET localization, ASP.NET multi-tenancy, ASP.NET SaaS, ASP.NET SaaS framework, ASP.NET distributed events, ASP.NET distributed event bus, ASP.NET cross-cutting concerns, ASP.NET blob storing, ASP.NET audit logging, ASP.NET microservice, ASP.NET microservice solution, ASP.NET microservice example, ASP.NET API gateway, ASP.NET domain driven design, ASP.NET layered architecture, ASP.NET layering, ASP.NET clean architecture, ASP.NET authentication, ASP.NET authorization, ASP.NET identity, ASP.NET identity server, ASP.NET IdentityServer, ASP.NET payment module, ASP.NET best practices, ASP.NET design patterns, ASP.NET background jobs, ASP.NET exception handling, ASP.NET background workers, ASP.NET repository, ASP.NET repository pattern, ASP.NET unit of work, ASP.NET domain services, ASP.NET swagger, ASP.NET content management system, ASP.NET user management, ASP.NET role management, ASP.NET permission management

Microservice Example: eShopOnAbp

eShopOnAbp is a microservice example built on top of ABP. It is a sample net application similar to Microsoft's eShopOnContainer project. It is a reference microservice solution built with the ABP Framework and .NET, runs on Kubernetes with Helm configuration and includes API Gateways, Angular and ASP.NET Core MVC applications with PostgreSQL and MongoDB databases. For more information, check out https://github.com/abpframework/eShopOnAbp.

⚠️ Important Notice

This project, "eshoponabp," is outdated. It served as a reference project for microservice architecture using the ABP Framework, but we now recommend using the ABP Microservice Solution Template for new projects.

The new template offers a modernized and officially supported starting point for building microservices with ABP. Please consider transitioning to the new template for the latest features and improvements.

Conclusion

In conclusion, ABP Framework is an open-source web development framework that offers many features and benefits for building modern and scalable web applications. Its modular and extensible architecture, implementation of Domain-Driven Design, and compatibility with various platforms make it a popular choice for developers. Whether you're building a web application, microservices, or modular monoliths, ABP Framework has everything you need to get started.

Whether you're building a dot net website, a web app infrastructure, or a webpage framework, open source web application frameworks are a cost-effective and flexible option for web development. If you are looking for an open source web application builder which contains a project framework template with web application development tools (open source), ABP Framework is the right choice.

I'm Alper Ebicoglu 🧑🏽‍💻\

ABP Framework Core Team Member\

Follow me for the latest news about .NET and software development:\

📌 twitter.com/alperebicoglu\

📌 github.com/ebicoglu\

📌 linkedin.com/in/ebicoglu\

📌 medium.com/@alperonline

In this post, I'll briefly mention the new features of .NET 8 and the changes.

dotnet publish and dotnet pack Release Mode 🏭

With this new version, dotnet publish and dotnet pack commands will build and pack with the Release mode. Before it was producing in Debug mode. To be able to produce in Debug mode, you need to set this parameter -p:PublishRelease as false.

dotnet publish -> /app/bin/Release/net8.0/app.dll
dotnet publish -p:PublishRelease=false -> /app/bin/Debug/net8.0/app.dll

System.Text.Json Serialization 🧱

System.Text.Json replaced Newtonsoft.Json in the recent versions. We are also using System.Text.Json in the ABP Framework now. There are several enhancements to object serialization and deserialization.

The latest version of the source generator now offers improved performance and reliability for Native AOT apps when used with ASP.NET Core. It also allows serializing types with required and init properties already supported in reflection-based serialization. Additionally, there is now an option to customize the handling of members that are not present in the JSON payload, see https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/missing-members. Support for serializing properties from interface hierarchies. The JsonNamingPolicy feature has been expanded to include new naming policies for snake_case and kebab-case property name conversions. Finally, JsonSerializerOptions.MakeReadOnly method allows for explicit control over when a JsonSerializerOptions instance is frozen, and you can check its status using the IsReadOnly property.

Randomness

AI programming is very popular these days. And the need to produce more random content arose.

GetItems() 🧮

Two new methods: Random.GetItems and RandomNumberGenerator.GetItems have been introduced that enable developers to randomly select a set number of items from a given input set. The example below demonstrates the usage of the System.Random.GetItems<T>() method using an instance obtained from the Random.Shared property to randomly insert 31 items into an array.

private static ReadOnlySpan<CountryPhoneCodePhoneCode> countries = new[]
{
    new CountryPhoneCode("Turkey", "90"),
    new CountryPhoneCode("China", "86"),
    new CountryPhoneCode("Germany", "49"),
    new CountryPhoneCode("Finland", "358"),
    new CountryPhoneCode("Spain", "34")
};

var randomValues = Random.Shared.GetItems(countries, 2);
foreach (var x in randomValues)
{
    Console.WriteLine(x.Name + " -> " + x.CountryPhoneCode);
}

/**************
- Output -
Germany -> 49
Finland -> 358
**************/

Shuffle() 🔀

If you need to randomize the order of a span in your application, you can take advantage of two new methods: Random.Shuffle and RandomNumberGenerator.Shuffle. These methods are particularly handy when you want to minimize the impact of training bias in machine learning by varying the order in which training and testing data are presented. Using these methods, you can ensure that the first thing in your dataset is only sometimes used for training, and the last is only sometimes reserved for testing.

var trainingData = GetData();
Random.Shared.Shuffle(trainingData);

IDataView source = mlContext.Data.LoadFromEnumerable(trainingData);

DataOperationsCatalog.TrainTestData splittedData = mlContext.Data.TrainTestSplit(source);
model = chain.Fit(splittedData.TrainSet);

IDataView resultPredictions = model.Transform(split.TestSet);

Performance Improvements 🚀

In .NET 8, various new types have been introduced to enhance application performance.

• The System.Collections.Frozen namespace in .NET 8 includes the FrozenDictionary and FrozenSet collection types. These types are designed to prevent changes to keys and values once a collection is created, resulting in faster read operations such as TryGetValue(). They are particularly useful for collections populated on first use and then persisted for a long-lived service.

  private static readonly FrozenDictionary<string, bool> frozenData = LoadConfigurationData().ToFrozenDictionary(optimizeForReads: true); 
  //////
  if (frozenData.TryGetValue(key, out bool setting) && setting) 
  {
  Process();
  }
  

• Buffers.IndexOfAnyValues is a new type in .NET 8, designed to be passed to methods that search for the first occurrence of any value in a passed collection. The new overloads of methods like String.IndexOfAny and MemoryExtensions.IndexOfAny accept an instance of the new type. When you create an instance of Buffers.IndexOfAnyValues, all the necessary data for optimizing subsequent searches is derived at that time.

• Text.CompositeFormat is a new type in .NET 8 useful for optimizing format strings that aren't known at compile time (such as format strings loaded from a resource file). While some extra time is spent upfront to perform tasks like parsing the string, it saves the work from being done each time the format string is used.

  private static readonly CompositeFormat range = CompositeFormat.Parse(Load());
  //////////
  static string GetMessage(int min, int max) =>
      string.Format(CultureInfo.InvariantCulture, range, min, max);
  

• In .NET 8, two new types are introduced to implement the fast XxHash3 and XxHash128 hash algorithms.

Improvements in System.Numerics and System.Runtime.Intrinsics 🔥

There are several enhancements made to the System.Numerics and System.Runtime.Intrinsics namespaces. These improvements include better hardware acceleration for Vector256, Matrix3x2, and Matrix4x4 in .NET 8.

Vector256 was redesigned to utilize 2x Vector128<T> operations internally to achieve partial acceleration of certain functions on Arm64 processors where Vector128.IsHardwareAccelerated == true but Vector256.IsHardwareAccelerated == false. The introduction of Vector512 is also included in .NET 8.

Additionally, the ConstExpected attribute has been added to hardware intrinsic to alert users when a non-constant value might cause unexpected performance issues.

Lastly, the Lerp(TSelf, TSelf, TSelf) API has been added to IFloatingPointIeee754, enabling the efficient and accurate linear interpolation of two values in float(Single), double (Double), and Half.

New Data Validation Attributes 🛡️

The DataAnnotations namespace, aimed specifically for validation in cloud-native services. The existing DataAnnotations validators are primarily used for validating user data, like form fields. However, the new attributes are meant to validate data, not entered by users, like configuration options. Apart from the new attributes, the RangeAttribute and RequiredAttribute types also received new properties.

• RequiredAttribute.DisallowAllDefaultValues: The attribute forces that structs for inequality with their default values.
• RangeAttribute.MinimumIsExclusive & RangeAttribute.MaximumIsExclusive: Specifies whether the allowable range includes its boundaries or not.
• DataAnnotations.LengthAttribute: Specifies the lower and upper limits for strings or collections using the Length attribute. For instance, the [Length(5, 100)] attribute specifies that a collection must have at least 5 elements and at most 100 elements.
• DataAnnotations.Base64StringAttribute: Validates a valid Base64 format.
• DataAnnotations.AllowedValuesAttribute & DataAnnotations.DeniedValuesAttribute: Specifies accepted allow lists or not allowed deny lists. For instance: [AllowedValues("red", "green", "blue")] or [DeniedValues("yellow", "purple")].

Function Pointers Introspection Support ↩️

Function pointers were released with .NET 5. There was no support for reflection at that time. As a result, using typeof or reflection on a function pointer, such as typeof(delegate*<void>()) or FieldInfo.FieldType, respectively, would return an IntPtr. However, in .NET 8, a System.Type object is returned instead, providing access to function pointer metadata, such as calling conventions, return type, and parameters. This functionality is implemented only in the CoreCLR runtime and MetadataLoadContext.

Native AOT 🏭

The publishing as native AOT was initially introduced in .NET 7, the option to publish an application as native AOT enables the creation of a self-contained version of the app that does not require a separate runtime, bundling everything into a single file.

In .NET 8, the support for native AOT now encompasses the x64 and Arm64 architectures on macOS. Moreover, native AOT applications on Linux are now up to 50% smaller in size. Here's the table, illustrates the size of a minimal app published with native AOT, containing the entire .NET runtime:

• Linux x64 (with -p:StripSymbols=true)
  • .NET 7 ➡ 3.76MB
  • .NET 8 ➡ 1.84 MB
• Windows x64
  • .NET 7 ➡ 2.85 MB
  • .NET 8 ➡ 1.77 MB

Code Generation Improvements 📃

.NET 8 includes enhancements to code generation and just-in-time (JIT) compilation:

• JIT throughput improvements
• Arm64 performance improvements
• Profile-guided optimization (PGO) improvements
• Support for AVX-512 ISA extensions
• SIMD improvements
• Cloud-native improvements
• Loop and general optimizations

.NET 8 DevOps Improvements 📦

NET Container Image Changes

There are some changes with .NET 8 on image containers. First, Debian 12 is the default Linux distribution in the container images.

Secondly, the images include a non-root user to make the images non-root capable. To run as non-root, add the line USER app at the end of your Dockerfile.

Besides, the default port has also changed from 80 to 8080 and a new environment variable ASPNETCORE_HTTP_PORTS is available to change ports easily.

Also, the format for the ASPNETCORE_HTTP_PORTS variable is easier compared to the format required by ASPNETCORE_URLS, and it accepts a list of ports. If you change the port back to 80 using one of these variables, it won’t be possible to run as non-root.

Finally, .NET 8 is now supported on Chiseled Ubuntu images, available at the [Ubuntu/DotNet-deps Docker Hub](Ubuntu/DotNet-deps Docker Hub). Chiseled images are designed to have a smaller attack surface as they are stripped down to be ultra-compact, and do not include a package manager or shell. Chiseled images are non-root, making them ideal for developers looking for the benefits of appliance-style computing. These images are regularly published to the .NET nightly artifact registry for easy access.

Building Your .NET on Linux

Previously, building .NET from source in earlier versions required creating a source tarball from the corresponding release commit in the [dotnet/installer repository](dotnet/installer repository). However, in .NET 8, this step is no longer necessary as the dotnet/dotnet repository allows building .NET directly on Linux using dotnet/source-build to create runtimes, tools, and SDKs. Red Hat and Canonical also use this build for .NET. Building in a container is the easiest approach for most people since the dotnet-buildtools/prereqs container images have all the necessary dependencies. The build instructions provide more information.

Minimum support baselines for Linux

The support requirements for Linux have been updated for .NET 8, with changes to the minimum support baselines:

1. All architectures will target Ubuntu 16.04 for building .NET, which is important for setting the minimum required version of glibc for .NET 8. Versions of Ubuntu earlier than 16.04, such as 14.04, will not even allow .NET 8 to start.
2. Red Hat Enterprise Linux 7 is no longer supported with .NET 8. Only supporting RHEL 8 and later.

For further details, please refer to the support for Red Hat Enterprise Linux Family page.

Become a pioneer and try the new features of .NET 8 now. Adapt it to your project or start a new .NET 8 project. Claim your copy of .NET 8 today 🏎️ !

〰️〰️〰️

Happy Coding ⌨️

I'm Alper Ebicoglu 🧑🏽‍💻 ABP Framework Core Team Member Follow me for the latest news about .NET and software development: 📌 twitter.com/alperebicoglu 📌 github.com/ebicoglu 📌 linkedin.com/in/ebicoglu 📌 medium.com/@alperonline

In this article, I'll show you all the object mapping strategies of EF Core and especially the new one: TPC Inheritance Mapping. TPC mapping is the new feature introduced with Entity Framework Core 7. It's called Table Per Concrete type inheritance mapping. I'll explain the EF Core's inheritance mapping strategies with how the inherited entity and the specific information are saved into a relational database. I'll also explain which strategy is best for your case.

By default, EF Core maps an inheritance hierarchy of .NET types to a single database table. And it's called TPH (table-per-hierarchy) mapping.

In the previous versions EF Core , Table Per Hierarchy (TPH) or Table Per Type (TPT) were supported. And now TPC came!

To explain in a more clear way, I'll use the following entity model. Car, Bus and Motorcylce are inherited from the Vehicle object.

public abstract class Vehicle
{
    public int Id { get; set; }
    public string VehicleModel { get; set; }
}

//////////////////////////////////////

public class Car : Vehicle
{
    public string Segment { get; set; }
}

//////////////////////////////////////

public class Bus : Vehicle
{
    public int? SeatCount { get; set; }
}

//////////////////////////////////////

public class Motorcycle : Vehicle
{
    public int CylinderCount { get; set; }
}

Here's the list of available strategies to map Car, Bus and Motorcylce:

TPH (Table Per Hierarchy)

TPH maps an inheritance hierarchy of .NET types to a single database table. So a single table is created for all types. This is the default behavior of EF Core. If you explicitly want to use this strategy, you can write UseTphMappingStrategy() to the root entity in the OnModelCreating() method in the DbContext class. As you see from the following table, it adds an extra column, Discriminator to separate the Car, Bus and Motorcycle. This way of persistence is an unnormalized form.

CREATE TABLE [Vehicles] (
    [Id] int NOT NULL IDENTITY,   
    [Discriminator] nvarchar(max) NOT NULL,  -- "Car", "Bus", "Motorcylce"
    [VehicleModel] nvarchar(max) NOT NULL,
    [Segment] nvarchar(max) NULL,
    [SeatCount] int NULL,
    [CylinderCount] int NOT NULL
);

TPT (Table per Type)

With the TPT strategy, a different table is created for every type. The table itself is used to determine the type of the object saved, and each table contains only columns for the properties of that type. The data is saved in multiple tables, and this way of persistence is normalized form.

CREATE TABLE [Vehicles] (
    [Id] int NOT NULL IDENTITY,
    [VehicleModel] nvarchar(max) NOT NULL
); 

CREATE TABLE [Car] (
    [Id] int NOT NULL,
    [Segment] nvarchar(max) NULL
);

CREATE TABLE [Bus] (
    [Id] int NOT NULL,
    [SeatCount] int NULL,
);

CREATE TABLE [Motorcycle] (
    [Id] int NOT NULL,
    [CylinderCount] int NOT NULL
);

If you explicitly want to use this strategy, you can write UseTptMappingStrategy() to the root entity in the OnModelCreating() method in the DbContext class.

TPC (Table Per Concrete type)

It's the new strategy that has been introduced with EF Core 7. In this way, a different table is created for each concrete type. While in the TPT, the table itself indicates the type of the object saved, in TPC, each table contains columns for every property in the concrete type and its base types. As you see from the following tables, no Vehicles table is being created. The VehicleModel field is common in each table.

CREATE TABLE [Car] (
    [Id] int NOT NULL DEFAULT (NEXT VALUE FOR [VehicleIds]),
    [VehicleModel] nvarchar(max) NOT NULL, -- common field for each type
    [Segment] nvarchar(max) NULL
);

CREATE TABLE [Bus] (
    [Id] int NOT NULL DEFAULT (NEXT VALUE FOR [VehicleIds]),
    [VehicleModel] nvarchar(max) NOT NULL, -- common field for each type
    [SeatCount] int NULL 
);

CREATE TABLE [Motorcycle] (
    [Id] int NOT NULL DEFAULT (NEXT VALUE FOR [VehicleIds]),
    [VehicleModel] nvarchar(max) NOT NULL, -- common field for each type
    [CylinderCount] int NOT NULL
);

This strategy maps each .NET type to a different database table. You write UseTpcMappingStrategy() to the root entity in the root entity in the OnModelCreating() method in the DbContext class.

How do you choose which mapping type is best for you?

• TPH: In most cases, the TPH mapping is a good choice which is the default one. This way, the table columns increase because all the properties are saved in the same table, but it's easy to query in a single table.

• TPT In this form, data is persisted in a normalized form. For this reason, you can choose TPT, but generally, it's not being used. But the disadvantage is when you filter by VehicleModel column, it must join Vehicles, Bus, Car, Motorcycle tables. So it's not a feasible fetching way.

• TPC: This new strategy is similar to TPT but resolves some of the TPT problems. Because it stores the data in its own table, it doesn't divide across multiple tables. This option can be chosen when the mapped hierarchy is large and has many concrete types, each with many properties.

For example, if Car, Bus, or Motorcycle have 20 properties for each type, then it's better to store them in a separate table, so we should use TPC. But if these entities have only 3-5 properties, then TPH is the way to go.

Jeremy Likness says;

• If your code mostly queries entities of a single leaf type, then use TPC because the storage requirements are smaller since there are no null columns and no discriminator no index is ever needed on the discriminator column, which would slow down updates and possibly also queries. An index may not be needed when using TPH either, but that depends on various factors. If your code mostly queries for entities of many types, such as writing queries against the base type, lean towards TPH. If your database system supports it (for example SQL Server), then consider using sparse columns for columns that will be rarely populated. Use TPT only if constrained to do so by external factors.

References:

• https://devblogs.microsoft.com/dotnet/announcing-ef7-preview5/#primary-keys

A new .NET version has come. As open-source contributors, we are tracking the latest libraries and adopting them to our existing projects. In this sense, we completed our .NET 7 upgrade in our repositories for ABP Framework and ABP Commercial. In this article, I'll share the experiences we faced while upgrading to the new .NET version 👉 .NET 7.

When I wrote this article, the latest .NET version was 7.0.0-rc.2. So some of the version statements I wrote below must be changed due to the stable version release.

To see the latest and greatest stuff, let's see how to upgrade our existing projects to .NET 7!

Install .NET7 SDK

If you are on your development computer, then you need to install the .NET7 SDK 7.x.x. For the production servers, you need to install the .NET 7 runtime. Download link for the .NET7 SDK and runtime is:

• https://dotnet.microsoft.com/en-us/download/dotnet/7.0

Update Your *.csproj Files

First, you need to update all your *.csproj files to support .NET7. Find and replace all your <TargetFramework>*</TargetFramework> in the *.csproj files to support .NET 7:

<TargetFramework>net7.0</TargetFramework>

We already did this in ABP Framework, see this commit as an example github.com/abpframework/abp/templates/app-nolayers/aspnet-core/MyCompanyName.MyProjectName.Mvc.csproj.

Microsoft Package Updates

You must be using Microsoft packages as well; then you need to update them to the latest .NET 7 version. At the time, I wrote this article, the latest version was 7.0.0-rc.2.22476.2, so I'll update them to this version including minor version changes.

Here's the list of all package reference updates I did:

<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Authentication" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="7.0.0-rc.2.*" />

<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.0-rc.2.*">
<PackageReference Include="Microsoft.EntityFrameworkCore.Proxies" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.0-rc.2.*">
    
<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.FileProviders.Composite" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Http" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Identity.Core" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Localization" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0-rc.2.*" />
    
<PackageReference Include="System.Text.Encoding.CodePages" Version="7.0.0-rc.2.*" />
<PackageReference Include="System.Text.Encodings.Web" Version="7.0.0-rc.2.*" />
<PackageReference Include="System.Text.Json" Version="7.0.0-rc.2.*" /> 

<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="7.0.0-rc.2.*" />
<PackageReference Include="System.Collections.Immutable" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="7.0.0-rc.2.*" />
<PackageReference Include="Microsoft.Data.Sqlite" Version="7.0.0-rc.2.*" />

Entity Framework Core Updates

If you use EF Core as your data access library, you should update your dotnet-ef CLI tool. Here's the terminal command to update it:

dotnet tool update dotnet-ef --global --prerelease

We already did the the EF Core package reference update in the Microsoft Package Updates section.

Breaking Change: OrderBy

This release makes a breaking change in an EF Core query running behavior. We faced this issue in some of our queries that were missing OrderBy statement. It throws an exception and does not run the query. Here's the explanation of a EF Core team member for this issue: github.com/dotnet/efcore/issues/21202#issuecomment-913206415.

The following exception is being thrown:

InvalidOperationException: The query uses 'Skip' without specifying ordering and uses split query mode. This generates incorrect results. Either provide ordering or run query in single query mode using AsSingleQuery(). See https://go.microsoft.com/fwlink/?linkid=2196526 for more information

If you don't want to add OrderBy statement to solve the issue, you can also use AsSingleQuery().

EF Core - SQL Client Connection String Update

With this version, the behavior of the SQL connection has been changed. There is a keyword in the SQL connection string called TrustServerCertificate. This keyword indicates whether the channel will be encrypted while bypassing walking the certificate chain to validate trust.

When TrustServerCertificate is set to True, the transport layer will use SSL to encrypt the channel and bypass walking the certificate chain to validate trust. If TrustServerCertificate is set to true and encryption is turned on, the encryption level specified on the server will be used even if Encrypt is set to false. The connection will fail otherwise.

After the .NET7 update, it just started to throw the following exception:

A connection was successfully established with the server, but then an error occurred during the login process.

We fixed this problem by adding the TrustServerCertificate=true to your connection string. Here's an example connection string that supports,

Server=localhost; Database=MyProjectName; Trusted_Connection=True; TrustServerCertificate=True

See our commit for this fix:

• github.com/abpframework/abp/commit/96f17e67918eb87edd2baf876d4a7598281fe608

Related docs:

• learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-7.0/breaking-changes#encrypt-true
• stackoverflow.com/questions/34430550/a-connection-was-successfully-established-with-the-server-but-then-an-error-occ

Blazor Update

Ensure that you have updated your Blazor project's csproj to support .NET7:

<TargetFramework>net7.0</TargetFramework>

Install Blazor Workloads

.NET Web Assembly build tools

If you have a Blazor-WASM project, install the workloads by running the following in a command shell:

dotnet workload install wasm-tools

OR you can update your workloads by running the following command in your Blazor project directory:

dotnet workload restore

.NET MAUI Update

Ensure that you have updated your Blazor project's csproj to support .NET7:

<TargetFrameworks>net7.0-android;net7.0-ios;net7.0-maccatalyst</TargetFrameworks>
<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net7.0-windows10.0.19041.0</TargetFrameworks>

Install MAUI Workloads

If you have .NET MAUI project, then you also need to update your TargetFramework as below:

If you have a .NET MAUI project, after installing the .NET 7 SDK, install the latest workloads with the following command:

dotnet workload install maui

OR run the following command in your existing .NET MAUI project directory

dotnet workload restore

Further information, check out https://github.com/dotnet/maui/wiki/.NET-7-and-.NET-MAUI

Dotnet Maui Check Tool

Alternatively, there's a 3rd party tool for .NET MAUI to install the required workloads. This tool installs the missing SDK packs. You can reach the tool's repository at github.com/Redth/dotnet-maui-check.

Installation:

dotnet tool install -g Redth.Net.Maui.Check

Run:

maui-check

Docker Image Update

If you are using Docker to automate the deployment of applications, you also need to update your images. We were using aspnet:6.0.0-bullseye-slim base and after the .NET 7 update, we started using aspnet:7.0-bullseye-slim in our Docker files.

FROM mcr.microsoft.com/dotnet/aspnet:7.0-bullseye-slim AS base

For this update, you can check out the following commit as an example:

• github.com/abpframework/abp/commit/2d07b9bd00152bef4658c48ff9b2cbee5788d308

ABP Framework .NET 7 Update

In ABP Framework repository, we updated all our dependencies from .NET 6 to .NET 7. Not all the changes are here, but you can check out the following PR of the .NET 7 update:

• github.com/abpframework/abp/pull/13626/files

〰️〰️〰️

Happy Coding 🤗

I'm Alper Ebicoglu 🧑🏽‍💻 ABP Framework Core Team Member Follow me for the latest news about .NET and software development: 📌 twitter.com/alperebicoglu

📌 github.com/ebicoglu

📌 linkedin.com/in/ebicoglu

📌 medium.com/@alperonlinehttps://medium.com/@alperonline)\

This is a simple Windows Service built on the ABP Framework (open source) (.NET5 and ABP 4.4.2). The Windows Service uses a local SQL database.

Project Structure:

• AbpWindowsService: This is the Windows Service. You will install this service as Windows Service.
• AbpWindowsService.DbMigrator: You can create your database and update it with DbMigrator.
• AbpWindowsService.Domain: Your domain objects like your entities are in this project.
• AbpWindowsService.Domain.Shared: Shared objects like your entity consts, enums are in this project.
• AbpWindowsService.EntityFrameworkCore: The EFCore referenced project has DbContext and Migrations.

For more information see https://docs.abp.io/en/commercial/latest/startup-templates/application/solution-structure

How to install and run?

Clone this repository to your disk.

Build the solution.

Run the DbMigrator project to create the database.

Start a command prompt as an administrator and run install-service.bat. This will install the Window Service. Your service name will be AbpWindowsService. You can change the service name from this code line.

The database connection string is

Server=(LocalDb)\\MSSQLLocalDB;Database=MyDatabase;Trusted_Connection=True

The Trusted_Connection allows connecting the database with your active Windows user account. But the default user account for Windows Services is a local System user. Therefore you need to set your active account to the service. To do this; Open the Services window by running C:\Windows\System32\services.msc and right-click your service, go to "Properties". Go to the "LogOn" tab, choose "This Account" and write your username & password. To learn your logon username, start a command prompt and write whoami.

Start the service. And that's it!

To check if it's working, open the following logfile

 src\AbpWindowsService\bin\Debug\net5.0\win-x64\Logs\Log.txt

I already added 4 database records (books) with the data seeder, so you'll see the following lines in the logs when the service starts. These are the records fetched from the Books table.

[INF] *** Book name: George Orwell 1984
[INF] *** Book name: Lord of the Flies
[INF] *** Book name: Harry Potter
[INF] *** Book name: The Great Gatsby

How to uninstall?

Start a command prompt as an administrator and run uninstall-service.bat. This will uninstall the Window Service. This batch runs the following operations:

• Stops the service if it's running
• Closes mmc.exe if it's open. (because the service cannot be uninstalled if this window is open)
• Removes service with sc delete command

Creating your own Windows Service in .NET CORE using ABP Framework

Create an ABP console application

To create your own Windows Service, you can start with creating an ABP console application with the following command:

abp new AbpWindowsService -t console -csf

Add Windows Service middleware

Add the Microsoft.Extensions.Hosting.WindowsServices package to your console application by adding the following line to the csproj:

<PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="5.0.1" />

Open the Program.cs and add the UseWindowsService() to CreateHostBuilder method. You can also set a service name to be shown in the services window.

  Host.CreateDefaultBuilder(args)
  .UseAutofac()
  .UseSerilog()
  .UseWindowsService(x => x.ServiceName = "AbpWindowsService") //// add this line /////
  .ConfigureAppConfiguration((context, config) =>
  {
      //setup your additional configuration sources
  })
  .ConfigureServices((hostContext, services) =>
  {
  services.AddApplication<AbpWindowsServiceModule>();
  });

UseWindowsService makes 3 things:

• Sets the host lifetime to WindowsServiceLifetime
• Sets the Content Root
• Enables logging to the event log with the application name as the default source name

Set log file path

By default, Windows Service runs as a local System account and Serilog will write the logs under C:\Windows\System32. To overcome this, you can set the log file as the static path. The below code lets Serilog write to the Logs folder under your Windows Service installation directory.

Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Async(c => c.File(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Logs/Log.txt")))
.CreateLogger();

Write your business logic

In your Windows Service, there is an ABP module class AbpWindowsServiceModule.cs. This class adds the hosted service *HostedService.cs. Hosted service is an implementation of IHostedService. It has StartAsync() and StopAsync() methods. StartAsync the method will run when you start your Windows Service and StopAsync will run when you stop your Windows Service. The application will not end unless you stop it. You can create a domain service from IDomainService. And write your code in this domain service. Call your method inside the Hosted Service StartAsync method. Dependency Injection will work without any problem as long as you implement your classes from ITransientDependency or ISingletonDependency.

Accessing the database

To access your database and repositories you can move your Windows Service into your main ABP Web Application solution. To do this, copy the service project to the src folder of your main web solution. Add project reference of *.EntityFrameworkCore project to your Windows Service as shown below:

<ProjectReference Include="..\AbpWindowsService.EntityFrameworkCore\AbpWindowsService.EntityFrameworkCore.csproj" />

Add the DependsOn attribute of EntityFramework module to your Windows Service as shown below:

 [DependsOn(
    typeof(AbpAutofacModule),
    typeof(AbpWindowsServiceEntityFrameworkCoreModule)) /// added this line ///
 ]
 public class AbpWindowsServiceModule : AbpModule
 {
      //....
 }

Now you can inject your repositories into your domain service.

Don't forget to add the database connection string to the appsettings.json of your Windows Service.

{
  "ConnectionStrings": {
    "Default": "Server=(LocalDb)\\MSSQLLocalDB;Database=MyDatabase;Trusted_Connection=True"
  }
}

Note that we are using Trusted_Connection=True which means, Windows Authentication (the active Windows user) will be used.

Trusted_Connection=True will cause a small problem! The default user of a Windows Service is local System account. Therefore you cannot connect your database with the System account. To solve this, apply the 5th step of How to install and run? section in this document. Alternative way; You can create a user in your database and use the UserId-Password credential in the connection string.

And you are ready to install your new service! See the How to install and run? section to install your new service.

Click here to download the sample project

And happy coding!

SignalR is an open source library that adds real-time operation functionality to applications. Real-time web functionality enables server-side code to instantly send content to clients without refreshing the page. I'll show you how to add SignalR and use it to send notifications from backend. I'll implement this functionality in MVC template of ABP Framework.

Implement Backend

Create Notification Hub

Create a new folder named SignalR in your root directory of your Web project.

Then add the following classes to the folder:

1. INotificationClient.cs
2. UiNotificationClient.cs
3. UiNotificationHub.cs

Configure Module

These 3 steps will be done in your web module class.

1- Add SignalR

Open YourProjectWebModule.cs class and add the following line to the PreConfigureServices method:

 context.Services.AddSignalR();

2- Add Client Scripts

2- In the ConfigureServices method of your web module add the following code to add the signalr.js and notification-hub.js. We'll add these packages in the next steps. If you are not using Lepton Theme you can add the files to StandardBundles.Scripts.Global.

 Configure<AbpBundlingOptions>(options =>
  {
      options
          .ScriptBundles
          .Get(LeptonThemeBundles.Scripts.Global) //or -> Volo.Abp.AspNetCore.Mvc.UI.Theme.Shared.Bundling.StandardBundles.Scripts.Global
          .AddFiles("/libs/signalr/signalr.js")
          .AddFiles("/Pages/notification-hub.js");
  });

3- Add Hub Endpoint

Add the following code to add the notification hub endpoint in OnApplicationInitialization method:

app.UseEndpoints(endpoints =>
{
   endpoints.MapHub<UiNotificationHub>("/notification-hub");
});

Implement Frontend

We'll write the client-side code to be able to handle the SignalR response.

1- Add Notification Hub

Add the following JavaScript class into your Pages folder in your Web project. We already added this script to our global scripts.

notification-hub.js

2- Add SignalR NPM package

Add Microsoft.SignalR JavaScript package to the package.json which is located in your root folder of the Web project. After you add it, run yarn command in your Web directory to be able to install this package.

You can install the latest version (3.1.13 will be old)

  "@microsoft/signalr": "^3.1.13"

3- Add resource Mapping

We added SignalR to the package.json but it comes into your node_modules folder. We need to copy the related files to wwwroot/libs folder. To do this copy the content of the following file to your abp.resourcemappings.js file. It's in your root directory of Web folder. After you do this, go to your web directory and run abp install-libs command. By doing this, it'll copy the related files into your wwwroot/libs folder.

abp.resourcemappings.js

4- Usage

We have completed the implementation part. Let's check if it's running... We will show the current time which comes from server. To do this replace the Index.cshtml and Index.cshtml.cs with the followings:

• Index.cshtml

• Index.cshtml.cs

5- See it in action

Run your web project and in the Index page you'll Server Time will be updated every second. The time information comes from backend via SignalR. This is a very basic usage of SignalR notification system. You can implement your own SignalR notification system based on your requirements.

Introduction

ABP Suite, a part of the ABP Commercial, is a productivity tool developed by the team behind the ABP Framework. The main functionality of the ABP Suite is to generate code for you.

In this post, I'll show you how to add the user entity as a navigation property in your new entity, by the help of the ABP Suite.

In the sample project MVC UI is used, but the same steps are applicable to the Angular UI as well.

Code Generation

Create a New Entity

Open the ABP Suite (see how). Create a new entity called Note, as an example entity.

Then add a string property called Title, as an example property.

Create AppUserDto

Note that, creating AppUserDto is not necessary after ABP v4.X

ABP Suite needs a DTO for the target entity (user, in this case) in order to define a navigation property.

To do this, create a new folder called "Users" in *.Application.Contracts then add a new class called AppUserDto inherited from IdentityUserDto.

We should define the object mapping to be able to convert the AppUser objects to AppUserDto objects. To do this, open YourProjectApplicationAutoMapperProfile.cs and add the below line:

CreateMap<AppUser, AppUserDto>().Ignore(x => x.ExtraProperties);

Creating such a DTO class may not be needed for another entity than the AppUser, since it will probably be already available, especially if you had created the other entity using the ABP Suite.

Define the Navigation Property

Get back to ABP Suite, open the Navigation Properties tab of the ABP Suite, click the Add Navigation Property button. Browse AppUser.cs in *.Domain\Users folder. Then choose the Name item as display property. Browse AppUserDto.cs in *.Contracts\Users folder. Choose Users from Collection Names dropdown.

Generate the Code!

That's it! Click Save and generate button to create your page. You'll see the following page if everything goes well.

This is the new page that has been created by the ABP Suite. It can perform the fundamental CRUD operations. Also, it has the "App user" column that shows the related user name (you can easily change the automatically created "App user" title from the Entity Name field of the navigation property creation screen).

Picking Users from Look Up Table

We used dropdown element to select a user from the user list. If you have a lot of users, then it's good to pick a user from a look up table. A look up table is a modal window that lets you filter data and pick one. To do this, get back to Suite and click Edit button of user navigation which is set as AppUserId name. Choose "Modal" from the "UI Pick Type" field. Then click Save and generate button to recreate your page.

After successful code generation, you'll see the the user can be picked from user table.

About the ABP Commercial RC

This example has been implemented with ABP Commercial 3.1.0. If you have not installed the ABP CLI and ABP Suite, follow the next steps:

1- Uninstall the current version of the CLI and install:

dotnet tool install --global Volo.Abp.Cli --version 3.1.0

2- Uninstall the current version of the Suite and install:

dotnet tool uninstall --global Volo.Abp.Suite && dotnet tool install -g Volo.Abp.Suite --version 3.1.0 --add-source https://nuget.abp.io/<YOUR-API-KEY>/v3/index.json

Don't forget to replace the <YOUR-API-KEY> with your own key!

Introduction

When you use HTTP on your Identity Server 4 enabled website, users may not login because of the changes made by Chrome in the version 8x. This occurs when you use HTTP schema in your website. The issue is explained here https://docs.microsoft.com/en-gb/dotnet/core/compatibility/3.0-3.1#http-browser-samesite-changes-impact-authentication

How to solve it?

Step-1

Create the below extension in your *.Web project.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;

namespace Microsoft.Extensions.DependencyInjection
{
    public static class SameSiteCookiesServiceCollectionExtensions
    {
        public static IServiceCollection AddSameSiteCookiePolicy(this IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                options.MinimumSameSitePolicy = SameSiteMode.Unspecified;
                options.OnAppendCookie = cookieContext => 
                    CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
                options.OnDeleteCookie = cookieContext => 
                    CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
            });

            return services;
        }
        
        private static void CheckSameSite(HttpContext httpContext, CookieOptions options)
        {
            if (options.SameSite == SameSiteMode.None)
            {
                var userAgent = httpContext.Request.Headers["User-Agent"].ToString();
                if (!httpContext.Request.IsHttps || DisallowsSameSiteNone(userAgent))
                {
                    // For .NET Core < 3.1 set SameSite = (SameSiteMode)(-1)
                    options.SameSite = SameSiteMode.Unspecified;
                }
            }
        }

        private static bool DisallowsSameSiteNone(string userAgent)
        {
            // Cover all iOS based browsers here. This includes:
            // - Safari on iOS 12 for iPhone, iPod Touch, iPad
            // - WkWebview on iOS 12 for iPhone, iPod Touch, iPad
            // - Chrome on iOS 12 for iPhone, iPod Touch, iPad
            // All of which are broken by SameSite=None, because they use the iOS networking stack
            if (userAgent.Contains("CPU iPhone OS 12") || userAgent.Contains("iPad; CPU OS 12"))
            {
                return true;
            }

            // Cover Mac OS X based browsers that use the Mac OS networking stack. This includes:
            // - Safari on Mac OS X.
            // This does not include:
            // - Chrome on Mac OS X
            // Because they do not use the Mac OS networking stack.
            if (userAgent.Contains("Macintosh; Intel Mac OS X 10_14") && 
                userAgent.Contains("Version/") && userAgent.Contains("Safari"))
            {
                return true;
            }

            // Cover Chrome 50-69, because some versions are broken by SameSite=None, 
            // and none in this range require it.
            // Note: this covers some pre-Chromium Edge versions, 
            // but pre-Chromium Edge does not require SameSite=None.
            if (userAgent.Contains("Chrome/5") || userAgent.Contains("Chrome/6"))
            {
                return true;
            }

            return false;
        }
    }
}

Step-2

Assume that your project name is Acme.BookStore. Then open AcmeBookStoreWebModule.cs class.

Add the following line to ConfigureServices() method.

 context.Services.AddSameSiteCookiePolicy(); // cookie policy to deal with temporary browser incompatibilities

Step-3

Go toOnApplicationInitialization() method in AcmeBookStoreWebModule.cs add app.UseCookiePolicy();

public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
        var app = context.GetApplicationBuilder();
        var env = context.GetEnvironment();

        if (env.IsDevelopment())
        {
                app.UseDeveloperExceptionPage();
        }
        else
        {
                app.UseErrorPage();
                app.UseHsts();
        }

        app.UseCookiePolicy(); // added this, Before UseAuthentication or anything else that writes cookies.
	
	//....
}

It's all! You are ready to go!

Attention: This problem can't be solved if the user/browser/operating system blocked third-party cookies.

Referenced from https://devblogs.microsoft.com/aspnet/upcoming-samesite-cookie-changes-in-asp-net-and-asp-net-core/

Introduction

In this tutorial, we will show you how to add a custom token provider to authenticate a user with a link, instead of entering the password.

This can be useful especially if you want to make someone login to the application with your user, without sharing your secret password. The generated link will be for a single use.

Source Code

The completed sample is available on GitHub repository.

Creating the Solution

Before starting the development, create a new solution named PasswordlessAuthentication and run it by following the getting started tutorial.

Step-1

Create a class named PasswordlessLoginProvider in your *.Web project:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Identity;

namespace PasswordlessAuthentication.Web
{
    public class PasswordlessLoginProvider<TUser> : TotpSecurityStampBasedTokenProvider<TUser>
        where TUser : class
    {
        public override Task<bool> CanGenerateTwoFactorTokenAsync(UserManager<TUser> manager, TUser user)
        {
            return Task.FromResult(false);
        }

        //We need to override this method as well.
        public async override Task<string> GetUserModifierAsync(string purpose, UserManager<TUser> manager, TUser user)
        {
            var userId = await manager.GetUserIdAsync(user);

            return "PasswordlessLogin:" + purpose + ":" + userId;
        }
    }
}

Step-2

Create IdentityBuilderExtensions.cs in your *.Web project. We will use this extension method in the ConfigureServices.

using Microsoft.AspNetCore.Identity;

namespace PasswordlessAuthentication.Web
{
    public static class IdentityBuilderExtensions
    {
        public static IdentityBuilder AddPasswordlessLoginProvider(this IdentityBuilder builder)
        {
            var userType = builder.UserType;
            var totpProvider = typeof(PasswordlessLoginProvider<>).MakeGenericType(userType);
            return builder.AddTokenProvider("PasswordlessLoginProvider", totpProvider);
        }
    }
}

Step-3

Add the token provider to the Identity middleware. To do this, find the module class (eg: PasswordlessAuthenticationWebModule.cs in here) in your *.Web project and add the below into the ConfigureServices() method.

public override void ConfigureServices(ServiceConfigurationContext context)
{
	//...
	context.Services
		.GetObject<IdentityBuilder>()
		.AddDefaultTokenProviders()
		.AddPasswordlessLoginProvider();
}

Step-4

We need to create a user interface to be able to generate the magic login link. To do this quickly, open your existing Index.cshtml.cs in your *.Web project. It's under Pages folder. And copy-paste the below content.

Index.cshtml.cs

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.Identity;

namespace PasswordlessAuthentication.Web.Pages
{
    public class IndexModel : PasswordlessAuthenticationPageModel
    {
        protected IdentityUserManager UserManager { get; }

        private readonly IIdentityUserRepository _userRepository;

        public string PasswordlessLoginUrl { get; set; }

        public string Email { get; set; }

        public IndexModel(IdentityUserManager userManager, IIdentityUserRepository userRepository)
        {
            UserManager = userManager;
            _userRepository = userRepository;
        }

        public ActionResult OnGet()
        {
            if (!CurrentUser.IsAuthenticated)
            {
                return Redirect("/Account/Login");
            }

            return Page();
        }

        //added for passwordless authentication
        public async Task<IActionResult> OnPostGeneratePasswordlessTokenAsync()
        {
            var adminUser = await _userRepository.FindByNormalizedUserNameAsync("admin");

            var token = await UserManager.GenerateUserTokenAsync(adminUser, "PasswordlessLoginProvider",
                "passwordless-auth");

            PasswordlessLoginUrl = Url.Action("Login", "Passwordless",
                new {token = token, userId = adminUser.Id.ToString()}, Request.Scheme);

            return Page();
        }
    }
}

We added OnPostGeneratePasswordlessTokenAsync() action to generate the link. We will generate a link for the admin user. Therefore, we injected IIdentityUserRepository to get admin user Id. Using the UserManager.GenerateUserTokenAsync() method, we generated a token. After that, we created the URL with the admin user Id and the token. Now we will show the PasswordlessLoginUrl on the page.

Step-5

Create a class named PasswordlessAuthenticationMenus under Menus folder in your *.Web project. And set the content as below.

namespace PasswordlessAuthentication.Web.Menus
{
    public class PasswordlessAuthenticationMenus
    {
        public const string GroupName = "PasswordlessAuthentication";

        public const string Home = GroupName + ".Home";
    }
}

Step-6

Open your Index.cshtml and set the content as below. We added a form that posts to GeneratePasswordlessToken action in the razor page. And it will set the PasswordlessLoginUrl field.

@page
@using MyBookStore.Web.Menus
@using Volo.Abp.AspNetCore.Mvc.UI.Layout
@model MyBookStore.Web.Pages.IndexModel
@using Microsoft.AspNetCore.Mvc.Localization
@using MyBookStore.Localization
@inject IHtmlLocalizer<MyBookStoreResource> L
@{
    ViewBag.PageTitle = "Home";
}
@inject IPageLayout PageLayout
@{
    PageLayout.Content.Title = L["Home"].Value;
    PageLayout.Content.BreadCrumb.Add(L["Menu:Home"].Value);
    PageLayout.Content.MenuItemName = MyBookStoreMenus.Home;
}
<abp-card>
    <abp-card-body>
        <form asp-page-handler="GeneratePasswordlessToken" method="post">

            <abp-button button-type="Dark" type="submit">Generate passwordless token link</abp-button>

            @if (Model.PasswordlessLoginUrl != null)
            {
                <abp-card class="mt-3 p-3">
                    <a href="@Model.PasswordlessLoginUrl">@Model.PasswordlessLoginUrl</a>
                </abp-card>
            }
        </form>
    </abp-card-body>
</abp-card>

Step-7

We implemented token generation infrastructure, now it's time validate the token and let the user in. To do this create a folder named Controllers in your *.Web project and create a controller, named PasswordlessController inside it:

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.AspNetCore.Mvc;
using Volo.Abp.Identity;
using Volo.Abp.Identity.AspNetCore;

namespace PasswordlessAuthentication.Web.Controllers
{
    public class PasswordlessController : AbpController
    {
        protected IdentityUserManager UserManager { get; }

        protected AbpSignInManager SignInManager { get; }

        public PasswordlessController(IdentityUserManager userManager, AbpSignInManager signInManager)
        {
            UserManager = userManager;
            SignInManager = signInManager;
        }

        public virtual async Task<IActionResult> Login(string token, string userId)
        {
            var user = await UserManager.FindByIdAsync(userId);

            var isValid = await UserManager.VerifyUserTokenAsync(user, "PasswordlessLoginProvider", "passwordless-auth", token);
            if (!isValid)
            {
                throw new UnauthorizedAccessException("The token " + token + " is not valid for the user " + userId);
            }

            await UserManager.UpdateSecurityStampAsync(user);

            await SignInManager.SignInAsync(user, isPersistent: false);

            return Redirect("/");
        }
    }
}

We created an endpoint for /Passwordless/Login that gets the token and the user Id. In this action, we find the user via repository and validate the token via UserManager.VerifyUserTokenAsync() method. If it's valid, we call SignInManager.SignInAsync to be able to create an encrypted cookie and add it to the current response. Finally we redirect the page to the root URL.

That's all! We created a passwordless login with 7 steps.

Source Code

The completed sample is available on GitHub repository.

〰️〰️〰️

Happy Coding 🤗

I'm Alper Ebicoglu 🧑🏽‍💻 ABP Framework Core Team Member

Follow me for the latest news about .NET and software development:

📌 twitter.com/alperebicoglu

📌 github.com/ebicoglu

📌 linkedin.com/in/ebicoglu

📌 medium.com/@alperonline