Drasko Popovic

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

.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

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

Choosing between FirstOrDefault and SingleOrDefault in .NET isn’t just about syntax – it’s about intent. FirstOrDefault: * Use this when multiple matches are fine and you only care about the first one. * It stops scanning after the first match, so it’s faster for large datasets. * There’s no uniqueness guarantee. Perfect for sorted or time-based data where the first match is all you need. SingleOrDefault: * Use this when you expect exactly one result or none. * It enforces data integrity. If there’s more than one match, it throws an exception. * It scans the entire dataset to ensure uniqueness, which makes it slower on big collections. The rule of thumb: * If you want, “give me the first match quickly”, use FirstOrDefault. * If you want “there must be only one, or throw”, use SingleOrDefault. These small choices make your intent clear and your code more predictable. I share deep-dive .NET tips like this every week with over 10,000 developers through my newsletter. If you want to sharpen your .NET fundamentals and write cleaner, faster APIs, join us here: https://lnkd.in/gWgq8i9N

743

28 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 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

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

Companies Want .NET Talent. This Is How You Become One in 2025! 1️⃣ Fundamentals -- Master Programming Basics (Variables, Loops, Data Types, Conditions) -- Grasp OOP Concepts (Inheritance, Abstraction, Polymorphism, etc.) -- Learn C# Syntax & start building mini-projects 2️⃣ Core .NET Development -- Deep dive into .NET Core vs Framework -- Understand CLR, CTS, CLS -- Practice File Handling, Collections, Generics, and Exception Handling 3️⃣ Backend with ASP.NET Core -- Build with MVC Pattern & Razor Pages -- Learn Dependency Injection & Middleware -- Use Entity Framework Core & LINQ -- Create REST APIs using ASP.NET Core Web API 4️⃣ Database Mastery -- Learn SQL (CRUD, Joins, SPs, Indexes) -- Work with SQL Server -- Integrate with EF Core -- Optimize DB performance 5️⃣ Frontend for .NET Devs -- HTML5, CSS3, JavaScript Essentials -- Explore Blazor and Razor Components -- Use Bootstrap to build responsive UIs 6️⃣ Advanced .NET Development -- Implement JWT & Identity-based Authentication -- Async Programming with Task, await/async -- Unit Testing (xUnit, NUnit, Moq) -- Logging, Caching, Config Management 7️⃣ Version Control & DevOps -- Learn Git & GitHub like a pro -- Setup CI/CD with Azure DevOps / GitHub Actions -- Dockerize .NET Apps -- Deploy on Azure / AWS 8️⃣ Projects & Portfolio -- Build CRUD, Multi-tier, API-integrated apps -- Document your work on GitHub -- Showcase your achievements on LinkedIn 9️⃣ Continuous Learning -- Explore gRPC, SignalR, Microservices -- Learn .NET MAUI for cross-platform apps -- Stay up-to-date with new .NET releases !! Pro Tip: Build while you learn. Every topic = 1 project idea !! Join the community, share your code, and contribute to open-source. !! Build your visibility with consistent GitHub & LinkedIn presence. @@ Save this roadmap ❤️ React if you found this useful 💬 Comment what step you’re on Share with your dev network 🙌 Follow Narendra Kushwaha. for more valuable roadmaps, dev tips, and tech career content! 💬 #DotNetDeveloper #FullStackDeveloper #Roadmap2025 #CSharp #DotNetCore #ASPNetCore #WebDevelopment #BackendDeveloper #FrontendDeveloper #GitHub #AzureDevOps #Microservices #Blazor #DevRoadmap #LearnToCode #BuildInPublic #TechCareers

83

3 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

🎯 Design Best Practices In .NET C# ✅ After working for some reasonable period of time in the Software field, day by day you would get more confident that there is still something new you are not aware of, yet. Depending on your exposure to different kinds of projects and requirements, you would harness new skills. However, in my humble opinion, the most precious skills are the Analytical and Design skills. Don’t get me wrong, we all know that at the end of the day there is some code to write and someone would eventually do it. However, writing the code is something you could learn from an online -or offline- documentation or a tutorial. On the other hand, Analytical and Design skills are different… In this article we are going to explore some Design Best Practices that are practically proved to be efficient. 🔍 Topics to Look Out For ⭐ Unified Return Object ⭐ Don’t Abuse DI/IoC/Containers ⭐ Delegating Controlling How To Fire Events ⭐ The Snapshot Structure ⭐ Immutability ⭐ Paging and Partitioning ⭐ Delegates over Func<> ⭐ String.GetHashCode Nightmare ⭐ Separate State from Behavior ⭐ Not Using IoC Containers is Not an Excuse ⭐ Wrap Static Objects & Third Parties ⭐ Best Practice When Using Timers ⭐ Avoid Code Hidden Intentions ⭐ Defining Non-Generic Interface beside the Generic One 💡 What’s one design best practice you admire the most? Don't let it stop here, repost and share ♻️ with your network to spread the knowledge ✅ https://lnkd.in/gKdas9gX #dotnet #csharp #coding #code #programming #bestpractices #devcommunity #computerscience #softwaredesign #softwaredevelopment #softwareengineering #softwarearchitecture

61

1 Comment