Can you explain the differences between Dependency Injection and Dependency Inversion concepts in software development?

Dependency Injection (DI) is a design pattern where an object's dependencies are provided from outside rather than created internally. This makes it easy to change dependency implementations, simplifies testing, and increases code modularity.

Dependency Inversion Principle (DIP) is one of the five SOLID principles, which states that:

• High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Abstractions should not depend on details. Details should depend on abstractions.

In simpler terms, DIP aims to reduce coupling between components through the use of abstractions (e.g., interfaces).

The connection between them: DI is a way to implement DIP. By using DI, dependencies are passed through constructors or setters, allowing modules to depend on abstractions rather than concrete implementations.

Example in Swift:

protocol NetworkService {
    func fetchData()
}

class APIService: NetworkService {
    func fetchData() {
        print("Fetching data from API")
    }
}

class ViewModel {
    private let networkService: NetworkService

    // Dependency Injection via constructor
    init(networkService: NetworkService) {
        self.networkService = networkService
    }

    func load() {
        networkService.fetchData()
    }
}

let apiService = APIService()
let viewModel = ViewModel(networkService: apiService)
viewModel.load()

Here, ViewModel depends on the abstraction NetworkService (DIP), and the specific implementation is provided externally (DI).