How to avoid exceptions in C#

Value = value;

   ErrorMessage = errorMessage;

  IsSuccess = isSuccess;

  }

public static Result Success(T value) =>

  new Result(value, null, true);

   public static Result Failure(string errorMessage) =>

  new Result(default(T), errorMessage, false);

}

The class contains two methods, namely Success and Failure. While the first returns a value, the second returns an error message.

The following method shows how you can use the Result class to avoid exceptions in your code.

public Result DivideNumbers(int x, int y)

   {

  if (x == 0)

   {

       return Result.Failure("Division by zero is not allowed.");

   }

     int result = x / y;

     return Result.Success(result);

}

The following code snippet shows how to use the Result pattern with the DivideNumbers method.

var result = Test.DivideNumbers(15, 5);

if (result.IsSuccess)

    Console.WriteLine($"The result is: {result.Value}");

else

    Console.WriteLine($"Error occurred: {result.ErrorMessage}");

Avoid exceptions with the Try-Parse pattern

The Try-Parse pattern is also a good way to avoid exceptions in your application. In C#, this pattern is represented by the TryParse method, which transforms data types and returns a boolean value.

If the parsing process is successful, the output is true, otherwise it is false. You can use this pattern as follows to avoid exceptions in your code.

String str = "1000";

Boolean result = Int32.TryParse(str, out int n);

if (result == true)

   Console.WriteLine($"{n}");

else

   Console.WriteLine("Error in conversion");

Avoid exceptions with Try* methods

When converting data types, you should use the Try-Parse pattern just demonstrated. Otherwise, there are other Try methods – for example TryGetValue.

These methods return false if they were unsuccessful. The output of a successful operation is returned via an out parameter. The following code snippet shows how to achieve this.

int myValue;

if (dictionary.TryGetValue("MyKey", out myValue))

{

    //TryGetValue is successful so you can proceed as usual

}

else

{

    //TryGetValue is unsuccessful so display

    //or return an appropriate error message

}

Avoid exceptions with common condition handling

You can also avoid exceptions by handling conditions that can cause them to be thrown at runtime. For example, before closing the connection to a database, you should check whether a Connection Object is null or is already closed. The following snippet describes this technique.

if (connection!= null && connection.State != ConnectionState.Closed)

{

    connection.Close();

}

If you do not check your database connection instances for null values ​​or explicitly close an already closed connection by calling the Close method, an InvalidOperationException can occur. The following code shows how you should handle this in your code.

try

{

   connection.Close();

}

catch (InvalidOperationException ex)

{

    Console.WriteLine(ex.Message);

}

As mentioned above, frequent exceptions can have a negative impact on application performance. You should therefore take steps to avoid exception handling within your code if it can easily be replaced with logic. A rule of thumb is to check your code for common error conditions. In all other cases, you can benefit from the Result Pattern, which provides a structured error handling method.

One final tip: Exceptions should only be used in exceptional cases – for example, when you already know that an error could occur. And please: Do not use exceptions to manage the control flow of an application. (fm)

Would you like to read more interesting articles on various topics from the IT world? Our free newsletter Delivering everything IT professionals need to know – straight to your inbox!