Daily micro-tips for C#, SQL, performance, and scalable backend engineering.
📦 Using = Resource Management Resources leak without cleanup. Using statements ensure disposal. Files, connections, streams — auto-cleanup. ❌ Manual Cleanup var file = File.Open(“file.txt”); try { // Use file } finally { file.Dispose(); } ✅ Using Statement using var file = File.Open(“file.txt”); // Use file – auto-disposed 📝 Using Examples // File operations using […]
⚡ Lambda Expressions = Concise Code Anonymous methods are verbose. Lambda expressions are concise. One-liners for LINQ, delegates, events. ❌ Anonymous Method Func square = delegate(int x) { return x * x; }; ✅ Lambda Expression Func square = x => x * x; 📝 Lambda Examples // Basic syntax (parameters) => expression (parameters) => […]
🔌 Extension Methods = Add Functionality Can’t modify existing types? Extension methods add functionality. Use like instance methods. ❌ Static Methods string email = “USER@EXAMPLE.com”; email = StringHelper.ToTitleCase(email); ✅ Extension Method string email = “USER@EXAMPLE.com”; email = email.ToTitleCase(); 📝 Extension Examples // Static class, static methods public static class StringExtensions { public static string ToTitleCase(this […]
🧩 Generics = Type-Safe Code Object types are unsafe. Generics create type-safe reusable code. Performance, safety, flexibility. ❌ Object (Unsafe) public class Stack { private object[] items; public void Push(object item) { } public object Pop() { } } Stack s = new Stack(); s.Push(123); // Boxed int i = (int)s.Pop(); // Cast ✅ Generic […]
📝 Records = Immutable Data Classes are mutable. Records are immutable. Value-based equality, concise syntax, data-centric. ❌ Class (Mutable) public class Person { public string Name { get; set; } public int Age { get; set; } } ✅ Record (Immutable) public record Person(string Name, int Age); 📝 Record Features // Positional record public record […]
📦 ValueTuples = Multiple Return Values Returning multiple values is messy. ValueTuples make it clean. Lightweight, named, convenient. ❌ Out Parameters public void GetUser(out int id, out string name) { id = 1; name = “Alice”; } ✅ ValueTuple public (int Id, string Name) GetUser() { return (1, “Alice”); } 📝 ValueTuple Examples // Named […]
📦 Struct vs Class — Choose Wisely Both store data. Struct vs Class matters for performance. Value type vs reference type. 📝 Key Differences // Class (Reference Type) public class Person { public string Name { get; set; } public int Age { get; set; } } // Struct (Value Type) public struct Point { […]
⚡ Async/Await Best Practices Async is powerful but tricky. Best practices make it reliable. Performance, deadlocks, error handling. 📝 Best Practices // 1. Use async for I/O only // Good: Database, HTTP, file I/O public async Task GetUserAsync(int id) { … } // Bad: CPU-intensive operations public async Task CalculateAsync(int n) { … } // […]
⚡ TAP = Asynchronous Programming Async is essential. TAP is the standard pattern. Async/await, Task, Task. 📝 TAP Basics // Basic async method public async Task GetDataAsync() { using var client = new HttpClient(); var result = await client.GetStringAsync(“https://api.example.com/data”); return result; } // Async with error handling public async Task GetUserAsync(int id) { try { […]
🛡️ Exception Handling = Robust Code Apps crash without error handling. Try-catch handles errors gracefully. Robust, reliable apps. 📝 Try-Catch Basics try { // Code that might throw int result = int.Parse(input); Console.WriteLine($”Result: {result}”); } catch (FormatException ex) { Console.WriteLine($”Invalid format: {ex.Message}”); } catch (OverflowException ex) { Console.WriteLine($”Number too large: {ex.Message}”); } catch (Exception ex) […]
📝 String Interpolation = Clean Formatting String concatenation is messy. String interpolation embeds expressions directly. Readable, concise, elegant. ❌ Concatenation string msg = “Hello, ” + name + “. You are ” + age + ” years old. Today is ” + date.ToShortDateString(); ✅ Interpolation string msg = $”Hello, {name}. You are {age} years old. […]
?? Null-Coalescing = Default Values Null checks are verbose. Null-coalescing operator provides defaults. Clean, concise, safe. ❌ Verbose Null Check string name; if (user != null && user.Name != null) name = user.Name; else name = “Unknown”; ✅ Null-Coalescing string name = user?.Name ?? “Unknown”; 📝 Null-Coalescing Examples // Null-coalescing (??) string name = user?.Name […]
📝 Records = Immutable Data Classes are mutable. Records are immutable. Value-based equality, concise syntax, data-centric. ❌ Class (Mutable) public class Person { public string Name { get; set; } public int Age { get; set; } } ✅ Record (Immutable) public record Person(string Name, int Age); 📝 Record Features // Positional record public record […]
📁 Indexers = Array-Like Access Custom collections need array access. Indexers provide array-like syntax. Clean, intuitive, flexible. 📝 Indexer Basics // Simple indexer public class StringCollection { private string[] _items = new string[10]; public string this[int index] { get => _items[index]; set => _items[index] = value; } } // Usage var collection = new StringCollection(); […]
📦 ValueTuple = Lightweight Tuples Return multiple values without creating classes. ValueTuple is lightweight, value-based, convenient. 📦 Tuple (Reference Type) var result = Tuple.Create(1, “Alice”); int id = result.Item1; string name = result.Item2; ✅ ValueTuple (Value Type) var result = (Id: 1, Name: “Alice”); int id = result.Id; string name = result.Name; 🎯 ValueTuple Examples […]
📦 Object Initializers = Clean Creation Constructors with many params are messy. Object initializers create objects cleanly. Readable, concise, flexible. ❌ Constructor public class User { public string Name { get; set; } public int Age { get; set; } public string Email { get; set; } public User(string name, int age, string email) { […]
🛡️ Nullable Reference Types = Null Safety Null reference is #1 error. Nullable reference types prevent null bugs. Compiler help, fewer crashes, safer code. 📝 Enabling Nullable # Project file enable # Or per file #nullable enable # Disable nullable #nullable disable # Nullable annotations public class Person { // Non-nullable (compiler warns if null) […]
🎯 Pattern Matching = Elegant Code If-else chains are messy. Pattern matching is elegant. Switch expressions, type matching, property patterns. 📝 Pattern Types // Type pattern if (obj is string s) { Console.WriteLine($”String: {s}”); } else if (obj is int i) { Console.WriteLine($”Integer: {i}”); } // Property pattern if (person is { Name: “Alice”, Age: […]
📁 File Scoped Namespaces = Cleaner Code Namespaces add indentation. File scoped namespaces are cleaner. Less nesting, more readable. ❌ Old Style namespace MyApp { namespace Models { public class User { } } namespace Services { public class UserService { } } } ✅ File Scoped namespace MyApp.Models; public class User { } namespace […]
🔌 Default Interface Methods = API Evolution Interfaces break existing code. Default interface methods add methods without breaking. Evolve APIs safely. 📝 Default Interface Basics // Interface with default method public interface ILogger { void Log(string message); // Default implementation void LogError(string message) { Log($”ERROR: {message}”); } // Default implementation void LogWarning(string message) { Log($”WARNING: […]
🚀 Native AOT = Ultra Performance JIT compilation has overhead. Native AOT compiles ahead-of-time. Fast startup, low memory, native performance. 📝 AOT Setup # Project file <Project Sdk=”Microsoft.NET.Sdk”> <PropertyGroup> <OutputType>Exe</OutputType> <TargetFramework>net8.0</TargetFramework> <PublishAot>true</PublishAot> <TrimMode>full</TrimMode> <EnableAotAnalyzer>true</EnableAotAnalyzer> </PropertyGroup> </Project> # Publish with AOT dotnet publish -c Release -r win-x64 –self-contained # Or dotnet publish -c Release -r linux-x64 […]
⚡ Source Generators = Code Generation Boilerplate code is tedious. Source Generators generate code at compile time. Efficiency, consistency, performance. 📝 Source Generator Setup // Create generator project dotnet new console -n MyGenerator cd MyGenerator dotnet add package Microsoft.CodeAnalysis.CSharp dotnet add package Microsoft.CodeAnalysis.Analyzers // Generator class using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Text; using System.Text; [Generator] […]
⚡ Span = Memory Performance Memory allocations slow down apps. Span provides safe, allocation-free access. High-performance, low-allocation code. 📝 Span Basics // Span from array int[] numbers = {1, 2, 3, 4, 5}; Span span = numbers.AsSpan(); // Slice Span slice = span.Slice(1, 3); // {2, 3, 4} // Modify via span slice[0] = 10; […]
🌊 Async Streams = Asynchronous Data Sync streams block. IAsyncEnumerable is async. Process data as it arrives, non-blocking, efficient. 📝 Async Streams Basics // Async stream method async IAsyncEnumerable GenerateNumbersAsync() { for (int i = 0; i < 10; i++) { await Task.Delay(100); // Simulate async work yield return i; } } // Consume async […]
🛡️ Nullable Reference Types = Null Safety Null reference is #1 error. Nullable reference types prevent null bugs. Compiler help, fewer crashes, safer code. ❌ Null (Unsafe) public class User { public string Name { get; set; } public string Email { get; set; } } // Potential null reference ✅ Nullable Reference (Safe) public […]
🎯 Pattern Matching = Elegant Code If-else chains are messy. Pattern matching is elegant. Switch expressions, type matching, property patterns. ❌ If-Else Chains if (obj is string) { … } else if (obj is int) { … } else if (obj is bool) { … } ✅ Pattern Matching switch (obj) { string s => […]
📝 Records = Immutable Data Classes are mutable. Records are immutable. Value-based equality, concise syntax, data-centric. ❌ Class (Mutable) public class Person { public string Name { get; set; } public int Age { get; set; } } ✅ Record (Immutable) public record Person(string Name, int Age); 📝 Record Features // Positional record public record […]
📦 Using = Resource Management Resources leak without cleanup. Using statements ensure disposal. Files, connections, streams — cleanup automatically. ❌ Manual Cleanup (Error-Prone) var file = File.Open(“file.txt”); try { // Use file } finally { file.Dispose(); } ✅ Using Statement (Clean) using var file = File.Open(“file.txt”); // Use file – auto-disposed 📝 Using Examples // […]
⚡ Lambdas = Concise Functions Anonymous methods are verbose. Lambda expressions are concise. One-liners for LINQ, delegates, events. ❌ Anonymous Method Func square = delegate(int x) { return x * x; }; ✅ Lambda Expression Func square = x => x * x; 📝 Lambda Syntax // Basic syntax (parameters) => expression (parameters) => { […]
🧩 Generics = Type-Safe Code Object types are unsafe. Generics create type-safe reusable code. Performance, safety, flexibility. ❌ Object (Unsafe) public class Stack { private object[] items; public void Push(object item) { } public object Pop() { } } Stack s = new Stack(); s.Push(123); // Boxed int i = (int)s.Pop(); // Cast ✅ Generic […]