Ayman Anaam’s Post

Solid list of performance tweaks for ASP.NET Core apps I always remind my team: performance isn’t about big rewrites, it’s about consistent small optimizations. Personally, I never skip using AsNoTracking() for read-heavy queries, it makes a huge difference in high-load apps. DbContext pooling and trimming middleware are also underrated but powerful. And with .NET 8, output caching is a game-changer for APIs that return similar responses. At the end of the day, performance is about being intentional with every layer, from queries to caching to the server itself.

Goodbye UseStaticFiles, Hello MapStaticAssets in .NET 9! Microsoft just made serving CSS, JS, and images in ASP.NET Core apps way faster. Here’s how the old vs new stacks up: UseStaticFiles (Old) • No built-in compression (needs extra config) • Runtime compression (costly CPU cycles) • Weak caching (last-modified timestamps) • No fingerprinting → cache busting is manual • Doesn’t optimize publish pipeline MapStaticAssets (New in .NET 9) Pre-compressed at build time (gzip & Brotli) Content-based ETags (SHA-256 hash) Automatic fingerprinting + immutable caching Plays nicely with Blazor, MVC, Razor Pages Smaller payloads (70–90% size reduction) One-liner switch: // Old app.UseStaticFiles(); // New app.MapStaticAssets(); 💡 When to use Use MapStaticAssets for build-time known files (wwwroot, Blazor assets, static bundles). Keep UseStaticFiles for dynamic/unknown assets (user uploads, external dirs). 📌 Takeaway: This is a drop-in performance upgrade for most ASP.NET Core apps. Your users get faster loads, your servers use less CPU, and your cache headaches disappear. 👉 Are you planning to switch to MapStaticAssets in your projects? #dotnet #aspnetcore #performance #webdev #blazor

🚀 ASP.NET Core Filters Simplified 🚀 Filters in Web API help you run code before or after actions. They’re perfect for cross-cutting concerns like logging, security, caching, and error handling. Here’s a simple table to keep them straight 👇 ✅ Pro tip: Use Middleware for global cross-cutting (all requests). Use Filters for MVC-specific cross-cutting (per controller/action). 🔔 Join me to improve your skills to clean code. 👩💻 Please share and repost and help others to code better and clean code. Follow me : Ayyappa R.. #efcore #entityframework #csharp #csharpdotnet #csharpdeveloper #csharpprogramming #linq #dotnet #dotnetdeveloper #dotnetcore #dotnetfullstackdeveloper #aspnetcore #aspnet #aspdotnet #aspnetmvc #mvcframework #DotNetCore #ASPNetCore #CSharp #WebDevelopment

⚡ Exception Handling & Error Pages in ASP.NET Core ⚡ No matter how good your code is, exceptions will happen — null values, failed API calls, missing routes. If you don’t handle them, users see ugly error dumps 😅. That’s why ASP.NET Core gives us built-in tools: ✅ UseDeveloperExceptionPage → shows detailed error info (for devs only). ✅ UseExceptionHandler → catches errors in production and redirects to a friendly error page. ✅ UseStatusCodePages → handles 404, 500, etc. with clean messages or custom pages. 💡 Example: If /products/9999 doesn’t exist, instead of showing a scary exception, you can: ✔️ Show a nice “Product not found 🛒” page ✔️ Log the error internally for developers ✨ Best Practices ✔️ Keep error details hidden from users (but log them for devs) ✔️ Customize 404/500 pages to match your app’s branding ✔️ Centralize exception handling with middleware 🔑 Takeaway Good exception handling isn’t just about debugging — it’s about user experience and trust. Even when things go wrong, your app should handle it gracefully.

🚀 Clean, Maintainable ASP.NET Core with Filters Your controller shouldn't do all the heavy lifting. Whether you’re building scalable APIs or sleek web apps, filters in ASP.NET Core are your secret weapon for handling cross-cutting concerns like authentication, logging, caching, and error handling — all outside your core business logic. Here's how they work: 🎯 𝗪𝗵𝗮𝘁 𝗔𝗿𝗲 𝗙𝗶𝗹𝘁𝗲𝗿𝘀? Filters let you tap into the request-processing pipeline — running code before or after a controller action executes, or even when exceptions occur. Think of them as middleware for individual controller actions. 📚 𝗙𝗶𝗹𝘁𝗲𝗿 𝗧𝘆𝗽𝗲𝘀 (𝗮𝗻𝗱 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗧𝗵𝗲𝗺) 🔐 𝗔𝘂𝘁𝗵𝗼𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Check if the user is allowed access before anything else runs. 🧰 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Execute before and after model binding. Great for caching or short-circuiting the request. 🎬 𝗔𝗰𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Wrap around the controller action. Perfect for logging, validation, or performance tracking. 🧯 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Centralized error handling — no more scattered try/catch blocks. 📤 𝗥𝗲𝘀𝘂𝗹𝘁 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Modify or log the result (like JSON or HTML view) before it goes out to the client.

🚀 Clean, Maintainable ASP.NET Core with Filters Your controller shouldn't do all the heavy lifting. Whether you’re building scalable APIs or sleek web apps, filters in ASP.NET Core are your secret weapon for handling cross-cutting concerns like authentication, logging, caching, and error handling — all outside your core business logic. Here's how they work: 🎯 𝗪𝗵𝗮𝘁 𝗔𝗿𝗲 𝗙𝗶𝗹𝘁𝗲𝗿𝘀? Filters let you tap into the request-processing pipeline — running code before or after a controller action executes, or even when exceptions occur. Think of them as middleware for individual controller actions. 📚 𝗙𝗶𝗹𝘁𝗲𝗿 𝗧𝘆𝗽𝗲𝘀 (𝗮𝗻𝗱 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗨𝘀𝗲 𝗧𝗵𝗲𝗺) 🔐 𝗔𝘂𝘁𝗵𝗼𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Check if the user is allowed access before anything else runs. 🧰 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Execute before and after model binding. Great for caching or short-circuiting the request. 🎬 𝗔𝗰𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Wrap around the controller action. Perfect for logging, validation, or performance tracking. 🧯 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Centralized error handling — no more scattered try/catch blocks. 📤 𝗥𝗲𝘀𝘂𝗹𝘁 𝗙𝗶𝗹𝘁𝗲𝗿𝘀 → Modify or log the result (like JSON or HTML view) before it goes out to the client.

I just built a To-Do List Web App using **ASP.NET Core 8 & Entity Framework Core** 🚀 🔹 Features:   ✅ User Registration & Login with Identity   ✅ Create, Edit, Delete Tasks   ✅ File Upload & Download   ✅ Search & Pagination for tasks   ✅ Role-based Authorization (Admin / Customer) This project helped me practice:   💡 Clean architecture with Repository Pattern   💡 ASP.NET Core Identity & Authentication   💡 Modern UI with Bootstrap   💡 **SOLID principles** for clean and maintainable code:   • **SRP** — Each class has one responsibility   • **OCP** — Extended features without modifying core logic   • **LSP** — Swappable implementations via `IItemRepository`   • **ISP** — Lean interfaces only include what’s needed   • **DIP** — Controllers rely on abstractions, injected via DI 📂 Check out the source code here 👉 https://lnkd.in/dKNgcauX #dotnet #aspnetcore #csharp #webdevelopment #cleanCode #SOLID #productivity #SoftwareEngineer #demo

💡 A Day in the Life of an ASP.NET Core Developer… and How DI Saves the Day Imagine this: You’re building a web application, and your controller needs to fetch user data. At first, you just create the service inside your controller… simple, right? But soon, your code grows messy 🌀. Controllers tightly tied to concrete classes… Tests failing because you can’t easily swap real services with fake ones 🧪… Adding new features feels like walking through a minefield ⚠️. Then you discover Dependency Injection (DI). With DI, controllers don’t worry about creating services 🏗️. They just ask for what they need, and ASP.NET Core provides it. Everything becomes cleaner: 🔹 Controllers depend on interfaces, not implementations 🔗 🔹 Swapping real services for mock services is effortless 🧪 🔹 Your code starts following SOLID principles automatically ✅ 🔹 Changes in one part don’t break the rest – maintainability skyrockets 📈 Suddenly, building, testing, and scaling your app feels… joyful 😄. No more tangled dependencies, no more fragile tests. Just flexible, professional, and testable code. Embrace DI in ASP.NET Core — it doesn’t just inject services; it injects sanity into your workflow 🚀 #dotnet #aspnetcore #dependencyinjection #solidprinciples #csharp #cleanarchitecture #programmingtips #softwareengineering

🚦 Routing in ASP.NET Core – Which One’s Better? 🚦 When building web apps, routing is the invisible traffic cop 🛣️ directing incoming requests to the right endpoints. In ASP.NET Core, we’ve got two main types: 🔹 Convention-based Routing Centralized in Startup.cs (or Program.cs in .NET 6+) Routes defined using URL patterns Great for traditional MVC apps Defined in Program.cs: app.MapControllerRoute(   name: "default",   pattern: "{controller=Home}/{action=Index}/{id?}"); 🔹 Attribute Routing Routes defined directly on controllers/actions via [Route], [HttpGet], etc. Highly flexible & explicit Perfect for APIs and microservices Defined directly on controllers: [Route("api/[controller]")] public class ProductsController : ControllerBase {   [HttpGet("{id}")]   public IActionResult Get(int id) => Ok(); } ⚖️ So, which is better? For APIs → Attribute routing wins ✅ (clear, self-documented, and scalable). For simple MVC apps → Convention routing keeps things clean. In modern ASP.NET Core development → Attribute routing tends to be the preferred approach, especially with the rise of minimal APIs and microservices. 👉 At the end of the day, the best choice depends on your project’s complexity and team preferences. But if you’re building REST APIs in ASP.NET Core? Go with attribute routing. 🚀 💡 What’s your go-to routing style in ASP.NET Core, and why? #DotNet #ASPNETCore #WebDevelopment #APIs #CodingTips #CleanCode #Microservices #MinimalAPIs #WebAPI #DevCommunity #CSharp

Today, I explored the History & Evolution of .NET step by step: ✨ ASP (1996 – Active Server Pages) 🔹 Microsoft’s first tech for dynamic web pages with server-side scripts. ⚠️ Limitations: Mixed code & HTML (hard to maintain) Interpreted slower performance Poor separation of concerns Limited language options Weak scalability & state management Limited debugging tools ✨ ASP.NET (2002) 🔹 Released as part of the .NET Framework. 🔹 Added compiled code, code-behind model, better tools, built-in security & scalability. ⚠️ Limitations: Everything tightly bound in one place New request couldn't be efficiently served until the previous one finished ✨ ASP.NET MVC (2009) 🔹 Introduced MVC pattern for clean separation of concerns. 🔹 Gave full control over HTML, lightweight, more testable. ⚠️ Limitation: still platform-dependent. ✨ ASP.NET Core (2016) 🔹 Cross-platform, modular, high-performance, cloud-ready, and open-source. 🔹 Unified MVC & Web API → true modern development! 💡 From script-based pages ➝ to modern cross-platform apps, .NET has evolved into a powerful framework trusted worldwide. #DotNet #ASPNET #LearningJourney #Developers