Dependency Injection (DI) is a design pattern used to implement IoC (Inversion of Control), allowing for better modularity and testability in applications. In C#, there are various ways to implement dependency injection, including Constructor Injection, Setter Injection, and Interface Injection.
Below is a simple example demonstrating Constructor Injection in C#:
// Interface
public interface IMessageService
{
void SendMessage(string message);
}
// Implementation of the interface
public class EmailService : IMessageService
{
public void SendMessage(string message)
{
Console.WriteLine("Email sent: " + message);
}
}
// Consumer class
public class UserController
{
private readonly IMessageService _messageService;
// Constructor Injection
public UserController(IMessageService messageService)
{
_messageService = messageService;
}
public void NotifyUser(string message)
{
_messageService.SendMessage(message);
}
}
// Usage
public class Program
{
public static void Main(string[] args)
{
IMessageService emailService = new EmailService();
UserController userController = new UserController(emailService);
userController.NotifyUser("Hello, Dependency Injection!");
}
}
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?