Table of Contents
Item 5: Dart Best Practices - Prefer dependency injection to hardwiring resources
Introduction to Dependency Injection in [[Dart]]
In Dart, a language optimized for building fast apps on multiple platforms, dependency injection (DI) is a design pattern that promotes loose coupling between components by injecting dependencies (such as services, objects, or resources) into classes or functions, rather than hardwiring these dependencies directly within the code. This approach contrasts with hardwiring, where resources and dependencies are created or managed directly inside a class or function, leading to tightly coupled code that is harder to test, extend, and maintain. By preferring dependency injection over hardwiring resources, you can achieve more modular, testable, and maintainable code.
Advantages of Dependency Injection in [[Dart]]
Preferring dependency injection over hardwiring resources offers several key advantages: 1. **Improved Testability**: DI allows you to easily replace real implementations with mocks or stubs during testing, making unit tests more isolated and reliable. 2. **Loose Coupling**: DI decouples classes and functions from their dependencies, allowing them to evolve independently. This results in a more flexible and maintainable codebase. 3. **Simplified Configuration Management**: DI patterns allow centralized management of dependencies, reducing complexity and making configuration changes easier. 4. **Better Separation of Concerns**: By separating the creation of dependencies from their usage, you adhere to the single responsibility principle, leading to more focused and maintainable code.
Example 1: Hardwiring vs. Dependency Injection in a Class
- Hardwiring Example
```dart class UserService {
final DatabaseConnection _dbConnection;
UserService() : _dbConnection = DatabaseConnection('localhost:5432/mydb');
void addUser(String user) {
_dbConnection.save(user);
}
}
void main() {
final userService = UserService();
userService.addUser('John Doe');
}
```
In this example, the `UserService` class is responsible for creating its `_dbConnection` dependency. This tight coupling makes the class harder to test, extend, and maintain.
- Dependency Injection Example
```dart class UserService {
final DatabaseConnection _dbConnection;
UserService(this._dbConnection);
void addUser(String user) {
_dbConnection.save(user);
}
}
void main() {
final dbConnection = DatabaseConnection('localhost:5432/mydb');
final userService = UserService(dbConnection);
userService.addUser('John Doe');
}
```
Here, the `UserService` class receives its `_dbConnection` dependency through its constructor. This loose coupling allows for greater flexibility and makes the class easier to test and modify.
Example 2: Using Factory Constructors for Dependency Injection
In Dart, factory constructors can be used to manage dependency injection, allowing you to create instances with injected dependencies more flexibly.
- Dependency Injection with Factory Constructors
```dart class UserService {
final DatabaseConnection _dbConnection;
UserService._internal(this._dbConnection);
factory UserService(DatabaseConnection dbConnection) {
return UserService._internal(dbConnection);
}
void addUser(String user) {
_dbConnection.save(user);
}
}
void main() {
final dbConnection = DatabaseConnection('localhost:5432/mydb');
final userService = UserService(dbConnection);
userService.addUser('John Doe');
}
```
In this example, the `UserService` class uses a factory constructor to manage the creation of instances, allowing dependencies to be injected in a controlled and flexible manner.
Example 3: Using Dependency Injection with [[GetIt]]
GetIt is a popular service locator in the Dart ecosystem that simplifies dependency injection by allowing you to register and retrieve dependencies globally.
- Dependency Injection with GetIt
```dart import 'package:get_it/get_it.dart';
final getIt = GetIt.instance;
class DatabaseConnection {
final String connectionString;
DatabaseConnection(this.connectionString);
void save(String user) {
print('Saving user $user to database $connectionString');
}
}
class UserService {
final DatabaseConnection _dbConnection = getIt();
void addUser(String user) {
_dbConnection.save(user);
}
}
void main() {
getIt.registerSingleton( DatabaseConnection('localhost:5432/mydb'), );
final userService = UserService();
userService.addUser('John Doe');
}
```
In this example, GetIt is used to register the `DatabaseConnection` as a singleton, and the `UserService` class retrieves the dependency through the service locator. This approach centralizes dependency management and simplifies code maintenance.
Example 4: Testing with Dependency Injection
One of the main benefits of dependency injection is the ability to test classes and functions more effectively by injecting mock or stub dependencies.
- Testing a Class with Mock Dependencies
```dart class MockDatabaseConnection implements DatabaseConnection {
@override
void save(String user) {
print('Mock saving user $user');
}
}
void main() {
final mockDbConnection = MockDatabaseConnection();
final userService = UserService(mockDbConnection);
userService.addUser('Test User');
}
```
In this example, a mock `DatabaseConnection` is injected into the `UserService` for testing purposes. This allows you to test the class without relying on a real database connection, making your tests faster and more reliable.
When to Prefer Dependency Injection in [[Dart]]
Dependency injection is particularly useful in the following scenarios: - **Complex Applications**: In large or complex applications, DI helps manage the interdependencies between classes and functions more effectively. - **Test-Driven Development (TDD)**: If you follow TDD practices, DI makes it easier to create testable classes and functions by allowing dependencies to be injected as mocks or stubs. - **Configuration-Driven Applications**: When building applications that rely on different configurations, DI helps manage and inject these configurations throughout the application. - **Reusable Components**: DI is beneficial in systems designed with reusable components, where dependencies need to be loosely coupled and easily interchangeable.
Conclusion
In Dart, preferring dependency injection over hardwiring resources is a best practice that leads to more maintainable, testable, and flexible code. By injecting dependencies, you decouple your classes and functions from their dependencies, making it easier to manage and extend your application. This approach aligns well with modern Dart development practices, especially when using service locators like GetIt or factory constructors to manage dependencies.