这是对依赖注入的正确使用吗?

我有一个从存储库检索DTO的服务层。根据DTO的属性，我需要使用两种策略中的一种来执行DTO上的计算。我已经创建了一个工厂来返回适当的策略，我正在使用DI容器(Munq)来实例化对象。

public class CalculationFactory
{
    private readonly IDependencyResolver _resolver;
    public CalculationFactory(IDependencyResolver resolver)
    {
        ThrowIfNullArgument(resolver, "resolver", typeof(IDependencyResolver));
        _resolver = resolver;
    }
    public static ICalculation CreateCalculator(int serviceType)
    {
        switch (serviceType)
        {
            case 1: return _resolver.Resolve<ICalculation>("Type1");
            case 2: return _resolver.Resolve<ICalculation>("Type2");
            default: return _resolver.Resolve<ICalculation>("InvalidType");
        }
    }
}

这要求我在实例化工厂时传入依赖解析器，以便它可以用于解析/实例化要使用的适当计算。这是正确的方法吗?如果我想添加一个新的计算类型，那么我需要更新工厂CreateCalculator方法并注册新类型。

更新(长)恐怕我对这些建议并没有什么好感。我回到了Mark在。net中的DI版本，特别是关于重构的第6章。所以我有一个类 meterreads ，我需要使用基于运行时值的两个计算之一来计算收费。我添加了一个抽象工厂，但在我的具体工厂中，我仍然需要new进行适当的计算。我觉得我没有抓住重点:

public enum ServiceType
{
    Actuals = 1, CopyBlock,
}
public interface IChargeCalculator
{
    decimal CalculateCharge();
}
public interface IChargeCalculatorFactory
{
    IChargeCalculator CreateChargeCalculator(ServiceType serviceType);
}
public class MeterReading
{
    private readonly IChargeCalculatorFactory chargeCalculatorFactory;
    public MeterReading(IChargeCalculatorFactory chargeCalculatorFactory)
    {
        if (chargeCalculatorFactory == null)
            throw new ArgumentNullException("chargeCalculatorFactory");
        this.chargeCalculatorFactory = chargeCalculatorFactory;    
    }
}
public class ConcreteChargeCalculatorFactory : IChargeCalculatorFactory
{
    public IChargeCalculator CreateChargeCalculator(ServiceType serviceType)
    {
        switch (serviceType)
        {
            case ServiceType.Actuals : return new ActualsChargeCalculator();
            default: return new CopyBlockChargeCalculator();
        }
    }
}

但是在我的容器中，我可以注册不同的计算器，如果我将容器传递为混凝土工厂，我会得到如下内容(未测试)，坦率地说，这对我来说是相当合理的。欢迎任何反馈/澄清。

Container.Register<IChargeCalculator>("Actuals",
                                      c => new ActualsChargeCalculator());
Container.Register<IChargeCalculator>("CopyBlock",
                                      c => new CopyBlockChargeCalculator());
...
public enum ServiceType
{
    Actuals = 1, CopyBlock,
}
public interface IChargeCalculator
{
    decimal CalculateCharge();
}
public class MeterReading
{
    private readonly IDependencyResolver chargeCalculatorFactory;
    private ServiceType serviceType;
    public MeterReading(IDependencyResolver chargeCalculatorFactory)
    {
        if (chargeCalculatorFactory == null)
            throw new ArgumentNullException("chargeCalculatorFactory");
        this.chargeCalculatorFactory = chargeCalculatorFactory;    
    }
    public decimal Charge
    {
        get
        {
            return chargeCalculatorFactory.Resolve<IChargeCalculator>(serviceType.ToString());
        }
    }
}