DI 问题，这是否被认为是松散耦合的？

Question

我在这里使用工厂 class 将 DataAccess 和 Logging 注入到我的 BusinessLogic，这算松散耦合吗？

我正在尝试遵循 DIP（依赖倒置原则），以及 IoC（控制倒置）和 DIP（依赖倒置原则）。我在 post.

中包含了我的 classes 和我的界面

请注意，我没有使用 IoC 容器，也许我应该使用？

public interface IDataAccess
{
    void SaveData(string data);
}

public interface ILogger
{
    void Log(string str);
}

class Program
{
    public class Logger : ILogger
    {
        public void Log(string str)
        {
            Console.WriteLine("Logging {0}", str);
        }
    }

    public class BusinessLogic
    {
        ILogger _logger;
        IDataAccess _dataAccess;
        public BusinessLogic(Logger logger, DataAccess DataAccess)
        {
            _logger = logger;
            _dataAccess = DataAccess;
        }
        public void ProcessData()
        {
            _logger.Log("Hello!");
            _dataAccess.SaveData("Hey");
        }
    }

    public class DataAccess : IDataAccess
    {
        public void SaveData(string data)
        {
            Console.WriteLine("Saving {0}", data);
        }
    }

    static class Factory
    {
        public static DataAccess getDataAccess()
        {
            return new DataAccess();
        }
        public static Logger getLogger()
        {
            return new Logger();
        }
    }

    static void Main(string[] args)
    {
        BusinessLogic bLogic = new BusinessLogic(Factory.getLogger(), Factory.getDataAccess());
        bLogic.ProcessData();
        Console.ReadLine();
        Console.WriteLine("Hello World!");
    }
}

Answer 1

is this considered loosely coupled?

您的业务逻辑 class 与实现细节紧密耦合（具体 classes）

业务逻辑

//...

ILogger _logger;
IDataAccess _dataAccess;

public BusinessLogic(Logger logger, DataAccess DataAccess) { //<-- classes?
    _logger = logger;
    _dataAccess = DataAccess;
}

//...

而不是抽象（interfaces/abstract classes）。

业务逻辑（更新）

//...

ILogger _logger;
IDataAccess _dataAccess;

public BusinessLogic(ILogger logger, IDataAccess DataAccess) { //<-- abstractions
    _logger = logger;
    _dataAccess = DataAccess;
}

//...

上面更新的示例现在与实现分离 concerns/details。

Main 似乎是您的组合根，因此只需新建所有必需的依赖项并使用 pure DI 显式注入它们，因此实际上也不需要静态工厂。

static void Main(string[] args) {
    ILogger logger = new Logger();
    IDataAccess dataAccess = new DataAccess();
    BusinessLogic bLogic = new BusinessLogic(logger, dataAccess);
    bLogic.ProcessData();
    Console.ReadLine();
    Console.WriteLine("Hello World!");
}

Note that I am not using a IoC Container, maybe I should?

你是否应该是有争议的，并且很可能会得到意见的回答，将其置于 SO 可接受的范围之外。

查看链接的文章并自行做出明智的决定。

DI 问题，这是否被认为是松散耦合的？

DI Question, is this considered loosely coupled?

c#

dependency-injection

inversion-of-control