Property in Swift - Computed property | Property Observers (WillSet & DidSet)

   Computed property -  Computed properties are part of a property type in Swift.  Stored properties are the most common which save and return a stored value  Computed properties calculate (rather than store) a value. A computed property provides a getter and an optional setter to indirectly access other properties and values. Computed property in swift is an interesting topic as you can write code inside a property in swift. Computed properties are provided by classes, structures, and enumerations but stored properties are provided only by classes and structures. This computed property swift tutorial has some tips on how to use the computed property in the right way and avoid the common mistakes that swift programming beginners do while computed property. Example :- Computed property A Calculate Simple Intrest struct CalculateLoan {      var amount : Int      var rate : Int      var years : Int      var simpleInterest: Int {          get {              return ( amount * rate
0

Singleton vs Dependency Injection in iOS Swift With A Simple Example

 

Singleton

Singleton: - The Singleton is a Design Pattern. That only on single instance of a class. A Singleton can be accessed from anywhere in the program, but it cannot be modified from anywhere. It can only be modified from within the Singleton. It is, therefore, a means to protect globals.

A Singleton class supports inheritance, while a Static class is a sealed class, and therefore cannot be inherited. A Singleton class can inherit from other classes, while a Static class cannot (not even from other static classes).

  • The singleton pattern increases coupling.
Disadvantages of singleton in Swift
  • The global nature leads to dependency hiding.
  • It can be difficult to unit test the code.
  • It can lead to tightly coupled code.
  • If the single Instance of the object becomes corrupted, the entire system is compromised

A singleton class itself is not thread safe. Multiple threads can access the singleton same time and create multiple objects, violating the singleton concept. The singleton may also return a reference to a partially initialised object.

Example: - 

class MySingleton {

static let shared = MySingleton() // Singleton instance

private init() {
// Private initializer to prevent external instantiation
}

func doSomething() {
print("Singleton: Doing something")
}
}

// Usage:
MySingleton.shared.doSomething()

Dependency Injection


Dependency Injection:- Dependency injection reduces coupling  

  • Improves code reusability.
  • Eases the unit testing of applications through mocking/stubbing injected dependencies.
  • Reduces boilerplate code because dependencies are initialized by their injector component.
  • Decouples component logic.
  • Makes it easier to extend the application classes.

Example:- 

protocol MyDependency {
func performAction()
}

class MyDependencyImplementation: MyDependency {
func performAction() {
print("Dependency: Performing an action")
}
}

class MyClass {
let dependency: MyDependency

init(dependency: MyDependency) {
self.dependency = dependency
}

func useDependency() {
dependency.performAction()
}
}

// Usage:
let dependency = MyDependencyImplementation()
let myClass = MyClass(dependency: dependency)
myClass.useDependency()


Reference

Comments

Post a Comment