Milan Jovanović

Junior .NET devs keep asking me what skills to focus on. I analyzed 100+ Senior .NET job posts to find out. These are the skills that show up again and again, the ones employers expect senior .NET developers to master: 𝗖# The core of .NET roles; fluency in modern features and writing clean, efficient code is baseline. 𝗥𝗘𝗦𝗧 𝗔𝗣𝗜𝘀 The main integration style; secure, scalable endpoints with clear documentation matter. 𝗚𝗿𝗮𝗽𝗵𝗤𝗟 Adoption keeps growing; well-designed schemas and resolvers improve efficiency. 𝗔𝘇𝘂𝗿𝗲 The top cloud for .NET; deployment, monitoring, and scaling apps are in demand. 𝗔𝗪𝗦 Hybrid setups are common; knowledge of core services shows flexibility. 𝗣𝗼𝘀𝘁𝗴𝗿𝗲𝗦𝗤𝗟 Popular for new projects; SQL fluency, indexing, and tuning skills are needed. 𝗦𝗤𝗟 𝗦𝗲𝗿𝘃𝗲𝗿 Entrenched in enterprise; stored procedures and optimization remain essential. 𝗖𝗼𝘀𝗺𝗼𝘀 𝗗𝗕 Central to Azure apps; modeling and querying NoSQL data is common. 𝗚𝗿𝗮𝗳𝗮𝗻𝗮 Dashboards must be actionable; metrics tied to outcomes matter most. 𝗢𝗽𝗲𝗻𝗧𝗲𝗹𝗲𝗺𝗲𝘁𝗿𝘆 Now the tracing standard; consistent instrumentation across services is expected. 𝗔𝗽𝗽 𝗜𝗻𝘀𝗶𝗴𝗵𝘁𝘀 Native Azure monitoring; instrumentation and analysis skills are critical. 𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀 Central in enterprise; pipelines, repos, and releases are core. 𝗚𝗶𝘁𝗛𝘂𝗯 𝗔𝗰𝘁𝗶𝗼𝗻𝘀 Rapid adoption in modern teams; CI/CD automation experience is valued. 𝗧𝗲𝗿𝗿𝗮𝗳𝗼𝗿𝗺 Infrastructure as Code is table stakes; reproducible infra is expected. 𝗗𝗼𝗰𝗸𝗲𝗿 Baseline for backend devs; containerized apps ensure consistent deployments. 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 The orchestration standard; deployments and rollbacks show maturity. 𝗛𝗲𝗹𝗺 Default for Kubernetes apps; managing deployments with charts is common. 𝗝𝗪𝗧 Token-based auth is everywhere; APIs must implement JWT correctly. 𝗢𝗔𝘂𝘁𝗵 𝟮.𝟬 The standard for delegated access; integrating identity providers is critical. 𝗧𝗟𝗦 Encryption is non-negotiable; enforcing protocols and certificate renewal is required. 𝗞𝗮𝗳𝗸𝗮 Event streaming is mainstream; designing and consuming pipelines shows readiness. 𝗥𝗮𝗯𝗯𝗶𝘁𝗠𝗤 Common in .NET stacks; exchanges, routing, and retries highlight reliability. 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 𝗕𝘂𝘀 Core in Azure; decoupling services with queues and topics builds resilience. 𝗠𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 Among the top requested skills; services that scale independently are essential. 𝗘𝘃𝗲𝗻𝘁 𝗗𝗿𝗶𝘃𝗲𝗻 Modern systems rely on events; resilient, eventually consistent designs matter. 𝗥𝗲𝗮𝗰𝘁 The leading frontend framework; full-stack .NET developers who use React are in demand. 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 Common in enterprise; adaptability across frameworks shows seniority. 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 The foundation of the web; strong fundamentals prove you can work beyond frameworks. Want a clear path to get started? Grab my Free .NET Backend Developer Roadmap 👇 https://lnkd.in/gmb6rQUR

2,178

45 Comments

🚀 𝐖𝐡𝐚𝐭’𝐬 𝐭𝐡𝐞 𝐃𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐁𝐞𝐭𝐰𝐞𝐞𝐧 ‘𝐔𝐬𝐞’, ‘𝐌𝐚𝐩’, 𝐚𝐧𝐝 ‘𝐑𝐮𝐧’ 𝐢𝐧 𝐀𝐒𝐏.𝐍𝐄𝐓 𝐂𝐨𝐫𝐞 𝐌𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞? 🚀 ⁉️ 𝐄𝐯𝐞𝐫 𝐛𝐞𝐞𝐧 𝐜𝐨𝐧𝐟𝐮𝐬𝐞𝐝 𝐚𝐛𝐨𝐮𝐭 𝐰𝐡𝐞𝐧 𝐭𝐨 𝐜𝐡𝐨𝐨𝐬𝐞 𝐔𝐬𝐞, 𝐌𝐚𝐩, 𝐨𝐫 𝐑𝐮𝐧 𝐢𝐧 𝐀𝐒𝐏.𝐍𝐄𝐓 𝐂𝐨𝐫𝐞? Let’s break it down in a clear and simple way 👇 🧱 𝑾𝒉𝒂𝒕 𝒊𝒔 𝑴𝒊𝒅𝒅𝒍𝒆𝒘𝒂𝒓𝒆? In ASP.NET Core, middleware is a component that handles HTTP requests and responses. Each component can: Decide whether to pass the request to the next component in the pipeline. Perform actions before and/or after the next component executes. ⚙️ 𝑾𝒉𝒂𝒕 𝑨𝒓𝒆 𝑹𝒆𝒒𝒖𝒆𝒔𝒕 𝑫𝒆𝒍𝒆𝒈𝒂𝒕𝒆𝒔? Request delegates process HTTP requests and they’re configured using Use, Map, and Run. Here’s how they differ: 🔁 𝐔𝐬𝐞 – 𝐂𝐡𝐚𝐢𝐧 Use lets you chain multiple delegates together. You get a next parameter, and you can choose whether to call it or not. ✅ If you skip next(), the pipeline ends there — this is called short-circuiting. ⛔ 𝐑𝐮𝐧 – 𝐄𝐧𝐝 𝐭𝐡𝐞 𝐏𝐢𝐩𝐞𝐥𝐢𝐧𝐞 Run is a terminal middleware. It does not receive a next parameter and stops the pipeline when called. A̳n̳y̳ ̳m̳i̳d̳d̳l̳e̳w̳a̳r̳e̳ ̳r̳e̳g̳i̳s̳t̳e̳r̳e̳d̳ ̳a̳f̳t̳e̳r̳ ̳R̳u̳n̳ ̳w̳i̳l̳l̳ ̳n̳o̳t̳ ̳b̳e̳ ̳e̳x̳e̳c̳u̳t̳e̳d̳.̳ 🌳 𝐌𝐚𝐩 – 𝐁𝐫𝐚𝐧𝐜𝐡 𝐭𝐡𝐞 𝐏𝐢𝐩𝐞𝐥𝐢𝐧𝐞 If you need to branch the pipeline, you can use Map. What is branching?  It is used like a convention. For instance, if the request path starts with the given path, the branch is executed.   This is great for modularizing your app and handling specific routes differently. 💬 Which one do you use most often? And did you learn something new today? Let’s discuss in the comments 👇 #dotnet #aspnetcore #middleware #csharp #backend #webdevelopment #programming

177

25 Comments

🚀 𝗦𝗶𝗺𝗽𝗹𝗶𝗳𝘆 .𝗡𝗘𝗧 𝗕𝗮𝗰𝗸𝗴𝗿𝗼𝘂𝗻𝗱 𝗧𝗮𝘀𝗸𝘀 𝗨𝘀𝗶𝗻𝗴 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲 Building background processes in .NET? 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲 is your go-to framework for managing background jobs 𝗿𝗲𝗹𝗶𝗮𝗯𝗹𝘆, 𝘀𝗰𝗮𝗹𝗮𝗯𝗹𝘆, 𝗮𝗻𝗱 𝘄𝗶𝘁𝗵 𝘇𝗲𝗿𝗼 𝗵𝗮𝘀𝘀𝗹𝗲. 🔧 𝗪𝗵𝘆 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲? Hangfire lets you run background tasks without writing custom threading code or managing your own workers. It handles: • ✅ Job queuing • 🔁 Retries • 💥 Error handling • 💾 Persistence • 📊 Real-time monitoring 🧱 𝗧𝘆𝗽𝗲𝘀 𝗼𝗳 𝗝𝗼𝗯𝘀 𝗶𝗻 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲: 1️⃣ 𝗙𝗶𝗿𝗲-𝗮𝗻𝗱-𝗙𝗼𝗿𝗴𝗲𝘁 – Run immediately in the background 2️⃣ 𝗗𝗲𝗹𝗮𝘆𝗲𝗱 𝗝𝗼𝗯 – Scheduled to run after a delay 3️⃣ 𝗥𝗲𝗰𝘂𝗿𝗿𝗶𝗻𝗴 𝗝𝗼𝗯 – Based on CRON schedules 4️⃣ 𝗖𝗼𝗻𝘁𝗶𝗻𝘂𝗮𝘁𝗶𝗼𝗻 𝗝𝗼𝗯 – Runs after another job completes 5️⃣ 𝗕𝗮𝘁𝗰𝗵 & 𝗕𝗮𝘁𝗰𝗵 𝗖𝗼𝗻𝘁𝗶𝗻𝘂𝗮𝘁𝗶𝗼𝗻 – Grouped or dependent jobs 📦 𝗖𝗼𝗿𝗲 𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀: • 🖥️ 𝗗𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱 – Real-time job monitoring • 🛢️ 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 – SQL Server, Redis, PostgreSQL • 🔁 𝗥𝗲𝘁𝗿𝗶𝗲𝘀 – Built-in error handling • ⚙️ 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 – Custom job behaviors • 📡 𝗦𝗰𝗮𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆 – Works across multiple servers 📌 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲? Use it when you need: • A full-featured 🖥️ monitoring dashboard • 💾 Persistence across app restarts • 🕒 Recurring jobs (CRON-style) • 🔁 Automatic retries + error logs • 🔗 Chained or dependent jobs • 🚀 Production-ready background workers ⚖️ 𝗔𝗹𝘁𝗲𝗿𝗻𝗮𝘁𝗶𝘃𝗲𝘀 𝘁𝗼 𝗛𝗮𝗻𝗴𝗳𝗶𝗿𝗲: 🔸 𝗤𝘂𝗮𝗿𝘁𝘇.𝗡𝗘𝗧 – Powerful scheduler, CRON-friendly 🔸 𝗖𝗔𝗣 – Event-based background processing 🔸 𝗠𝗮𝘀𝘀𝗧𝗿𝗮𝗻𝘀𝗶𝘁 + 𝗥𝗮𝗯𝗯𝗶𝘁𝗠𝗤 – Distributed message queues 🔸 𝗔𝘇𝘂𝗿𝗲 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 – Serverless background jobs 🔸 𝗪𝗼𝗿𝗸𝗲𝗿 𝗦𝗲𝗿𝘃𝗶𝗰𝗲 – Lightweight OS-level background tasks 📖 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 👉 https://lnkd.in/dwb_vSb4 💻 𝗦𝗼𝘂𝗿𝗰𝗲 𝗖𝗼𝗱𝗲 👉 https://lnkd.in/dRnWurjt 💬 𝗪𝗵𝗮𝘁’𝘀 𝘆𝗼𝘂𝗿 𝗳𝗮𝘃𝗼𝗿𝗶𝘁𝗲 𝗯𝗮𝗰𝗸𝗴𝗿𝗼𝘂𝗻𝗱 𝗷𝗼𝗯 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 𝗶𝗻 .𝗡𝗘𝗧? 𝗟𝗲𝘁’𝘀 𝗱𝗶𝘀𝗰𝘂𝘀𝘀 👇 👉 Follow me (Kanaiya Katarmal) and hit the 🔔 on my profile so you don’t miss upcoming .NET tips and deep dives. 𝗧𝗵𝗮𝗻𝗸𝘀 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗹𝗲𝘁’𝘀 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲 𝗴𝗿𝗼𝘄𝗶𝗻𝗴 𝗮𝗻𝗱 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 .𝗡𝗘𝗧 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿! 👉 𝗦𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲 𝘁𝗼 𝗺𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿: https://lnkd.in/dp7tz_3V #𝗱𝗼𝘁𝗻𝗲𝘁 #𝗰𝘀𝗵𝗮𝗿𝗽 #𝗮𝘀𝗽𝗻𝗲𝘁𝗰𝗼𝗿𝗲 #𝗵𝗮𝗻𝗴𝗳𝗶𝗿𝗲 #𝗯𝗮𝗰𝗸𝗴𝗿𝗼𝘂𝗻𝗱𝗷𝗼𝗯𝘀 #𝗴𝗶𝘁𝗵𝘂𝗯 #𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 #𝗾𝘂𝗮𝗿𝘁𝘇𝗻𝗲𝘁 #𝗰𝗮𝗽 #𝗺𝗮𝘀𝘀𝘁𝗿𝗮𝗻𝘀𝗶𝘁

319

55 Comments

.NET developers: Stop searching for a "perfect" architecture. It doesn't exist. An email subscriber asked me recently: "How do you decide on the optimal architecture at the start of a project?" Well, it all comes down to the first law of software architecture: Everything is a tradeoff. There is no single solution that will work all the time. Every choice you make will involve many factors. Sometimes those factors will conflict with each other. Here's what that looks like in practice: - Increase testability → lose simplicity. - Increase consistency → lose availability. - Increase redundancy → lose cost efficiency. You can't have them all. But you can have the right ones for the context. - For a startup MVP, speed beats scalability. - For an internal tool, simplicity beats resilience. - For a bank's payment system, security beats speed. So how do you decide at the start? You look at the non-functional requirements (NFRs). They're your compass. - If performance matters → optimize queries, add caching. - If adaptability matters → enforce clean boundaries. - If time-to-market matters → go monolith first. Architecture isn't about building the fanciest system, microservices from day 1. It's about building the right system for the job today. Solve today's problems, but leave doors open for tomorrow's decisions.

222

18 Comments

.NET development is sometimes underrated, even in 2025 😞 Many think .NET is just: - Writing C# classes - Drag-drop in Visual Studio - EF Core scaffolding - Click “Publish” and you’re done But that’s just the tip of the iceberg. The reality? Professional .NET development is way more than building CRUD endpoints. A strong .NET Developer can: - Design clean architectures and follow SOLID principles - Model business domains (DDD) instead of dumping everything into one folder - Build Scalable Systems and Services - Optimize EF Core queries and transactions for real-world performance - Implement caching, distributed systems, and make APIs scalable - Secure applications using AuthN/AuthZ, Identity, OAuth - Build automated tests and ensure proper coverage - Review code, enforce branching strategies, and improve PR quality - Optimize hosting costs and design cloud-ready systems - And literally, so much more! .NET isn’t just a framework – it’s a discipline. Share this with someone who would want to read this.

2,749

73 Comments

How do you make sure your team doesn’t accidentally break your architecture? I use a mix of three techniques: • Compiler and static analysis • Architecture tests • Code reviews The compiler is your cheapest safety net. If something doesn’t compile, the build fails. In .NET, you can use access modifiers like internal to hide types across boundaries. Architecture tests go one step further. They let you write automated checks for your design rules. Still fast, and easy to run with every build. Code reviews are important too, but they’re slow and manual. They rely on people catching mistakes. If I had to rank them by cost: • Compiler – almost free • Architecture tests – some setup, still fast • Code reviews – most expensive and error-prone The best approach? Use all three, but lean more on the ones that never get tired. I wrote a post on how to bulletproof your architecture: https://lnkd.in/dp9z9DHs What guardrails do you use to keep your system in shape? P.S. There are also many AI tools you can use today that are really good at code reviews. The most popular one is CodeRabbit, but there are others. I would also explore this approach if you're looking to automate this process. --- Do you want to simplify your development process? Grab my free Clean Architecture template here: https://lnkd.in/eFSRpRwx

261

28 Comments

🚀 Today’s Post | Interview Question #36 Dependency Injection Lifecycles in .NET 🧐 Here’s your quick guide to DI in .NET Core: 🔹 Singleton ♾️ ✅ One instance for the entire application ✅ Perfect for stateless, shared services (e.g., Logger) ❌ Dangerous for storing state! 🔹 Scoped 🔄 ✅ One instance per user request (e.g., in a web app) ✅ Ideal for Entity Framework DbContexts ❌ Not thread-safe outside a request 🔹 Transient ⚡ ✅ A new instance is created every time it’s requested ✅ Great for lightweight, stateless services ❌ Can cause memory overhead if overused 💡 Quick Recap: Singleton = Shared, global state Scoped = Per user session/request Transient = Always new, never shared Mastering these lifecycles will level up your architecture and prevent nasty bugs. 🚀 👉 Which lifecycle do you use the most in your projects? 🔑 Hashtags #DotNet #DotNetCore #DependencyInjection #SoftwareArchitecture #Programming #BackendDevelopment #WebDevelopment #Microservices #Coding #SoftwareDevelopment #Tech #CodeNewbie #LearnToCode

391

16 Comments

🚀 .NET Interview Q&A – Real-World Scenarios Are you preparing for a .NET developer role? Many interviews now focus on practical scenarios, not just syntax. Here are 5 scenario-based questions to test your readiness: 1️⃣ How would you handle a memory leak in a .NET application? ✅ Use profiling tools like dotMemory or PerfView. Analyze object retention paths, dispose unmanaged resources, and avoid static references where not needed. 2️⃣ How do you implement caching in a .NET web API? ✅ Use IMemoryCache or IDistributedCache in .NET Core. Consider sliding/absolute expiration and invalidation strategy. 3️⃣ What’s your approach to handling large file uploads in ASP.NET Core? ✅ Stream the file directly to disk or cloud storage using buffered or streamed request reading. 4️⃣ How do you design a scalable architecture for high-traffic .NET web apps? ✅ Apply principles like microservices, caching layers, async processing, and queue-based messaging (e.g., Azure Service Bus). 5️⃣ How would you troubleshoot high CPU usage in a live .NET app? ✅ Use dotnet-trace, analyze thread stacks, GC stats, and performance counters. 🔍 Interviews today require you to think like a system designer, not just a coder. 📩 Let me know if you'd like a PDF version or infographic of these Q&As! #DotNet #SoftwareEngineering #TechInterviews #BackendDev #DotNetCore #InterviewTips #CleanCode #SystemDesign #LinkedInLearning #CSharp

82

6 Comments

🚀 .NET Developers in 2025 – Expectations vs. Reality I’m speaking with both companies and developers daily, and one theme keeps coming up: 👉 The “ideal” .NET candidate profile many companies are aiming for doesn’t always match what’s available in today’s market. That gap is natural, but being aware of it helps both sides make better decisions. #dotnet #hiring #developers #softwaredevelopment #backend #fullstack #cloud #azure #careers #talentacquisition

73

4 Comments

Understanding ASP.NET Core Project Folder Structure 🧩 🔍 A well-structured ASP.NET Core project makes your application: ✅ More maintainable ✅ Easy to scale ✅ Easier for new developers to understand Let’s break down the typical folders and files you’ll see in a new ASP.NET Core Web App 👇 --- 📁 Connected Services 🧠 Use this when you connect to external services like REST APIs, gRPC, Azure storage, or other third-party cloud integrations. 💡 It auto-generates helper classes that simplify consuming those services. 📁 Dependencies 📦 Lists all your NuGet packages and project references. 🔧 These packages extend your app’s capabilities (like Entity Framework Core, Swagger, etc.). 📁 wwwroot 🌐 This is the only folder accessible publicly (client-side). 📁 It contains static files like: HTML, CSS, JS Fonts and images 💡 Example: site.css, logo.png 📁 Controllers 🧭 This is where your main logic goes — it handles incoming requests. Each controller (e.g., HomeController.cs) processes a route and returns a response (like a view or JSON). 🔁 Often paired with models and views. 📁 Models 🧱 Represents your application data. 📦 It contains classes that define the structure of your objects (DTOs, ViewModels, Domain Models). 💡 Example: User.cs, Product.cs 📁 Views 🖼️ Stores the front-end Razor (.cshtml) files. 🎨 Think of them as HTML templates with embedded C# logic. 💡 Follows MVC: A view for each controller action (e.g., Views/Home/Index.cshtml) 📄 Program.cs 🎯 The entry point of your ASP.NET Core app. 🧩 It configures the web host and sets up the app builder. You’ll find lines like app.UseRouting(), app.UseEndpoints(), etc. 📄 Startup.cs 🧰 (Optional in .NET 6+, but used in earlier versions) Configures services like DB context, Authentication, Middleware. 🔧 Contains methods like: ConfigureServices() Configure() --- 🧠 Why it matters: A clean folder structure not only helps you manage your codebase efficiently but also prepares you to work in real-world enterprise applications.

128

3 Comments

⚡ Boot an ASP.NET Core app inside your tests ⚠️ The Problem Many teams spin up containers or rely on shared servers for integration tests. That slows tests down, adds flakiness, and requires infrastructure. ✅ The Solution Subclass WebApplicationFactory to create a reusable Test Application instead of using the WebApplicationFactory directly. This allows you to pack shared configuration and features in the Test Application, making your test suite easier to evolve. 🧠 Under the Hood WebApplicationFactory runs your app entirely in memory, while giving you an HttpClient bound to the test server. 🎯 The Result The Test Application pattern: - Real ASP.NET Core pipeline (middleware, DI, routing). - No ports, no containers, no infrastructure. - Clean code, configurable for each test, reusable across test cases. This pattern brings integration-test confidence with near-unit-test speed. A pattern I leveraged in my latest book. 💬 Would you swap containers for in-memory test apps in your setup? 💬 Are you already using WebApplicationFactory? 💬 What are your success/failure stories? This post continues my series on HttpClient & integration testing. It expands the original proxy testing article with bite-sized tips and new topics. (Link in comments 👇) #dotnet #testing #aspnetcore

91

10 Comments

Custom middleware is one of the most powerful features in .NET. It gives you complete control over how HTTP requests and responses flow through your application. The recommended way to build middleware is by implementing the IMiddleware interface. This approach promotes clean architecture, strong typing, and better testability. Core method to implement: ➜ InvokeAsync(HttpContext context, RequestDelegate next) Inside this method, you can inject custom logic, handle requests, and decide when to pass control to the next component in the pipeline. Unlike traditional middleware, using IMiddleware requires registering the class as a service. This unlocks the full benefits of dependency injection and keeps code modular and clean. To register middleware: Use AddTransient<YourMiddleware>() in Program.cs or Startup.cs. Then, define an extension method to plug middleware into the pipeline. This keeps startup configuration clean and readable. 💡 Ex: AnonymousUserMiddleware Each visitor is assigned a unique identifier stored securely in a cookie. If no cookie exists, a new GUID is generated and stored with proper options. The identifier is also stored in HttpContext.Items, making it easily accessible throughout the app. Key benefits of this pattern: ↳ Strong typing and improved reusability. ↳ Easier unit testing with clean mocks. ↳ Cleaner Program.cs using extension methods. ↳ Full support for dependency injection. Key takeaways: ↳ Use IMiddleware to follow separation of concerns. ↳ Always implement InvokeAsync() to process requests. ↳ Register middleware with AddTransient<>(). ↳ Use extension methods for a cleaner pipeline setup. When designed well, custom middleware can significantly improve the maintainability and scalability of .NET applications. It’s a simple yet powerful pattern every .NET developer should master. 👉 What’s your go-to approach for building middleware? --- 🔁 Reshare to spread the knowledge! 👉 Follow me [Elliot One] for more on modern software engineering. #dotnet #csharp #cleancode #systemdesign #technology #tech

67

5 Comments