Generic Calculator

In this article I shall demonstrate how to use Generics in developing a sample calculator application.

Before going through this article I strongly recommend to go through the basics of Generics in C#. There are lot of articles in c-sharpcorner.com.

In order to demonstrate, I have developed a console application.

In this sample it is possible to perform mathematical operations for any number of inputs.

Step 1: Create an abstract class as shown

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace GenericCalculator

{

       public abstract class AbstractCalculator<T>
    {
        public abstract T Add(T input1, T input2);
        public abstract T Sub(T input1,T input2);

        public abstract T Multiply(T input1,T input2);
        public abstract T Divide(T input1,T input2);
    }

}


This class takes a generic data type.

Step 2: Create an IntCalculator class which performs all actions with integer as inputs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace
GenericCalculator

{
    public class IntCalculator : AbstractCalculator<int>
    {
        public override int Add(int input1, int input2)
        {
            return input1 + input2;
        }

        public override int Sub(int input1, int input2)
        {
            return input1 - input2;
        }

        public override int Multiply(int input1, int input2)
        {
          
            return input1 * input2;
        }

        public override int Divide(int input1, int input2)        {
            return input1 / input2;
        }

    }
}

Step 3: Create a DoubleCalculator class which performs all actions with double as inputs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace
GenericCalculator

{
    class DoubleCalculator:AbstractCalculator<double>
    {
        public override double Add(double input1, double input2)
        {
            return input1 + input2;
        }
       public override double Sub(double input1, double input2)
        {
            return input1 - input2;
        }

        public override double Multiply(double input1, double input2)
        {
            return input1 * input2;
        }


        public override double Divide(double input1, double input2)
        {
            return input1 / input2;
        }
    }
}


Like the same way we can create classes for decimal, float etc.

Step 4: Create a class which performs the various actions in a calculator based on the incoming input parameters as shown.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GenericCalculator
{
   public class ArithmeticOperation <T>

    {
       AbstractCalculator<T> _myCalculator;


       public ArithmeticOperation(AbstractCalculator<T> myCalculator)
       {
           this._myCalculator = myCalculator;
       }
       public T Sum(List<T> items)
       {
           dynamic sum=0;

           for (int i = 0; i < items.Count; i++)
           {
               sum = _myCalculator.Add(sum, items[i]);
           }


           return sum;
       }

       public T Sub(List<T> items)
       {
           dynamic sub = 0;
           for (int i = 0; i < items.Count; i++)
           {
               sub = _myCalculator.Sub(sub, items[i]);
           }
           return sub;
       }

       public T Multiply(List<T> items)
       {
           //val is set to 1 for the first multiplication attempt.
          dynamic mul=1;
         
          for (int i = 0; i < items.Count; i++)
           {
               mul = _myCalculator.Multiply(mul, items[i]);
           }
           return mul;
       }
       public T Divide(List<T> items)
       {
           dynamic div = 1;
           for (int i = 0; i < items.Count; i++)
           {
               if (div == 1)
               {

                   // Initially the val is set to one and the first value in items collection is set as the
first parameter to didvide function.


                   div = _myCalculator.Divide(items[i], div);
               }
               else

               {
                   div = _myCalculator.Divide(div, items[i]);

               }
           }

           return div;
       }      
    }
}


This class has got a parameter of type AbstractCalculator in its constructor. Any class which inherits this abstract class can be passed as parameter to the constructor of this class.

All the mathematical functions accept a List<T> collection.

Step 5: Client Code (Console Application)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GenericCalculator
{
    class Program
    {
        static void Main(string[] args)
        {
            ArithmeticOperation<int> intOperation = new ArithmeticOperation<int>(new IntCalculator());
            ArithmeticOperation<double> doubleOperation = new ArithmeticOperation<double>(new DoubleCalculator());
            List<int> numbers = new List<int> {1,2,3,4,5 };

            List<double> doubleNumbers = new List<double> {1.1, 2.2, 3.3, 4.4, 5.5};
            Try
            {
                Console.WriteLine("Integer Calculation");

                Console.WriteLine("************************************************************");
                Console.WriteLine("Addition : {0}", intOperation.Sum(numbers));
                Console.WriteLine("Substraction : {0}", intOperation.Sub(numbers));
                Console.WriteLine("Mulitplication : {0}", intOperation.Multiply(numbers));
                Console.WriteLine("Division : {0}", intOperation.Divide(numbers));

              Console.WriteLine("************************************************************");
               Console.WriteLine("Double Calculation");

            Console.WriteLine("*********************************************************
**"
);
                Console.WriteLine("Addition : {0}", doubleOperation.Sum(doubleNumbers));
                Console.WriteLine("Substraction : {0}", doubleOperation.Sub(doubleNumbers));
                Console.WriteLine("Mulitplication : {0}", doubleOperation.Multiply(doubleNumbers));
                Console.WriteLine("Division : {0}", doubleOperation.Divide(doubleNumbers));

            }
            catch (DivideByZeroException ex)
            {
                Console.WriteLine("Division Error : {0}", ex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine(" Error : {0}", ex.Message);
            }

            Console.ReadLine();
        }
    }
}


ArithmeticOperation<int> intOperation = new ArithmeticOperation<int>(new IntCalculator());

 To the constructor of ArithmeticOperation class an instance of the IntCalculator class is passed as the ArithmeticOperation class is of an integer data type.

ArithmeticOperation<double> doubleOperation = new ArithmeticOperation<double>(new DoubleCalculator());

To the constructor of ArithmeticOperation class an instance of the DoubleCalculator class is passed as the ArithmeticOperation class is of a double data type.

For a better understanding I have shared the source code.

Output

Happy Coding!!!
 

Ebook Download
View all
Learn
View all