Bad Code Works Today, Hurts Tomorrow: .NET Best Practices

C#/.NET Performance Tip — String Concatenation in Loops Many .NET developers still use += inside loops without realizing how expensive it really is. Using result += "x" inside a 1,000-iteration loop is 100 times slower than using StringBuilder.Append. When += is used on a string, .NET must: - Allocate a brand new string on every single iteration - Copy all existing characters into the new buffer - Discard the old string for the garbage collector In contrast, when StringBuilder is used, .NET: - Maintains one internal, growable buffer - Appends characters in place with zero extra allocations - Converts to a string only once at the end This pattern applies anywhere you build text dynamically: - Logging and reporting - CSV / JSON generation - Query construction - Any loop-based text assembly A small change can lead to a massive impact at scale. Benchmark results show: 4.21 us (StringBuilder) vs 412.50 us (+=), with 2.1 KB vs 2,500 KB allocated. Pre-size your StringBuilder when you know the capacity — even better. #csharp #dotnet #performance #programming #tips #coding #softwaredevelopment #aspnetcore #developer #cleancode

🚨 𝐂# 𝐜𝐨𝐝𝐞 𝐫𝐞𝐯𝐢𝐞𝐰 𝐜𝐡𝐚𝐥𝐥𝐚𝐧𝐠𝐞 - 𝐬𝐨𝐫𝐭𝐢𝐧𝐠 The code looks reasonable. Sort by last name, then sort by first name. In small datasets with obvious ordering differences you may never notice. In production, with real names, real dates, real amounts - the sort is wrong and the bug ships. Reports are wrong. Pagination is wrong. User-facing tables show incorrect order. The code review passes because both calls look intentional. Can you spot what is wrong and how to fix it? Drop your answer below. 👇 ♻️ Repost to spread the knowledge 📌 Save this for your next LINQ code review Subscribe to my weekly .NET newsletter 🚀 https://lnkd.in/drjE3rjP Follow Remigiusz Zalewski for more daily .NET tips 👇 #dotnet #aspnetcore #csharp #linq #api #dotnetcore #codingtips #softwaredeveloper #programming #webdevelopment #careergrowth #developer #coding #aspnet

From a "Developer Script" to Standalone Software My first Python File Organizer worked great, but it had one major barrier: you needed Python installed and a terminal open just to run it. So I iterated. V2.0 transforms the same logic into a full-fledged application. Not just code anymore, a tool anyone can actually use. What's new:    1) Clean GUI built with Tkinter      2) Browse and select folders visually, no path typing required    3) Bundled into a standalone .exe with PyInstaller 450 mixed files. 7 clean folders. Done in seconds. A quick note on security:  Since this is an open-source and self-signed, Windows may display a SmartScreen warning. That's standard for apps without a paid code-signing certificate, not a red flag. I've documented how to bypass it safely (or run from source) in the README. The code and the release are live on GitHub - link in the comments. #Python #SoftwareEngineering #Automation #GUI #Tkinter #OpenSource

Source Generators let the compiler write your boilerplate at build time - real C# files, zero reflection, zero runtime cost. They inspect your code during compilation and emit new source files that get compiled right alongside yours. It's like having an intern who only writes the tedious parts and never asks for a code review. // You write the model. The generator writes the rest: public partial class PizzaOrder { public string Topping { get; set; } } // This partial was never typed by a human: public override string ToString() =>   $"PizzaOrder {{ Topping = {Topping}, Qty = {Quantity}, Price = {Price:C} }}"; Microsoft introduced them in .NET 5 / C# 9 (2020) to kill reflection-based slowness and make things like `System.Text.Json` actually fast. Writing code that writes code - still feels like cheating, honestly. See it in action: https://lnkd.in/eb8S_rXV #dotnet #csharp #programming #sourcegenerators

🚀 **Hashtable vs Dictionary in C# — When to Use What?** If you're working with key–value pairs in .NET, you've probably come across both **Hashtable** and **Dictionary**. But choosing the right one matters 👇 🔹 **Dictionary<TKey, TValue> (Recommended)** ✔ Strongly typed (compile-time safety) ✔ Better performance (no boxing/unboxing) ✔ Cleaner and modern approach ✔ Works seamlessly with LINQ 👉 Best for: * New applications * High-performance scenarios * Structured data (e.g., ID → Object mapping) --- 🔸 **Hashtable (Legacy)** ✔ Stores mixed data types ✔ Allows null keys ❌ Not type-safe ❌ Slower due to boxing/unboxing 👉 Best for: * Maintaining legacy systems * Interacting with older APIs --- 💡 **Simple Rule to Remember:** ➡ Writing new code? → Use **Dictionary** ➡ Maintaining old code? → You might encounter **Hashtable** --- 🧠 Writing clean and efficient code is not just about making it work — it's about making it scalable and maintainable. #dotnet #csharp #software development #coding tips #developers #programming #backend #learning #100DaysOfCode

Most developers use classes every day without thinking about what's actually happening. 🧠 Here are 4 things that'll make you a more intentional .NET developer: ① Class ≠ Object A class is just a blueprint. The object only exists once you call new. Don't confuse the template with the thing. ② Your constructor is a contract. If an object can be created in a broken state, your constructor is lying. Make invalid state impossible from the start. ③ Access modifiers = your API. Everything public is a promise you'll have to keep. Default to private. Expose only what's intentional. ④ Properties over public fields. Always. Use { get; init; } for immutable data. Use { get; private set; } to protect state. Public fields skip all your guardrails. Bonus → In modern C#, ask yourself: is this a class or a record? If it's pure data with no behavior, record class will save you a lot of boilerplate. Master classes, and the rest of OOP clicks into place. 🔩 What's one class design mistake you made early on? I'll go first in the comments 👇 #dotnet #csharp #oop #100daysofcode #softwareengineering #programming #dotnetdeveloper

💡 𝐆𝐥𝐨𝐛𝐚𝐥 𝐮𝐬𝐢𝐧𝐠𝐬 𝐢𝐧 𝐂# - 𝐬𝐭𝐨𝐩 𝐫𝐞𝐩𝐞𝐚𝐭𝐢𝐧𝐠 𝐭𝐡𝐞 𝐬𝐚𝐦𝐞 𝐮𝐬𝐢𝐧𝐠 𝐬𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭𝐬 Most projects repeat the same 5-10 using statements across every file. It's boilerplate that adds noise without value. Global usings let you declare them once and use them everywhere. 🔹 What are global usings? Global usings are namespace imports you declare once in a single file, and they're available in every other file in your project. You use the global using keyword instead of the regular using keyword. The compiler treats them as if you'd written them at the top of every file. 🔹 How do you use them? Create a file called GlobalUsings.cs (or any name you prefer) and put your global using statements there. Common candidates: System, System.Collections.Generic, System.Linq, your company namespace, your most-used domain models. That's it - they're now available everywhere. 🔹 When does this matter? In larger projects with 50+ files, eliminating repetitive usings saves scrolling and makes the code cleaner. In small projects, the benefit is minimal. The real win is in maintaining shared libraries or conventions - one place to update, everywhere benefits. 🔹 The trap to avoid Don't make global usings a dumping ground. If you're only using a namespace in one or two files, keep the using local. Global usings work best for truly universal dependencies. Overuse makes it harder to understand what your code actually depends on. ✦ Declare global usings with global using Namespace; ✦ Keep them in a dedicated file like GlobalUsings.cs for discoverability ✦ Use global usings only for namespaces you need in most files ✦ Local using statements still override and add to global ones in the same file ♻️ Repost to help your team clean up using statements! 📌 Save this for later Subscribe to my weekly .NET newsletter 🚀 https://lnkd.in/drjE3rjP Follow Remigiusz Zalewski for more daily .NET tips 👇 #csharp #dotnet #aspnetcore #dotnetcore #codingtips #softwaredeveloper #programming #webdevelopment #careergrowth #developer #coding #aspnet

Ever opened your Node backend after a few months and wondered "Who wrote this spaghetti?" Everything lives in one place — routes, controllers, database calls, business logic. At first it works fast then suddenly, your monolithic codebase becomes unmaintainable. That’s exactly when I discovered the MVC folder structure pattern. ##JavaScript #SoftwareEngineering #DevCommunity #CleanCode #Programming

You can now add properties, operators, and static methods to ANY type in C#. Including string. Including int. Including sealed classes. C# 14 Extension Members are the biggest language change since records. Before, we only had extension methods: → public static bool IsEmail(this string s) — works but ugly → Buried in a random static class → Can't add properties or operators Now, with extension blocks: public static class StringExtensions { extension(string str) { public bool IsEmail => str.Contains("@") && str.Contains("."); public int WordCount => str.Split(' ').Length; } } And usage is completely natural: if (user.Email.IsEmail) { ... } var words = title.WordCount; No more StringExtensions.IsEmail(email) scattered across utility classes. What you can now extend: • Instance properties • Static methods • User-defined operators (+=, -, ==, etc.) • Even sealed classes and built-in types Why this matters for real projects: • Domain-specific extensions that feel native • Fluent APIs without owning the target type • Cleaner validation — "price.IsValid" reads better than "PriceValidator.Validate(price)" • Less boilerplate in every layer of your code The limitation: Extension members can't have state. No backing fields that persist between calls. They're computed, not stored. This is intentional. Extensions enhance types — they don't fundamentally alter them. My take: This is a feature that changes how .NET libraries will be designed going forward. Every major NuGet package will adopt this. What type would you extend first? #dotnet #csharp #csharp14 #extensionmembers #programming #softwareengineering