C#依赖注入(直白明了)讲解 一看就会系列

最基础的:UI-BLL-DAL
 
这是我们耳熟能详的分层
(补充:)  我们的类正常都不是孤立存在的。很多都是要依赖于其它的类。 比如说我们有一个Work类，Work类在工作的时候需要把信息记录下来。 MessageWriter就是 Worker的依赖项
 
首先我听到依赖注入之后看似非常的复杂
 
实际则是:为了实现不同的团队在不同的层上工作。我们可以让一个团队处理数据访问层，一个团队处理业务层，一个团队处理UI。 
 
首先建立:最基本的三层架构
实体层:

1. public class Product
2. {
3.     public Guid Id { get; set; }
4.     public string Name { get; set; }
5.     public string Description { get; set; }
6. }

复制代码

 
数据层:DAL

1. public class ProductDAL
2. {
3.     private readonly List<Product> _products;
5.     public ProductDAL()
6.     {
7.         _products = new List<Product>
8.         {
9.             new Product { Id = Guid.NewGuid(), Name= "iPhone 9",
10.                           Description = "iPhone 9 mobile phone" },
11.             new Product { Id = Guid.NewGuid(), Name= "iPhone X",
12.                           Description = "iPhone X mobile phone" }
13.         };
14.     }
16.     public IEnumerable<Product> GetProducts()
17.     {
18.         return _products;
19.     }
21.     public IEnumerable<Product> GetProducts(string name)
22.     {
23.         return _products
24.             .Where(p => p.Name.Contains(name))
25.             .ToList();
26.     }
27. }l

复制代码

 
逻辑层:BLL

1. public class ProductBL
2. {
3.     private readonly ProductDAL _productDAL;
5.     public ProductBL()
6.     {
7.         _productDAL = new ProductDAL();
8.     }
10.     public IEnumerable<Product> GetProducts()
11.     {
12.         return _productDAL.GetProducts();
13.     }
15.     public IEnumerable<Product> GetProducts(string name)
16.     {
17.         return _productDAL.GetProducts(name);
18.     }
19. }

复制代码

 
UI层:UI

1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         ProductBL productBL = new ProductBL();
7.         var products = productBL.GetProducts();
9.         foreach (var product in products)
10.         {
11.             Console.WriteLine(product.Name);
12.         }
14.         Console.ReadKey();
15.     }
16. }

复制代码

 
　　以上就是我们基础的结构:  UI - BLL - DAL  引用顺序
那么出现以下三个问题:
1.我们不能让三个不同的团队在每个层上工作。
2.业务层很难扩展，因为它依赖于数据访问层的实现。
3.业务层很难维护，因为它依赖于数据访问层的实现。
 
高级别对象不应该依赖于低级别对象。两者都必须依赖于抽象。那么抽象概念是什么呢?
抽象是功能的定义。在我们的例子中，业务层依赖于数据访问层来检索图书。在C#中，我们使用接口实现抽象。接口表示功能的抽象。
 
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------以下为修改后结构
数据层:DAL 
DAL:接口

1. public interface IProductDAL
2. {
3.     IEnumerable<Product> GetProducts();
4.     IEnumerable<Product> GetProducts(string name);
5. }

复制代码

 
DAL:实现　

1. public class ProductDAL : IProductDAL

复制代码

 
 
业务逻辑层:BLL　　这样我们就做到了  使其依赖于IDAL 抽象层，而不是DAL层直接实现:

1. public class ProductBL
2. {
3.     private readonly IProductDAL _productDAL;
5.     public ProductBL()
6.     {
7.         _productDAL = new ProductDAL();
8.     }
10.     public IEnumerable<Product> GetProducts()
11.     {
12.         return _productDAL.GetProducts();
13.     }
15.     public IEnumerable<Product> GetProducts(string name)
16.     {
17.         return _productDAL.GetProducts(name);
18.     }
19. }

复制代码

 
　
业务逻辑层:IBLL  (同样的 UI 依赖于BLL 我们也这样做 搞个抽象层 接口)

1. public interface IProductBL
2. {
3.     IEnumerable<Product> GetProducts();
4.     IEnumerable<Product> GetProducts(string name);
5. }　

复制代码

 
同理:更新BLL层:  

1. public class ProductBL : IProductBL

复制代码

 
UI层:  就和BLL依赖于DAL一样  UI依赖于BLL

1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         IProductBL productBL = new ProductBL();
7.         var products = productBL.GetProducts();
9.         foreach (var product in products)
10.         {
11.             Console.WriteLine(product.Name);
12.         }
14.         Console.ReadKey();
15.     }

复制代码

 
　　
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------以上为抽象层的建立,
 
还记得我们标红的地方吗?

1. public ProductBL()
2. {
3.     _productDAL = new ProductDAL();
4. }

复制代码

 
BLL依赖于IDAL  ,但是  最终我们还是依赖于DAL
到目前为止，我们所做的工作都与依赖注入无关　
 
为了使处在BLL依赖于DAL的功能，而没有具体的实现，必须由其他人创建类。其他人必须提供底层对象的具体实现，这就是我们所说的依赖注入。它的字面意思是我们将依赖对象注入到更高级别的对象中。
 
实现依赖项注入的方法之一是使用构造函数进行依赖项注入。
更新业务层:

1. public class ProductBL : IProductBL
2. {
3.     private readonly IProductDAL _productDAL;
5.     public ProductBL(IProductDAL productDAL)
6.     {
7.         _productDAL = productDAL;
8.     }
10.     public IEnumerable<Product> GetProducts()
11.     {
12.         return _productDAL.GetProducts();
13.     }
15.     public IEnumerable<Product> GetProducts(string name)
16.     {
17.         return _productDAL.GetProducts(name);
18.     }
19. }

复制代码

 
　　
UI:

1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         IProductBL productBL = new ProductBL(new ProductDAL());
7.         var products = productBL.GetProducts();
9.         foreach (var product in products)
10.         {
11.             Console.WriteLine(product.Name);
12.         }
14.         Console.ReadKey();
15.     }
16. }

复制代码

 
　　创建DAL控制与UI结合在一起。这也称为控制反转
我们不是在BLL中创建DAL的实例，而是在UI的中创建它。 Main方法将把实例注入到业务逻辑层。因此，我们将低层对象的实例注入到高层对象的实例中。
                                         这叫做依赖注入
现在，如果我们看一下代码，我们只依赖于业务访问层(BLL)中数据访问层(IDAL)的抽象，而业务访问层(BLL)是使用的是数据访问层实现的接口。因此，我们遵循了更高层次对象和更低层次对象都依赖于抽象的原则，抽象是更高层次对象和更低层次对象之间的契约。
 
接下来就显示了可维护性和可扩展性的好处。例如，如果我们想为SQL Server创建一个新的数据访问层，我们只需实现数据访问层的抽象并将实例注入基础设施中。
 
 
 
原文连接:   www.cnblogs.com/hhhnicvscs/p/14204806.html
原文链接：www.codeproject.com/Articles/5274732/Dependency-Injection-and-IoC-Containers-in-Csharp 
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！