CodeBlanks Logo Icon CodeBlanks
Login Register

Putting it together

Combine all parts into a working calculator.

Error handling

In the final lesson we'll add error handling to the calculator. We expect two kinds of errors:

  • FormatException: thrown by double.Parse if the user enters letters instead of a number.
  • DivideByZeroException: thrown by the method if the divisor is zero.

To catch these errors we put the risky code inside try and an error message inside catch. The program then shows a clear message instead of crashing.

Project complete

Congratulations! You've completed the five-lesson calculator project. Along the way you learned to:

  • design a Calculator class with class
  • read input with Console.ReadLine and double.Parse
  • write arithmetic methods and throw DivideByZeroException
  • build a menu loop with switch and while
  • handle errors with try/catch

These patterns are used the same way in real-world applications.

Practice Add error handling with try/catch

Wrap the loop body in a try block. Add a default branch to the switch that throws new FormatException("Invalid operation"); for unknown operators. Add two catch blocks: catch (DivideByZeroException) prints Console.WriteLine("Division by zero error"); and catch (FormatException) prints Console.WriteLine("Invalid input");. The program now catches errors without crashing.

Starter code

Program.cs
using System;

class Calculator
{
    public double Add(double a, double b) { return a + b; }
    public double Subtract(double a, double b) { return a - b; }
    public double Multiply(double a, double b) { return a * b; }
    public double Divide(double a, double b)
    {
        if (b == 0) throw new DivideByZeroException("Division by zero");
        return a / b;
    }
}

class Program
{
    static void Main()
    {
        var calc = new Calculator();
        // Test cases: (operator, a, b) — some are invalid
        string[][] tests = {
            new string[] { "+", "20", "5" },
            new string[] { "/", "20", "0" },
            new string[] { "?", "20", "5" }
        };
        int i = 0;
        while (i < tests.Length)
        {
            // Add error handling with try/catch
            string op = tests[i][0];
            double a = double.Parse(tests[i][1]);
            double b = double.Parse(tests[i][2]);
            double result = 0;
            switch (op)
            {
                case "+":
                    result = calc.Add(a, b);
                    break;
                case "-":
                    result = calc.Subtract(a, b);
                    break;
                case "*":
                    result = calc.Multiply(a, b);
                    break;
                case "/":
                    result = calc.Divide(a, b);
                    break;
            }
            Console.WriteLine(result);
            i++;
        }
    }
}

Sample solution

Program.cs
using System;

class Calculator
{
    public double Add(double a, double b) { return a + b; }
    public double Subtract(double a, double b) { return a - b; }
    public double Multiply(double a, double b) { return a * b; }
    public double Divide(double a, double b)
    {
        if (b == 0) throw new DivideByZeroException("Division by zero");
        return a / b;
    }
}

class Program
{
    static void Main()
    {
        var calc = new Calculator();
        // Test cases: (operator, a, b) — some are invalid
        string[][] tests = {
            new string[] { "+", "20", "5" },
            new string[] { "/", "20", "0" },
            new string[] { "?", "20", "5" }
        };
        int i = 0;
        while (i < tests.Length)
        {
            try
            {
                string op = tests[i][0];
                double a = double.Parse(tests[i][1]);
                double b = double.Parse(tests[i][2]);
                double result = 0;
                switch (op)
                {
                    case "+":
                        result = calc.Add(a, b);
                        break;
                    case "-":
                        result = calc.Subtract(a, b);
                        break;
                    case "*":
                        result = calc.Multiply(a, b);
                        break;
                    case "/":
                        result = calc.Divide(a, b);
                        break;
                    default:
                        throw new FormatException("Invalid operation");
                }
                Console.WriteLine(result);
            }
            catch (DivideByZeroException)
            {
                Console.WriteLine("Division by zero error");
            }
            catch (FormatException)
            {
                Console.WriteLine("Invalid input");
            }
            i++;
        }
    }
}

Expected output

25
Division by zero error
Invalid input

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 Which exception is thrown when an invalid number is entered?

  • DivideByZeroException
  • FormatException Correct answer
  • IndexOutOfRangeException
  • InvalidOperationException

Explanation: double.Parse throws FormatException on invalid format.

2 Match each exception or construct to its meaning

Term Meaning
FormatException Invalid number format
DivideByZeroException Division by zero
try Protected code block
catch Catching the error

3 Start the catch block

Question 
try {
    result = calc.Divide(a, b);
} ____ (DivideByZeroException) {
    Console.WriteLine("Division by zero error");
}
Answer 
try {
    result = calc.Divide(a, b);
} catch (DivideByZeroException) {
    Console.WriteLine("Division by zero error");
}

Explanation: the catch block catches the exception.

All lessons in Beginner

1 C# basics

  1. What is C# and .NET?
  2. Your first program
  3. Console.WriteLine
  4. Comments
  5. Compile and run
  6. Summary - C# basics

2 Variables

  1. Declaring variables
  2. The var keyword
  3. Constants
  4. Type inference
  5. Variable scope
  6. Summary - Variables

3 Data types

  1. Integer types
  2. Floating-point types
  3. Char and bool
  4. String basics
  5. Value and reference types
  6. Summary - Data types

4 Project: Calculator

  1. Project design
  2. Add and subtract
  3. Multiply and divide
  4. Error handling
  5. Putting it together

5 Operators

  1. Arithmetic operators
  2. Assignment operators
  3. Comparison operators
  4. Logical operators
  5. Bitwise operators
  6. Summary - Operators

6 String basics

  1. Declaring strings
  2. String interpolation
  3. String concatenation
  4. String.Format
  5. Verbatim strings
  6. Summary - String basics

7 Conditionals

  1. The if statement
  2. else and else if
  3. The switch statement
  4. Pattern matching
  5. The ternary operator
  6. Summary - Conditionals

8 Loops

  1. The for loop
  2. The while loop
  3. The do-while loop
  4. The foreach loop
  5. break and continue
  6. Summary - Loops

9 Project: Shopping cart

  1. Cart design
  2. Adding products
  3. Calculating totals
  4. Updating quantity
  5. Putting it together

10 Arrays

  1. Declaring arrays
  2. Array access
  3. Array length
  4. Multidimensional arrays
  5. Jagged arrays
  6. Summary - Arrays

11 Array methods

  1. Array.Sort
  2. Array.Reverse
  3. Array.IndexOf
  4. Array.Copy
  5. Array.Find and FindAll
  6. Summary - Array methods

12 Collections

  1. List<T> basics
  2. List<T> methods
  3. Dictionary<K,V>
  4. Dictionary access
  5. HashSet<T>
  6. Summary - Collections

13 Methods

  1. Defining methods
  2. Return values
  3. void methods
  4. Method overloading
  5. Local functions
  6. Summary - Methods

14 Method parameters

  1. Parameterized methods
  2. Default parameters
  3. The params keyword
  4. ref parameters
  5. out parameters
  6. Summary - Method parameters

15 Project: To-do CLI

  1. Task model
  2. Adding tasks
  3. Listing tasks
  4. Completing tasks
  5. Putting it together

16 Advanced string methods

  1. Substring
  2. IndexOf and LastIndexOf
  3. Split and Join
  4. Trim and Pad
  5. Replace
  6. Summary - Advanced strings

17 Console I/O

  1. Console.ReadLine
  2. Console.ReadKey
  3. int.Parse and TryParse
  4. double.Parse
  5. Console formatting
  6. Summary - Console I/O

18 Enums

  1. Defining enums
  2. Enum values
  3. Enum casting
  4. Enum.Parse
  5. Flags attribute
  6. Summary - Enums

19 Exception basics

  1. try/catch
  2. finally block
  3. throw
  4. The Exception class
  5. Custom exceptions
  6. Summary - Exception basics

20 Beginner final

  1. Project design
  2. Data model
  3. Business logic
  4. Error handling
  5. Putting it together