Daily micro-tips for C#, SQL, performance, and scalable backend engineering.
🚀 Code Like a Rockstar Stop squinting at your braces! Visual Studio 2022’s native Rainbow Braces and Sticky Scroll change the game. Why Your Current Setup Sucks: Deeply nested code is a cognitive drain. When you lose track of which ‘}’ belongs to which ‘if’, you lose flow. Sticky ScrollKeeps the class/method header at the […]
🔍 The ‘Unreproducible’ Bug Fix Sometimes a bug only happens in Production. Instead of guessing, take a .dmp file and open it in Visual Studio. The Pro Flow: Go to Debug -> Managed Memory. VS will show you exactly which objects were alive, their size on the heap, and the ‘Root’ that prevents them from […]
⚡ Senior Debugging Technique When debugging high-concurrency apps, the standard ‘Call Stack’ window is useless because it only shows one thread at a time. Enter Parallel Stacks. This window provides a graphical view of all threads in your system, grouping those that are executing the same code path. It’s the fastest way to identify a […]
Tired of clicking the small arrow to see object properties while debugging? DebuggerDisplay shows the data you want directly in the variable list. [DebuggerDisplay(“User: {Name} (ID: {Id})”)] public class User { public int Id { get; set; } public string Name { get; set; } } The Fix: This attribute forces Visual Studio to show […]
If you are working on a solution with 50+ projects, Visual Studio might feel sluggish. The culprit is often the Diagnostic Tools and IntelliCode cache. Pro Hack: Disable ‘Enable Diagnostic Tools while debugging’ in Tools -> Options -> Debugging -> General. This reduces RAM usage by up to 1.5GB during active sessions. For even better […]
The Problem: Manually running Gulp, Grunt, or Npm scripts every time you build or open a project is a productivity killer. Visual Studio’s Task Runner Explorer allows you to bind specific scripts to IDE events like ‘Project Open’ or ‘Before Build’. Why this is a Life Saver: Consistency: Ensures every developer on the team runs […]
🎯 The Problem Most Developers Face You’re reading code and wondering: “Who wrote this? When was it last changed? Where is it being used?” Opening Git history, searching references – it all takes precious seconds that add up to hours every week. Enter CodeLens: Your Code Intelligence Layer CodeLens displays contextual information directly above methods […]
Running tests manually after every change is slow. Live Unit Testing runs tests automatically as you type and shows results inline. Enable: Test → Live Unit Testing → Start Visual Indicators: Green checkmark = passing tests, Red X = failing tests, Blue dash = not covered by tests. Shows directly in code editor margin! Performance: […]
đź“Ś Executive Summary Developing webhooks or mobile backends usually requires complex tools like Ngrok. Visual Studio’s Dev Tunnels feature changes everything by providing a built-in, secure public URL for your localhost. The Technical Workflow Dev Tunnels create a secure relay between the internet and your local machine. This is critical for testing Stripe webhooks, GitHub […]
🚀 Speed Up Your Coding by 300% Mouse movements are the biggest productivity killers. Master these specific chord combinations to stay in the zone. Action Shortcut Quick Refactor Ctrl + . Search Everything Ctrl + T Peek Definition Alt + F12 Pro Tip: Use Ctrl + Shift + V to access your clipboard ring. It […]
Professional developers don’t just debug; they profile. If your app slows down over time, you likely have a memory leak. The Pro Move: Use the Diagnostic Tools (Alt+F2). Take two snapshots of the heap and use the ‘View Heap’ tool to compare them. Visual Studio will show you exactly which objects are staying in memory […]
Stopping at every iteration in a loop of 1000 items is a nightmare. Conditional breakpoints let you pause only when a specific state is met. The Fix: Right-click a breakpoint -> ‘Conditions’. Enter a C# expression like user.Id == 542 or items.Count > 10. Why? It saves hours of ‘F5-spamming’ and allows you to catch […]
Typing repetitive code structures wastes time. Code snippets insert entire templates with Tab shortcuts. Built-in Snippets: // Type and press Tab twice prop → Creates property with getter/setter ctor → Creates constructor for → Creates for loop foreach → Creates foreach loop try → Creates try-catch block cw → Console.WriteLine() Example Usage: 1. Type “prop” […]
Restarting app after every small change wastes minutes. Hot Reload applies changes to running app instantly. Enable Hot Reload: Click the flame icon 🔥 in Debug toolbar (or Alt+F10) Works While: – App is running (with or without debugger) – Even during breakpoints Supports: – Method body changes – Adding new methods – CSS/XAML changes […]
Constantly opening files to check definitions? Peek Definition shows code inline without switching files. Use Peek: Right-click symbol → Peek Definition (or Alt+F12) Features: – Shows definition in popup window – Edit code directly in peek window – Navigate to related definitions – Multiple peeks can be open simultaneously Keyboard Navigation: – Alt+F12: Peek Definition […]
Large solution taking 5 minutes to load? Solution filters load only selected projects instantly. Create Filter: 1. Right-click solution → Unload unnecessary projects 2. File → Save As Solution Filter (.slnf) 3. Next time: Open .slnf instead of .sln Result: Solution with 50 projects: 5 min load time Filter with 5 projects: 10 sec load […]
Need to debug app that’s already running? Attach debugger instead of restarting from VS. Steps: 1. Debug → Attach to Process (Ctrl+Alt+P) 2. Find your process (e.g., MyApp.exe, w3wp.exe for IIS) 3. Click Attach Debugger attaches to running process – breakpoints work immediately! Common Use Cases: – Debug production issues on server – Debug Windows […]
Editing same text on multiple lines one by one is tedious. Multi-caret lets you edit all simultaneously. Add Carets: Hold Alt + Click where you want additional cursors Or Select Multiple: 1. Select text 2. Press Ctrl+D repeatedly to select next occurrence 3. Type to change all at once Example: // Change all ‘firstName’ to […]
Manually fixing formatting issues wastes time. Let Visual Studio auto-format every time you save. Setup: Tools → Options → Text Editor → Code Cleanup → Check “Run Code Cleanup profile on Save” Choose profile: Full Cleanup What It Does: // Before save (messy): public void test(){int x=5;var y=10;Console.WriteLine(x+y);} // After save (clean): public void Test() […]
Lost track of important variable values when stepping through code? Pin them to keep them visible. How to Pin: // While debugging, hover over any variable var userId = 12345; // Click the pin icon that appears // Variable stays visible even when out of scope Benefits: Pinned variables persist across debug sessions. Close VS, […]
Need to pair program with remote teammates? Live Share turns VS Code into a collaborative editor with shared debugging. # Installation # 1. Install Live Share extension in VS Code # Extensions → Search “Live Share” # Install by Microsoft # 2. Sign in with GitHub/Microsoft account # 3. Start a session # Click Live […]
Debugging your code but accidentally stepping into framework methods like String.Format() or Linq internals? This wastes precious debugging time. The Annoying Problem: var users = GetUsers(); var result = users.Where(u => u.IsActive).ToList(); // Press F11 here // Debugger jumps into: // → Enumerable.cs (framework code) // → Buffer.cs // → List.cs // You just wanted […]
If your Visual Studio builds are taking forever, there’s a game-changing setting most developers miss entirely. The Problem: By default, Visual Studio uses only ONE CPU core for parallel project builds, even if you have 8, 16, or more cores available. This bottleneck can turn a 30-second build into a 2-minute nightmare. The Solution: Tools […]
Ever noticed code behaving differently in Debug vs Release? Root cause Visual Studio injects: Different JIT optimizations Conditional compilation (#if DEBUG) Altered timing (especially async code) Hidden fix Force Release-mode debugging: <PropertyGroup Condition=”‘$(Configuration)’==’Release'”> <DebugType>portable</DebugType> </PropertyGroup> Why this matters Many race conditions only exist in optimized builds.Debug mode can mask real production bugs.
Big solution, many projects… suddenly IntelliSense feels drunk. Root cause Visual Studio keeps: Symbol cache per project Roslyn analysis results Design-time builds running in background These accumulate and slow down parsing. Fix (safe & underrated) Disable design-time builds for large solutions Clear ComponentModelCache periodically %LOCALAPPDATA%\Microsoft\VisualStudio\<version>\ComponentModelCache Why it works Forces VS to rebuild symbol graphs cleanly.
One of the most dangerous Visual Studio behaviors is building and running with a different configuration than you think.You debug Debug, but the app actually runs Release — or worse, a cached build. Why this happens Multiple startup profiles IIS Express vs Kestrel mismatch Configuration Manager not synced across projects Life-saving fix Open Configuration Manager […]
TipUse .slnf (Solution Filter) files to load only the projects you actually need. Why it mattersLarge solutions kill startup time. Filters reduce memory usage and speed up context switching without touching the main solution.
// TODO: optimize cache eviction // HACK: temporary workaround for legacy API View → Task List Why it mattersYou get an in-IDE micro issue tracker without Jira friction. Perfect for solo or small teams.
Large solutions kill startup time and focus. Hidden feature: Solution Filters (.slnf) dotnet slnf create dotnet slnf add MyProject.csproj Why it mattersVisual Studio loads only required projects → faster boot, less RAM, more focus.
Use Solution Filters (.slnf) for large solutions. Instead of loading the entire solution (slow, error-prone), load only what you need. File → Save As Solution Filter Why this mattersDifferent devs load different projects → fewer mismatched dependencies → fewer “but it works here” issues.