## What is Dependency Injection?
As the name says, this technique allows you to **pass/inject objects (dependencies) to a receiver object**. There are two types of dependency injection:
* Constructor Injection
* Property Injection
 
But what is a Dependency? A Dependency is an object (eg. a class) that holds some information. Simple.
An with this technique we are injecting those dependencies into an object, in order to provide the information it needs. So the receiving object will depend on the injected dependencies.
Usually this is done using initializers that accept protocols and passing objects that conform to those protocols or passing the objects through properties.
Now let's see a simple example of Dependency Injection.
## Constructor Injection
With the Constructor Injection the dependencies are passed through a custom initializer.
```swift
// 1
protocol User {
    var name: String { get set }
    var surname: String { get set }
}
 
// 2
class LoggedUser: User {
    var name: String = "Jhonny"
    var surname: String = "Smith"
}
 
// 3
class LoginVC: UIViewController {
    private let user: User
    init(user: User) {
        self.user = user
    }
}
 
let user = LoggedUser()
let loginVC = LoginVC(user: user)
```
1. We declare a protocol `User` that requires a `name` and a `surname`
2. Then we create a `LoggedUser` that conforms to the protocol `User`
3. And finally we add an initializer to `LoginVC` that accepts an `User`
 
!TIP Using protocols creates more flexibility since, maybe, in the future we will need another type of user. With this in place we can create a new class that conforms to `User` a pass it to the `LoginVC`.
This is Dependency Injection in a nutshell. Isn't it a simple concept?
## Property Injection
Unfortunately, the constructor injection is not possible if you are creating your view controllers in the Storyboard, since Swift doesn't allow you to create custom initializers for storyboard.
In this case, the only option you have, is to pass the dependencies after the view controller has been instantiated. And consequently we cannot declare the property as `let` in `LoginVC` but we must declare it as an optional `var` or as a `var` with a default value, like in the next example:
```swift
class LoginVC: UIViewController {
    var user: User?
}
 
let user = User()
let storyboard = UIStoryboard(name: "main", bundle: nil)
let loginVC = storyboard.instantiateViewController(withIdentifier: "LoginVC") as? LoginVC
loginVC?.user = user
```
## Conclusion
In this article we've covered the basics of **Dependency Injection**. This technique allows you to setup your app in a completely different and more flexible way.
But we will cover this in a different article. In the meantime, I hope you enjoyed this article and that it has been helpful to you.

Learn the basics of dependency injection with Swift and Xcode. It will allows you to inject dependencies making classes flexible.

Understanding Dependency Injection in Swift

Abstract Factory is a pattern that allow you to create families of object that conform to a common protocol.
This patterns has three main components: the factory, the product and a client.
### Factory:
1. **Factory protocol**: Declares an interface that allows to create abstract objects.
2. **Concrete factory (class or struct)**: Implements the operations to create abstract objects.
### Product:
1. **Product protocol**: Declares an interface that defines a product object.
2. **Concrete product (class or struct)**: Implements the AbstractProduct interface.
### Client:
1. **Client (class or struct)**: Uses only interfaces declared by Factory protocol and Product protocol.
----
## Implementation
This example illustrates the structure of the Abstract Factory design pattern.
## Products
We create a `Product` protocol that defines a single product. And then we add the concrete classes that implements the Product protocol.
```swift
// Products
protocol Car {
 
    func drive()
    func canBeDriven(by driver: Driver) -> Bool
}
 
class ToyotaCar: Car {
 
    func drive() {
        print("Start drive Toyota")
    }
 
    func canBeDriven(by driver: Driver) -> Bool {
        if driver is ProfessionalDriver {
            return true
        } else {
            return false
        }
    }
}
 
class LamborghiniCar: Car {
 
    func drive() {
        print("Start drive Lamborghini")
    }
 
    func canBeDriven(by driver: Driver) -> Bool {
        if driver is ProfessionalDriver {
            return true
        } else {
            return false
        }
    }
}
 
protocol Driver {
 
    var name: String { get set }
    var surname: String { get set }
 
    func whoAmI()
}
 
class ProfessionalDriver: Driver {
 
    var name: String
    var surname: String
 
    init(name: String, surname: String) {
        self.name = name
        self.surname = surname
    }
 
    func whoAmI() {
        print("I am a professional driver.")
    }
}
 
class NewbieDriver: Driver {
 
    var name: String
    var surname: String
 
    init(name: String, surname: String) {
        self.name = name
        self.surname = surname
    }
 
    func whoAmI() {
        print("I am a newbie driver.")
    }
}
```
## Factories
We create a `Factory` protocol that defines an interface for creating all distinct products. And then we add the concrete classes that implements the Factory protocol.
```swift
// Factories
protocol Factory {
 
    func hireDriver() -> Driver
    func buildCar() -> Car
}
 
class ToyotaFactory: Factory {
 
    func hireDriver() -> Driver {
        ProfessionalDriver(name: "Fernando", surname: "Alonso")
    }
 
    func buildCar() -> Car {
        ToyotaCar()
    }
}
 
class LamborghiniFactory: Factory {
 
    func hireDriver() -> Driver {
        NewbieDriver(name: "Jhon", surname: "Smith")
    }
 
    func buildCar() -> Car {
        LamborghiniCar()
    }
}
```
## Client
Here we create the client that calls the creation methods of a factory object instead of creating products directly with a constructor call.
!TIP In the `init` we used [Dependency Injection](/articles/dependency-injection) that allows us to inject a factory in the client.
```swift
class Client {
 
    let factory: Factory
 
    var driverName: String {
        let driver = self.hireDriver()
        return "\(driver.name) \(driver.surname)"
    }
 
    // Inits
 
    init(factory: Factory) {
        self.factory = factory
    }
 
    // Methods
 
    func buildCar() -> Car {
        self.factory.buildCar()
    }
 
    func hireDriver() -> Driver {
        self.factory.hireDriver()
    }
 
    func canBeDriven() -> Bool {
        self.buildCar().canBeDriven(by: hireDriver())
    }
}
```
## Usage
Now we can instanciate the client providing a factory.
## Conclusion
### PROS
* **Isolation of concrete classes.** It helps to control the classes of objects created. Because a factory encapsulates the responsibility and process of creating objects and isolates clients from concrete classes.
* **Objects of the same family can be easily interchanged.** Each product of the same class can be swapped since they all conform to the same protocol.
* **Promotes consistency between objects of the same family.** Each object of the same family has equal methods and property defined in the implemented protocol.
### CONS
* **Supporting new product types.** Since the Factory protocol defines all the various types of products that can be instantiated, adding a family means changing the factory interface. This change affects the concrete factories and all the subclasses, making the operation laborious.

Learn how the abstract factory pattern allows you to improve you codebase making it more readable and maintainable.

Patterns

Understanding Dependency Injection in Swift

Abstract Factory Pattern in Swift