这些BLL-DAL是否符合依赖反转原则，这是否有效的依赖注入？

Question

我正在研究一个非常简单的概念证明(POC)。

在这个项目中应该实现关注点的分离，这样在将来我们就可以灵活地使用我们使用的数据源(因此在这个POC中没有UI )。

• BLL有一个POCO Fruit类，它希望它的数据源实现存储库接口，还有一个FruitService类，它的职责是返回一个字符串，该字符串将用于标记水果。
• 当通过存储库提供密钥时，DAL返回一个结果。

我希望检查代码是否应用了依赖反转的SOLID原则(DIP)，以便高阶BLL不依赖于DAL -而是DAL依赖于BLL。

解决方案结构：

BLL类

1.水果POCO：

namespace DapperRepository_SingleProject.BusinessLogicLayer
{
    public class Fruit
    {
        public int FruitKey { get; set; }
        public string Name { get; set; }
        public string Color { get; set; }
        public decimal Price { get; set; }
    }
}

2.通用存储库接口：

namespace DapperRepository_SingleProject.BusinessLogicLayer
{
    public interface IRepository<T> where T : class
    {
        T GetByKey(int key);
    }
}

3.带有返回字符串的单个方法的FruitService类，在这里，我尝试实现构造函数注入：

class FruitService
{

    private IRepository<Fruit> FruitRepo = null;

    public FruitService(IRepository<Fruit> fruitRepo)
    {
        FruitRepo = fruitRepo;
    }

    public string PrintLabel(int fruitKey)
    {
        Fruit f = FruitRepo.GetByKey(fruitKey);
        return string.Concat(f.Name.ToString(), " priced at ", f.Price.ToString());
    }

}

DAL有一个Repository类，它实现了BLL中指定的存储库接口：

using System.Linq;
using Dapper;
using System.Data;
using System.Configuration;
using System.Data.SqlClient;
using DapperRepository_SingleProject.BusinessLogicLayer;

namespace DapperRepository_SingleProject.DataAccessLayer
{

    public class FruitRepository : IRepository<Fruit>
    {
        private IDbConnection dbConnection = null;

        public FruitRepository()
        {
            dbConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["xxx"].ConnectionString);
        }

        public Fruit GetByKey(int key)
        {
            Fruit fruit = null;

            string sql = "SELECT * FROM FruitInfo.dbo.tb_Fruit WHERE FruitKey=@Key";
            var queryResult = dbConnection.Query<Fruit>(sql, new { Key = key });

            if (queryResult != null)
            {
                fruit = queryResult.FirstOrDefault();
            }
            return fruit;
        }
    }
}

数据如下：

USE FruitInfo;
CREATE TABLE dbo.tb_Fruit
(
    FruitKey    int not null,
    Name        varchar(25),
    Color       varchar(25),
    Price       money
);
ALTER TABLE dbo.tb_Fruit  
ADD CONSTRAINT PK_tb_Fruit_FruitKey PRIMARY KEY CLUSTERED (FruitKey);

INSERT INTO FruitInfo.dbo.tb_Fruit
    values
    (1, 'Apple', 'Red', 10),
    (2, 'Orange','Orange', 20),
    (3, 'Pear',  'Green', 15);

Program.cs --我使用DAL和BLL的命名空间，并使用了一个方法Orchestrator，这是我尝试注入的方法：

using System;
using DapperRepository_SingleProject.DataAccessLayer;
using DapperRepository_SingleProject.BusinessLogicLayer;


namespace DapperRepository_SingleProject
{
    class Program
    {

        FruitRepository fruitRepository = null;

        static void Main(string[] args)
        {
            Program p = new Program();
            p.Orchestrator();
        }

        public void Orchestrator()
        {

            fruitRepository = new FruitRepository();
            FruitService fs = new FruitService(fruitRepository);   //<<attempt at constructor injection
            Console.WriteLine(fs.PrintLabel(1));


            Console.WriteLine("press a key");
            Console.ReadKey();
        }

    }
}

两个审查问题：

1. 以上是否符合Dependency-Inversion Principle？我是using -- DAL类中的BLL名称空间，而不是BLL中的DAL名称空间--所以我假设它符合吗？如果它不符合这个原则，那么需要做什么改变呢？
2. 在Orchestration.cs和FruitService.cs类中，我尝试使用依赖注入-我的实现正确吗？

Answer 1

以上是否符合依赖-反演原则？我是..。

是，因为：

• BLL为DAL定义域类和接口以实现
• BLL不依赖DAL
• DAL实现BLL提供的接口，并使用它的域类。

在Orchestration.cs和FruitService.cs类中，我尝试使用依赖注入-我的实现正确吗？

您已经在依赖项中进行了编码。

FruitService fs = new FruitService(fruitRepository);

依赖“注入”意味着您不必将其编码。相反，您应该使用一个反转控制(IoC)容器来解析已注册的类及其依赖项。

IoC容器的伪用法：

寄存器类型

container.Register<FruitService>().AsSingleInstance();
container.Register<FruitRepository>().AsImplementedInterfaces();

获取存储库(如果需要直接使用存储库)

var repository = container.Resolve<IRepository<Fruit>>();

获取服务(存储库被注入，因为它已注册)

var service = container.Resolve<FruitService>();