Question

我希望我的应用程序不会严格依赖于IOC，所以基本上我的应用程序应该调用一个IOC工厂模式来解决运行时的特定实现。

所以，首先我创建了我的界面：

IIOCService

interface IIOCService
{
    void RegisterSingleton<RegisterType>()
        where RegisterType : class;

    void RegisterMultiple<RegisterType>()
        where RegisterType : class;

    void RegisterMultiple<RegisterType>(IEnumerable<Type> implementationTypes);

    // and so on
}

然后使用 TinyIOC

实施IIOCService

class TinyIOCServiceImpl : IIOCService
{
    private static readonly TinyIOCServiceImpl _Current = new TinyIOCServiceImpl();

    public static TinyIOCServiceImpl Current
    {
        get
        {
            return _Current;
        }
    }

    TinyIoC.TinyIoCContainer container;

    public TinyIOCServiceImpl()
    {
        container = TinyIoC.TinyIoCContainer.Current;
    }

    public void RegisterSingleton<RegisterType>()
        where RegisterType : class
    {
        container.Register(typeof(RegisterType)).AsSingleton();
    }

    // ...and so on
}

对于决定解决IOC容器实现的类，我创建了一个IOCFactory

IOCFactory

class IOCFactory
{
    public enum IOC { TinyIOC }

    public IIOCService GetService(IOC iocType)
    {
        switch (iocType)
        {
            case IOC.TinyIOC:
                return TinyIOCServiceImpl.Current;
            default:
                throw new NotSupportedException();
        }

    }
}

现在我的问题是：

我是否需要为需要IOC的每个班级重新安排工厂，或者有更优雅的方式？

IIOCService iocService = new IOCFactory().GetService(IOCFactory.IOC.TinyIOC); 
// code needed everytime I need to use IOC  (i.e. ServiceLocator, ViewModelLocator, etc.)
// is this code a bit redundant ???

Answer 1

我同意在IOC容器周围创建一个包装器有点多余。但是，如果您需要调用您的IOC容器来解析特定的，在运行时确定的接口实例，您可以创建一个resloving接口（不是工厂模式，而是保持在IOC模式内）。像这样的东西（这太基础了，只是让你可以得到这个想法）：

public interface IResolve {
    public T Resolve<T>();
}

您可以为此特定接口创建实现，并将其公开给您的IOC容器。在单个实例模式中执行此操作没有问题。

当您需要解析由IOC容器解析的类中的某些内容时，只需将IResolve添加到构造函数中，您就可以在不依赖任何品牌的IOC容器的情况下处理IOC容器。

我希望这为你带来一些清晰度？

IOC的工厂模式，总是需要实例化？

1 个答案: