Mô hình tiêm phụ thuộc là gì?

Dependency Injection [DI] là một mẫu thiết kế phần mềm cho phép chúng ta phát triển mã liên kết lỏng lẻo. DI là một cách tuyệt vời để giảm sự liên kết chặt chẽ giữa các thành phần phần mềm. DI cũng cho phép chúng tôi quản lý tốt hơn các thay đổi trong tương lai và sự phức tạp khác trong phần mềm của chúng tôi. Mục đích của DI là làm cho mã có thể bảo trì được

Mẫu Tiêm phụ thuộc sử dụng một đối tượng trình xây dựng để khởi tạo các đối tượng và cung cấp các phụ thuộc cần thiết cho đối tượng, nghĩa là nó cho phép bạn "tiêm" một phụ thuộc từ bên ngoài lớp

Ví dụ: Giả sử lớp Client của bạn cần sử dụng hai lớp dịch vụ, thì điều tốt nhất bạn có thể làm là làm cho lớp Client của bạn nhận thức được sự trừu tượng i. e. Giao diện

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 private IService _service;
 public Client[IService service] {
 this._service = service;
 }
 public ServeMethod[] { 
 this._service.Serve[]; 
 }
}

0 thay vì triển khai i. e. Lớp học

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 private IService _service;
 public Client[IService service] {
 this._service = service;
 }
 public ServeMethod[] { 
 this._service.Serve[]; 
 }
}

1 và

class Program
{
 static void Main[string[] args]
 {
 //creating object
 Service1 s1 = new Service1[]; 
 //passing dependency
 Client c1 = new Client[s1];
 //TO DO:
 c1.ServeMethod[];
 
 Service2 s2 = new Service2[]; 
 //passing dependency
 c1 = new Client[s2];
 //TO DO:
 c1.ServeMethod[];
 }
}

0. Bằng cách này, bạn có thể thay đổi việc triển khai giao diện

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 private IService _service;
 public Client[IService service] {
 this._service = service;
 }
 public ServeMethod[] { 
 this._service.Serve[]; 
 }
}

0 bất cứ lúc nào [và bao nhiêu lần bạn muốn] mà không cần thay đổi mã lớp máy khách

Chúng tôi có thể sửa đổi mã này bằng cách làm theo các cách triển khai Dependency Injection. Chúng tôi có các cách khác nhau sau đây để thực hiện DI

Xây dựng tiêm

1. Đây là một cách được sử dụng rộng rãi để thực hiện DI

2. Dependency Injection được thực hiện bằng cách cung cấp DEPENDENCY thông qua hàm tạo của lớp khi tạo thể hiện của lớp đó

3. Thành phần được đưa vào có thể được sử dụng ở bất kỳ đâu trong lớp

4. Được khuyến nghị sử dụng khi phụ thuộc được tiêm, bạn đang sử dụng trên các phương thức của lớp

5. Nó giải quyết tình huống phổ biến nhất trong đó một lớp yêu cầu một hoặc nhiều phụ thuộc

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 private IService _service;
 public Client[IService service] {
 this._service = service;
 }
 public ServeMethod[] { 
 this._service.Serve[]; 
 }
}

class Program
{
 static void Main[string[] args]
 {
 //creating object
 Service1 s1 = new Service1[]; 
 //passing dependency
 Client c1 = new Client[s1];
 //TO DO:
 c1.ServeMethod[];
 
 Service2 s2 = new Service2[]; 
 //passing dependency
 c1 = new Client[s2];
 //TO DO:
 c1.ServeMethod[];
 }
}

Quá trình Tiêm xảy ra trong hàm tạo, bỏ qua Dịch vụ triển khai Giao diện IService. Các phần phụ thuộc được lắp ráp bởi một "Người xây dựng" và các trách nhiệm của Người xây dựng như sau

1. Biết các loại của từng IService

2. Theo yêu cầu, cung cấp IService trừu tượng cho Khách hàng

Tiêm thuộc tính/Setter

1. Nên sử dụng khi một lớp có các thành phần phụ thuộc tùy chọn hoặc khi có thể cần phải hoán đổi việc triển khai

2. Các triển khai logger khác nhau có thể được sử dụng theo cách này

3. Không yêu cầu tạo đối tượng mới hoặc sửa đổi đối tượng hiện có. Không thay đổi trạng thái đối tượng, nó có thể hoạt động

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 private IService _service;
 public IService Service {
 set { this._service = value; }
 }
 public ServeMethod[] { 
 this._service.Serve[]; 
 }
}

class Program
{
 static void Main[string[] args]
 {
 //creating object
 Service1 s1 = new Service1[]; 
 
 Client client = new Client[];
 client.Service = s1; //passing dependency
 //TO DO:
 client.ServeMethod[];

 Service2 s2 = new Service2[]; 
 client.Service = s2; //passing dependency
 //TO DO:
 client.ServeMethod[];
 }
}

phương pháp tiêm

1. Đưa phần phụ thuộc vào một phương thức duy nhất và nói chung là để sử dụng phương thức đó

2. Nó có thể hữu ích, khi cả lớp không cần sự phụ thuộc, chỉ một phương thức có sự phụ thuộc đó

3. Đây là cách ít được sử dụng

public interface IService {
 void Serve[];
}
public class Service1 : IService {
 public void Serve[] { 
 Console.WriteLine["Service1 Called"]; 
 }
}
public class Service2 : IService {
 public void Serve[] { 
 Console.WriteLine["Service2 Called"]; 
 }
}
public class Client {
 public void ServeMethod[IService service] {
 service.Serve[];
 }
}

class Program
{
 static void Main[string[] args]
 {
 //creating object
 Service1 s1 = new Service1[]; 
 
 Client client = new Client[]; 
 client.Start[s1]; //passing dependency
 //TO DO:
 client.ServeMethod[];

 Service2 s2 = new Service2[]; 
 client.Start[s2]; //passing dependency
 client.ServeMethod[];
 }
}

Ưu điểm của tiêm phụ thuộc

1. Giảm khớp nối lớp

2. Tăng khả năng sử dụng lại mã

3. Cải thiện khả năng bảo trì mã

4. Làm cho thử nghiệm đơn vị có thể

Bộ chứa DI

Cách được đề xuất để triển khai DI là bạn nên sử dụng bộ chứa DI. Nếu bạn soạn đơn mà không có DI CONTAINER thì chẳng khác nào

class Program
{
 static void Main[string[] args]
 {
 //creating object
 Service1 s1 = new Service1[]; 
 //passing dependency
 Client c1 = new Client[s1];
 //TO DO:
 c1.ServeMethod[];
 
 Service2 s2 = new Service2[]; 
 //passing dependency
 c1 = new Client[s2];
 //TO DO:
 c1.ServeMethod[];
 }
}

2. Nếu bạn muốn triển khai DI trong ASP của mình. NET MVC bằng cách sử dụng bộ chứa DI, vui lòng tham khảo Tiêm phụ thuộc trong ASP. NET MVC sử dụng Unity IoC Container

Đọc thêm các bài viết liên quan đến Dependency InjectionBạn nghĩ sao?

Tôi hy vọng, bạn sẽ thích những cách khác nhau để triển khai các mẫu DI. Tôi muốn có thông tin phản hồi từ độc giả blog của tôi. Phản hồi, câu hỏi hoặc nhận xét có giá trị của bạn về bài viết này luôn được chào đón

tiêm phụ thuộc trong thuật ngữ đơn giản là gì?

Mẫu tiêm phụ thuộc trong Java là gì?

Tiêm phụ thuộc là gì và nó hoạt động như thế nào?

Tiêm phụ thuộc là gì và các loại của nó?