Tips for Exception Handling in Software Development

A few years ago, I thought my error handling in .NET was “clean”. Until one code review changed my perspective. A teammate asked me a simple question: “If this method fails… how do I know what can happen?” The method returned a DTO. But internally, it could throw three different domain exceptions. And that’s when it hit me. The signature was lying. It promised a result. It silently relied on runtime explosions. That’s when I started rethinking how I model failure in my systems. Not infrastructure failures. Not unexpected crashes. I’m talking about normal business outcomes: • Not found • Conflict • Validation errors Those aren’t exceptional. They’re part of the domain. When we use exceptions for control flow: • Behavior becomes implicit • Contracts become misleading • Testing becomes exception-driven • Code reading becomes non-linear The bigger the system grows, the more painful this becomes. Architecture isn’t just about patterns. It’s about honesty in contracts. When success and failure are explicit, everything changes: The API becomes predictable. The flow becomes readable. The intent becomes obvious. Exceptions still matter, but not for modeling normal business logic. That small shift in thinking improved the clarity of every backend I’ve worked on since. I wrote a detailed breakdown of how I implement the Result pattern in real applications, including clean HTTP mapping and domain error modeling: 👉 https://lnkd.in/dkyu4JQN Curious, how do you handle expected failures in your production systems? __ 📌 Don't miss the next newsletter issue, 19,000 engineers will read it, join them: thecodeman.net ♻️ Repost to others. 📂 You can save this post for later, and you should do it. ➕ Follow me ( Stefan Đokić ) to learn .NET and Architecture every day at 9 AM GMT-0.

Stop throwing exceptions for validation. Here's a better way: Last week I was reviewing a pull request. The code worked. Tests passed. But every business rule violation was handled by throwing an exception. Invalid email? throw new ValidationException(). Username taken? throw new ConflictException(). User not found? throw new NotFoundException(). It works, but it's a problem for 3 reasons: 𝟭. 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 Throwing exceptions is expensive. The runtime unwinds the stack, captures a stack trace, and allocates memory. For something that happens on every invalid form submission, that's wasteful. 𝟮. 𝗜𝗻𝘁𝗲𝗻𝘁 When you see a throw, you expect something has gone seriously wrong. Using exceptions for "email already taken" dilutes their meaning. Is this a bug or a business rule? You can't tell at a glance. 𝟯. 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗲 𝗳𝗼𝗿 𝗲𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝗮𝗹 𝘁𝗵𝗶𝗻𝗴𝘀 A user entering an invalid email is not exceptional. It happens all the time. 𝗧𝗵𝗲 𝗳𝗶𝘅: 𝗧𝗵𝗲 𝗥𝗲𝘀𝘂𝗹𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 Instead of throwing, you return a Result<T> that explicitly says: "this either worked, or here's what went wrong." A simple class with two static methods: Result.Success(value) and Result.Failure(error). No NuGet packages. No frameworks. Now your service returns Result<User> instead of throwing. The method signature tells you everything. It returns a result, meaning it might fail, and you have to handle it. No surprises. 𝗧𝗵𝗲 𝗲𝗻𝗱𝗽𝗼𝗶𝗻𝘁 𝗯𝗲𝗳𝗼𝗿𝗲: try/catch with a block for every exception type. Each new business rule means another custom exception class and another catch block. 𝗧𝗵𝗲 𝗲𝗻𝗱𝗽𝗼𝗶𝗻𝘁 𝗮𝗳𝘁𝗲𝗿: Two lines. Call the service, map the result to HTTP. A small ToHttpResult extension method translates error types to status codes (Validation → 400, Conflict → 409, NotFound → 404). One method, used everywhere. 𝗪𝗵𝗮𝘁 𝗮𝗯𝗼𝘂𝘁 𝗲𝘅𝗶𝘀𝘁𝗶𝗻𝗴 𝗹𝗶𝗯𝗿𝗮𝗿𝗶𝗲𝘀? If you don't want to roll your own, two solid options: → FluentResults: lightweight, flexible, supports multiple errors → ErrorOr: uses discriminated unions, plays nicely with minimal APIs Both are great. But I'd recommend understanding the pattern from scratch first before reaching for a library. 𝗧𝗵𝗲 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Exceptions should be for unexpected failures, infrastructure errors, things that shouldn't happen during normal operation. For everything else (validation, business rules, expected failures), the Result pattern gives you faster code, clearer intent, and easier testing. Full tutorial with the Result<T> implementation, error definitions, and HTTP mapping code 👇 https://lnkd.in/gGjBtacR

Rethrowing Exceptions in C#: Preserve Your Stack Trace! Ever caught an exception, logged it, and then wanted to pass it along? That's where rethrowing comes in, and it's crucial to get it right! Why Rethrow? ▪️ Logging & Context: Add details before the error continues its journey. ▪️ Partial Handling: Deal with what you can, then let others handle the rest. ▪️ Maintaining Flow: Don't let errors disappear silently. The Golden Rule: throw; NOT throw ex; This is the most important takeaway. ▪️ throw; (Correct): This rethrows the original exception, keeping its precious stack trace intact. This trace is your debugging lifeline, showing exactly how the error came to be. ▪️ throw ex; (Incorrect): This creates a new exception throw, wiping out the original stack trace. You'll lose vital information, making debugging a nightmare. Why the Stack Trace Matters: Imagine a complex application with nested method calls. If you lose the stack trace, you'll be left guessing where the error originated. With the original trace, you can pinpoint the exact line of code that caused the problem Advanced Scenarios: ▪️ ExceptionDispatchInfo: For complex cases, especially with async code, this helps preserve stack traces across boundaries. ▪️ Exception Wrapping: If you need to add context, wrap the original exception in a new one, keeping the original as the InnerException. In short: When rethrowing exceptions, always use throw;. Preserve your stack trace, save yourself debugging headaches, and write more robust code. Happy coding!

💡 .𝗡𝗘𝗧 𝗧𝗶𝗽 - 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 𝘃𝘀. 𝗥𝗲𝘀𝘂𝗹𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 🔥 When you're coding, you'll run into errors, it's just part of the deal. But the way you handle those errors can really shape how clean, efficient, and predictable your application is. Two common approaches are 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 and the 𝗥𝗲𝘀𝘂𝗹𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻. But how do you decide when to use each one? ✨ 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀: 𝙀𝙭𝙘𝙚𝙥𝙩𝙞𝙤𝙣𝙨 are used to handle unexpected errors that disrupt the normal flow of execution. In many programming languages, there is a built-in exception handling mechanism to catch errors, log them, and manage the flow accordingly. 𝗪𝗵𝗲𝗻 𝘁𝗼 𝘂𝘀𝗲: ✅ For truly unexpected or exceptional errors (e.g., file not found, network issues). ✅ When an error is severe enough to interrupt the current operation and needs to propagate up for centralized handling. However, exceptions can come with performance overhead, especially in high-performance scenarios. Using exceptions for expected errors might be inefficient. ✨ 𝗥𝗲𝘀𝘂𝗹𝘁 𝗣𝗮𝘁𝘁𝗲𝗿𝗻: 𝙏𝙝𝙚 𝙍𝙚𝙨𝙪𝙡𝙩 𝙋𝙖𝙩𝙩𝙚𝙧𝙣 is an alternative to exceptions. It involves returning a result that encapsulates both success and failure, typically using a custom result object. This approach makes error handling more predictable and cleaner, especially in applications that deal with many errors as part of the normal flow. 𝗪𝗵𝗲𝗻 𝘁𝗼 𝘂𝘀𝗲: ✅ For expected errors (e.g., invalid user input, failure to find a resource). ✅ When you want to handle errors explicitly without halting the operation and in cases where the error is part of normal behavior. 𝙏𝙝𝙚 𝙍𝙚𝙨𝙪𝙡𝙩 𝙋𝙖𝙩𝙩𝙚𝙧𝙣 helps avoid the performance cost of exceptions and gives you more control over the error handling process. 🤔 𝗗𝗲𝗰𝗶𝗱𝗶𝗻𝗴 𝗕𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲 𝗧𝘄𝗼 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵𝗲𝘀 🌟 𝙀𝙭𝙘𝙚𝙥𝙩𝙞𝙤𝙣𝙨 are better suited for handling unexpected errors that fall outside the normal flow of the program. 🌟 𝙏𝙝𝙚 𝙍𝙚𝙨𝙪𝙡𝙩 𝙋𝙖𝙩𝙩𝙚𝙧𝙣 is ideal for handling expected errors or when there's a need to avoid the performance overhead of exceptions. ❓What do you think? Comment below👇 🎥 Subscribe to my YouTube channel for tutorials, tips, and everything you need to level up your coding skills.♥️👇 https://lnkd.in/gER56NV4 ♻️ If this content is useful, 𝙧𝙚𝙥𝙤𝙨𝙩 to spread the knowledge. 👉 Please follow me (Poorna Soysa) and click the notification bell icon (🔔) on my profile to receive notifications for all my upcoming posts. 𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴! #DotNET #CSharp #Exception #ResultPattern #DotNETDevelopers #CleanCode #Programming

Interview-Style Explanation of Try–Except–Finally Flow: #Step 1: TRY block This is where we keep the risky code. For example, reading a sales file or performing a join. If it works fine, execution continues normally. #Step 2: IF error happens → EXCEPT block If something goes wrong, control immediately jumps to the except block. Here, we can log the error, handle bad records, or provide default values. So the pipeline doesn’t crash. #Step 3: FINALLY block (always runs) No matter what happens — success or error — the finally block always runs. This is where we do cleanup, like closing Spark sessions, releasing connections, or sending job completion logs. Simplified Flow (you can even draw on a board if asked): TRY → runs risky code │ ├── Success → Continue normally → FINALLY runs │ └── Error → Go to EXCEPT (handle error) → FINALLY runs #RetailExample in Interview Style In my retail project, I wrapped the daily sales file ingestion inside a try block. If the file existed → job continued normally. If the file was missing → except block logged the error and skipped that region. Finally → the Spark session was closed and job completion was logged. So no matter what, the pipeline cleaned up properly. Think of it like a seatbelt in a car: You try driving → if everything goes fine, great. If an accident happens, the seatbelt (except block) protects you. And at the end of the drive, you always stop the car and lock it (finally block). Karthik K. Shivani Bakhade #PySpark #ApacheSpark #BigData #DataEngineering #DataEngineer #ETL #ErrorHandling #TryCatch #DataPipelines #CloudDataEngineering #DataQuality #RetailAnalytics #ResilientSystems

Stop Throwing Exceptions — Try This Instead Exceptions are often overused in C# projects. While they are useful for exceptional scenarios, throwing exceptions for expected conditions can make your code slower, harder to read, and more difficult to maintain. Instead, consider using the Result Pattern. It's a smarter alternative when handling predictable errors or failures, avoiding the overhead of exception handling. Libraries like CSharpFunctionalExtensions by Vladimir Khorikov make this approach simple and effective, allowing you to clearly communicate success or failure states without throwing exceptions. Benefits of the Result Pattern: • Performance: Avoids the high cost of exception handling, especially in scenarios where failures are expected. • Readability: Makes the flow of success and failure explicit, improving readability. • Clarity: The code becomes more predictable, as the path for handling errors is clearly defined. Of course, there are trade-offs. Using the Result Pattern can sometimes lead to more boilerplate code, and it may take a bit of practice to get used to. For simple cases, creating your own minimal Result<T> class might be a great alternative, allowing flexibility without extra dependencies. Have you tried using the Result Pattern instead of exceptions? How did it impact your code quality? #CSharp #DotNet #ErrorHandling #CleanCode #ResultPattern

How do you handle errors in your code? Some use exceptions for flow control to fail fast. But in C#, the caller has no idea what to catch. It's not in the method signature. 𝗠𝘆 𝗿𝘂𝗹𝗲: Use exceptions for exceptional cases. For expected failures, make it explicit. Use the 𝗥𝗲𝘀𝘂𝗹𝘁 𝗽𝗮𝘁𝘁𝗲𝗿𝗻. It clearly signals: this method can fail. The caller must check, but this is a good thing. Bonus: it can improve throughput compared to throwing exceptions. Learn how to apply it: https://lnkd.in/eJVWxgNN Is it time to rethink your error handling?