C# 通过构造函数初始化实现冗余

我有两个类使用记录器

public class FooClass
{
    private readonly ILogger _logger;
    private readonly IBarClass _barClass;

    public FooClass() : this (new Logger(), new BarClass())
    { }

    public FooClass(ILogger logger, IBarClass barClass)
    {
        _logger = logger;
        _barClass = barClass;
    }

    public void FooMethod()
    {
        //Do something
    }
}

public class BarClass : IBarClass
{
    private readonly ILogger _logger;

    public BarClass() : this (new Logger())
    { }

    private BarClass(ILogger logger)
    {
        _logger = logger;
    }

    public void BarMethod()
    {
        //Do something
    }
}

似乎logger在FooClass和BarClass中初始化了两次。我不能使用FooClass中初始化的记录器在BarClass中使用。这个问题还有其他解决办法吗

请注意，FooClass的实例必须通过空构造函数调用生成。（这个例子正是我面临的问题的简单版本）

---

我遗漏了什么吗？

使用类似于structuremap的IoC容器，如果将来删除了

FooClass

？似乎

记录器

初始化依赖于

foo类

。我们有没有办法既有

FooClass

又有

BarClass

，而且只有一个

Logger

类的实例被发送给

FooClass

和

BarClass

的构造函数？现在他不应该被命名：你确定，OP真的需要你在说什么吗？我在他的问题中看不到这一点，关于

FooClass

、

BarClass

和

Logger

的解耦没有任何问题。对不起，OP似乎没有问这个问题。顺便问一下，出于好奇，如何将所有这些类解耦？@nowhohommustnotbenamed:IMO，最明显的方法是使用IoC-（DI-）container@Dennis我早些时候就考虑过这个实现。这是做这件事的最佳实践吗？当我们在构造函数中实例化某些东西并使用它来实例化另一个对象时，它不会在将来产生任何问题。

interface ILogger { }
class Logger : ILogger { }

interface IBarClass { }
class BarClass : IBarClass
{
    private readonly ILogger _logger;

    public BarClass(ILogger logger)
    {
        _logger = logger;
    }

    public void BarMethod()
    {
        //Do something
    }
}

class FooClass
{
    private readonly ILogger _logger;
    private readonly IBarClass _barClass;

    public FooClass()
    {
        _logger = new Logger();
        _barClass = new BarClass(_logger);
    }

    public FooClass(ILogger logger, IBarClass barClass)
    {
        _logger = logger;
        _barClass = barClass;
    }

    public void FooMethod()
    {
        //Do something
    }
}