SOLID Principles in Swift - ( Single Responsibility Principle(SRP), Open/Closed Principle, Liskov Substitution Principle, Interface Segregation, Dependency Inversion)

 

SOLID Principles in Swift

1. Single Responsibility Principle 
2. Open/Closed Principle 
3. Liskov Substitution Principle 
4. Interface Segregation 
5. Dependency Inversion

S - Single Responsibility Principle(SRP) 

Single Responsibility Principle (SRP) is that every class, module, or function in a program should have one responsibility(Task) in a program.

Example:-  A Simple Class For multiple Responsibility 

class SimpleHandler { 

    

    func simpleHandle() {        

        let data = requestToDataAPI()        

        let array = parseToResponse(data: data)        

        saveToDatabase(array: array)    

    }   

  

    private func requestToDataAPI() -> Data {        

        // Network request and wait the response    

        return Data()

    } 

    

    private func parseToResponse(data: Data) -> [String] {        

        // Parse the network response into array  

        return []

    }  

   

    private func saveToDatabase(array: [String]) {        

        // Save parsed response into database   

        print(array)

    }

}

This Simple class perform multiple Responsibility like first network, second parsing data and last loadData Binding data 

Example:-   It states that every module or Class should have only one responsibility.

class SrpHandler {

    let api: APIHandler

    let parse: ParsingData

    let datahander: DataHandler

    init(api: APIHandler, 

    parse: ParsingData, 

    datahander: DataHandler) {

        self.api = api

        self.parse = parse

        self.datahander = datahander

    }

    func handler(){

        let data = api.reqDataToApi()

        let array = parse.parseResponse(data: data)

        datahander.loadDataUI(array: array)

    }

}

// Network request and wait the response 

class APIHandler {

    func reqDataToApi() -> Data{

        return Data()

    }

}

// Parse the network response into array 

class ParsingData {

    func parseResponse(data: Data) -> [String]{

        return []

    }

}

// Save parsed response into database

class DataHandler {

    func loadDataUI(array: [String]){

        print(array)

    }

}

O - Open/Closed Principle

Open means - Open for extension 

closed means - closed for modification.

Open for Extension You should be able to extend or change the behavior of a class without effort. mean If you have to change in an existing class or change the behaviour.

Closed For Modification You must extend a class without changing the implematation

L - Liskov Substitution Principle (LSP)

The Liskov Substitution principle :-  A Derived class should be substitutable for its base class without affecting the correctness of the program.

Or

If you have a reference to a base class,  you should be able to substitute a derived class without breaking the program.

Example: - 

import Foundation

 

class Rectangle {

    

    var width: Double

    var height: Double

    

    init(width: Double, height: Double){

        self.width = width

        self.height = height

    }

    

    func calculateArea()-> Double{

        return width * height

    }

}

class Square: Rectangle {

    

    override var width: Double {

        didSet{

            height = width

        }

    }

    

    override var height: Double{

        didSet {

            width = height

        }

    }

    

    init(side: Double){

        super.init(width: side, height: side)

    }

    

    func printArea(rectangle: Rectangle){

        let area = rectangle.calculateArea()

        print("Area : \(area)")

    }

}

let square = Square(side: 10.0)

printArea(rectangle: square)