Exception Safe Coding Patterns In C# Complete Guide

Exception Safe Coding Patterns in C#

1. RAII (Resource Acquisition Is Initialization):

   • Implement this pattern through constructors and destructors in C#. When an object manages resources such as file handles, network connections, or memory, it should acquire these resources in its constructor and release them in its destructor (or finalizer).
   • Example:

     public class ResourceHandler : IDisposable
     {
         private IntPtr resource;
     
         public ResourceHandler()
         {
             this.resource = AllocateResource();
         }
     
         ~ResourceHandler()
         {
             this.Dispose(false);
         }
     
         public void Dispose()
         {
             this.Dispose(true);
             GC.SuppressFinalize(this);
         }
     
         protected virtual void Dispose(bool disposing)
         {
             if (this.resource != IntPtr.Zero)
             {
                 FreeResource(this.resource);
                 this.resource = IntPtr.Zero;
             }
         }
     
         private IntPtr AllocateResource() { /* ... */ }
         private void FreeResource(IntPtr resource) { /* ... */ }
     }
     

2. Using Statement:

   • The using statement ensures that the Dispose method of an object is called at the end of the statement block, even if an exception occurs.
   • Example:

     using (var stream = new FileStream("file.txt", FileMode.Open))
     {
         // Work with the stream
     } // Automatic call to Dispose() here
     

3. Try-Catch Block:

   • Use try-catch blocks to handle specific exceptions and allow the program to continue running or to fail gracefully.
   • Avoid catching System.Exception or other too wide-ranging exceptions unless absolutely necessary, as this can hide bugs and make debugging more difficult.
   • Example:

     try
     {
         // Code that might throw an exception
         int result = Divide(5, 0);
     }
     catch (DivideByZeroException ex)
     {
         // Handle specific exception
         Console.WriteLine($"Error occurred: {ex.Message}");
     }
     catch (Exception ex)
     {
         // Handle unexpected exceptions (if necessary)
         Console.WriteLine($"Unexpected error occurred: {ex.Message}");
     }
     finally
     {
         // Cleanup code
         Console.WriteLine("Cleanup process");
     }
     
     int Divide(int numerator, int denominator)
     {
         return numerator / denominator;
     }
     

4. Avoiding Unnecessary Stack Unwinding:

   • Rethrow exceptions correctly to avoid creating false stack traces. Use throw; instead of throw ex; to maintain the original stack information.
   • Example:

     try
     {
         // Some risky operation
         ProcessData();
     }
     catch (CustomException ex)
     {
         LogError(ex);
         throw; // Rethrows with original stack trace intact
     }
     
     void ProcessData() { /* ... */ }
     void LogError(Exception ex) { /* ... */ }
     

5. Catch-Filter Blocks:

   • Introduce exception filters in recent C# versions to handle only the exceptions satisfying certain conditions without unwinding the stack excessively.
   • Example:

     try
     {
         // Risky code
     }
     catch (SomeSpecificException ex) when (ex.ErrorCode == 404)
     {
         // Handle only if ErrorCode is 404
         Console.WriteLine("Resource not found.");
     }
     

6. Custom Exceptions:

   • Define custom exceptions to provide more information and context about what went wrong. This aids in accurate error handling and recovery.
   • Example:

     public class BusinessException : Exception
     {
         public string AdditionalInfo { get; }
     
         public BusinessException(string message, string additionalInfo) : base(message)
         {
             this.AdditionalInfo = additionalInfo;
         }
     }
     
     throw new BusinessException("Invalid input", "Input value must be greater than zero");
     

7. Ensure No Side Effects in Constructors:

   • Constructors should not perform operations that might fail (such as database calls or file operations). Instead, use factory methods or initialization methods that can handle exceptions.
   • Example:

     public class DatabaseConnection
     {
         private SqlConnection sqlConnection;
     
         private DatabaseConnection(SqlConnection sqlConnection)
         {
             this.sqlConnection = sqlConnection;
         }
     
         public static DatabaseConnection Create(string connectionString)
         {
             try
             {
                 var conn = new SqlConnection(connectionString);
                 conn.Open();
                 return new DatabaseConnection(conn);
             }
             catch
             {
                 // Handle exception
                 conn.Close();
                 throw;
             }
         }
     }
     

8. Transactional Idempotence:

   • Ensure that operations inside transactional contexts are idempotent (meaning they can be executed multiple times without changing the result beyond the initial application). This prevents corruption due to partial failures within transactions.
   • Example:

     using (var transactionScope = new TransactionScope())
     {
         // Idempotent actions
         UpdateOrderStatus(orderId, OrderStatus.Processed);
         transactionScope.Complete();
     }
     

9. Consistent State Maintenance:

   • Use strategies to maintain consistent state if operations fail. For example, use backups, rollback mechanisms, or atomic updates.
   • Example:

     public void PerformOperation(string data)
     {
         string backupData = LoadBackupData();
         try
         {
             SaveDataToDatabase(data);
             DeleteOldData();
         }
         catch (Exception ex)
         {
             // On failure, restore from the backup
             RestoreFromBackup(backupData);
             throw;
         }
     }
     

10. Graceful Degradation:

    • Design systems to degrade gracefully under exceptional conditions rather than falling completely. Provide fallbacks and alternate routes for execution.
    • Example:

      public void SendEmail(string recipient, string message)
      {
          try
          {
              SmtpClient.Send(recipient, "Default Sender", message);
          }
          catch (SmtpException)
          {
              // Fallback plan - send email via alternative method
              AlternativeEmailService.Send(recipient, "Default Sender", message);
          }
      }
      

11. Fail Fast:

    • Detect issues early and fail fast to prevent propagation of bad states throughout the system. Validate input parameters and ensure preconditions are met before proceeding.
    • Example:

      public void ProcessDocument(Document doc)
      {
          if (doc == null)
          {
              throw new ArgumentNullException(nameof(doc));
          }
      
          if (!doc.IsValid())
          {
              throw new ArgumentException("Document is invalid.", nameof(doc));
          }
      
          // Rest of the method implementation
      }
      

12. Atomic Operations:

    • Perform operations atomically (as a single, indivisible unit). Atomic operations are important because they cannot leave a system in an inconsistent state if interrupted by an exception.
    • Example:

      public class ConcurrentCounter
      {
          private int count;
      
          public void Increment()
          {
              Interlocked.Increment(ref count);
          }
      }
      

13. Deferred Commitment:

    • Delay committing changes until the entire operation can be guaranteed to succeed. This helps in undoing actions if something goes wrong at a later stage.
    • Example:

      public void TransferFund(Account fromAccount, Account toAccount, decimal amount)
      {
          var fromBalanceSnapshot = fromAccount.GetBalance();
      
          try
          {
              fromAccount.Withdraw(amount, false);
              toAccount.Deposit(amount, false);
      
              // Only commits if the above steps succeed
              fromAccount.Commit();
              toAccount.Commit();
          }
          catch (Exception)
          {
              // Rollback changes if there's an exception
              fromAccount.Revert(fromBalanceSnapshot);
              throw;
          }
      }
      

14. Logging and Diagnostics:

    • Ensure thorough logging of exceptions to diagnose and correct the underlying issue. Logging should capture as much context and state as possible at the point of failure.
    • Example:

      try
      {
          // Risky operation
      }
      catch (Exception ex)
      {
          LogException(ex); // Custom logging function
          throw; // Re-throw to upper layers if unhandled
      }
      
      private void LogException(Exception ex)
      {
          // Detailed logging including stack traces, user info etc.
          Debug.WriteLine(ex.Message + "\n" + ex.StackTrace);
          // Also log to file or centralized logging service
      }
      

15. Design By Contract:

    • Employ design-by-contract principles with preconditions, postconditions, and invariants. These help in specifying the assumptions and expectations of classes and methods.
    • Example: