Railway Ticket Fare Calculation With Strategy Pattern

Introduction

Design Pattern is a very wonderful part of object-oriented programming. It provides flexibility, extensibility, and clean code features. Railway Ticket Price can be calculated and implemented with the help of design patterns.

Problem Statement

A passenger travels from one station to another station by train and he/she needs a ticket. He pays the fare for the traveled stations and, Railways has some particular rule related to the fare. It is based on stations, senior citizens, festivals, etc.

Railway rule says "If a passenger travels up to 5 stations, then fare is only Rs. 10. But, after the five stations, for every five or less than five stations, an extra fare of Rs. 5 will be charged. If the passenger is a senior citizen, then Railway will offer them some discount. And, some additional fare will be added on the occasion of some particular festivals." 

Example

 

Let us consider there are 15 stations named, one, two, three, four...... fifteen and the passengers are traveling with different cases.

1. If passenger A travels from one to five stations, then he will be charged only Rs. 10.
2. If Passenger B travels from one to six stations, then he will be charged Rs. 15.
3. If Passenger C travels from six to ten station, then he will be charged Rs 15.
4. If Passenger D travels from one to fifteen station, then he will be charged Rs 20. 

Solution

This problem statement can be solved by using "Strategy Desing Pattern." Because different types of fare strategy can be applied based on the context. Below are the different types of fare strategies,

1. Station Fare Rule Strategy
2. Age Fare Rule Strategy
3. Festival Fare Rule Strategy
4. Distance Fare Rule Strategy
5. Class Type like Sleeper, General, First Ac, Second AC, etc. Fare Rule Strategy
6. Basic Fare Rule Strategy
7. Train Type Fare Rule Strategy 

So, each fare calculation algorithm will be written separately for each Fare Rule Strategy and these will not interfere with each other. New fare rule strategy can be added and written in case of new fare rule. So, it will also follow the concept of "Open for Extension and Close for Modification".

 

Diagrams - Depenency Diagram

Class Diagram

 

 

Code Explanation

 

IFareStrategy Interface

This interface defines the common strategy for the calculation of fare so that implementing a class can implement fare algorithm based on the context.

using TrainFair.Models;

namespace TrainFair.FareCalculator
{
    public interface IFareStrategy {
        float GetFare(IFareRule ruleValues, float basicFare);
    }
}

StationRuleFareCalculator class

This class calculates the fare based on the number of stations traveled and some ruleset which has been defined in the section of the problem statement. 

using System;
using TrainFair.Models;

namespace TrainFair.FareCalculator
{
    public class StationRuleFareCalculator : IFareStrategy
    {
        public float GetFare(IFareRule ruleValues, float basicFare) {
            var stationFareRuleModel = ruleValues as StationFareRuleModel;
            if (stationFareRuleModel == null || stationFareRuleModel.StationsCounts <= 0)
                return 0;

            int chargingStations = (int)Math.Ceiling(stationFareRuleModel.StationsCounts / 5.0);
            if (chargingStations <= 1)
                return basicFare;

            int restChargingStations = chargingStations - 1;
            var totalFare = basicFare + restChargingStations * stationFareRuleModel.IncrementalPrice;

            return totalFare;
        }
    }
}

AgeRuleFareCalculator class

 

This class implements the Fare algorithm, especially for the senior citizen. If the traveler is a senior citizen, then a particular dicount will be given to him/her. So, this class implements that algorithm.

using TrainFair.Models;

namespace TrainFair.FareCalculator
{
    public class AgeRuleFareCalculator : IFareStrategy
    {
        public float GetFare(IFareRule ruleValues, float basicFare) {
            var ageFareRuleModel = ruleValues as AgeFareRuleModel;
            if (ageFareRuleModel == null)
                return 0;

            if (ageFareRuleModel.Age < 60) return basicFare;
            var totalFare = basicFare - (basicFare * ageFareRuleModel.Discount);
            return totalFare;
        }
    }
}

FestivalRuleFareCalculator class

This class implements the fare price for the festival season. Some additional price will be added or some particular discount will be offered on the ocassion a particular festival. 

using TrainFair.Models;

namespace TrainFair.FareCalculator
{
    public class FestivalRuleFareCalculator : IFareStrategy
    {
        public float GetFare(IFareRule ruleValues, float basicFare) {
            var festivalFareRuleModel = ruleValues as FestivalFareRuleModel;
            if (festivalFareRuleModel == null)
                return basicFare;

            float totalFare = basicFare + festivalFareRuleModel.FestivalAdditionalFare;
            return totalFare;
        }
    }
}

FareRuleCalculatorContext class

using TrainFair.Models;

namespace TrainFair.FareCalculator
{
    public class FareCalculatorContext {

        private readonly IFareStrategy _fareStrategy;
        public FareCalculatorContext(IFareStrategy fareStrategy) {
            this._fareStrategy = fareStrategy;
        }

        public float GetFareDetails(IFareRule fareRules, float basicFare)
        {
            return _fareStrategy.GetFare(fareRules, basicFare);
        }
    }
}

And, here are some model classes based on the contexts like station fare, age fare, festival fare, etc.

 

IFareRule interface

This is the basic fare rule model class and every model class implements it. 

namespace TrainFair.Models
{
    public interface IFareRule
    {
        int FareRuleId { get; set; }
    }
}

StationFareRuleModel class

 

This class defines the properties for the Station Fare Rule.

namespace TrainFair.Models
{
    public class StationFareRuleModel : IFareRule
    {
        public int FareRuleId { get; set; }

        public int  StationsCounts { get; set; }

        public float IncrementalPrice { get; set; }
    }
}

AgeFareRuleModel class

 

This class defines the properties for the Age in case of a senior citizen. 

namespace TrainFair.Models
{
    public class AgeFareRuleModel : IFareRule
    {
        public int FareRuleId { get; set; }

        public int Age { get; set;  }

        public float Discount { get; set; }
    }
}

FestivalFareRuleModel class

 

This class defines the properties of festival and type of additional price or dicount on festival. 

namespace TrainFair.Models
{
    public class FestivalFareRuleModel : IFareRule
    {
        public int FareRuleId { get; set; }

        public string FestivalName { get; set; }

        public float FestivalAdditionalFare { get; set; }
    }
}

Model properties can be enhanced based on the future requirement and that can be used inside of algorithm classes.

 

Output

Below is the basic console output of the written code.

 

 

 

I have attached the zipped file of code that is in C# language.

 

Conclusion

Here, different types of fare calculation concepts like Station Fare, Age Fare, Festival Fare, Distance Fare, etc. are different in their behavior as their algorithms are different. So, all the algorithms have been isolated into separate classes in order to have the ability to select different algorithm at runtime. And, strategy design pattern is best for this type of case.