简短的问题

我应该把抽象的工厂界面和实际的工厂放在哪里？

概述

我正在编写一个简单的视频转码应用程序，并试图围绕依赖注入进行思考。

我已经在Visual Studio中将我的应用程序分成了几个项目。

• 一个用于转码器的类库，由应用程序引擎使用
• 一个应用程序引擎的类库，将由 gui 或控制台接口使用
• 一个控制台应用程序，现在将成为主用户界面

无 DI

这就是依赖注入之前的一切样

子

转码器库：

namespace SimpleFFmpeg {
    public interface ITranscoder {
        void Transcode(String fileName);
    }
    public class Transcoder:ITranscoder {
        // ...
        public void Transcode(String fileName) {
            // do transcoding stuff
        }
        // ...
    }
}

PusherEngine lib：

using SimpleFFmpeg;
namespace PusherLib {
    public class PusherEngine {
        private readonly List<VideoItem> _items;
        public PusherEngine() {
            _items = new List<VideoItem>();
        }
        // ...
        public void processItems() {
            foreach (VideoItem item in _items) {
                ITranscoder t = new Transcoder();
                t.Transcode(item.FileName);
            }
        }
        // ...
    }
}

实际应用：

namespace Pusher {
    class Program {
        static void Main(string[] args) {
            PusherEngine pe = new PusherEngine();
            pe.addVideoItem(new VideoItem(...));
            pe.processItems();
        }
    }
}

重构以使用 DI

我创建了一个通用的抽象工厂接口，如以下问题所示：在仍然使用依赖注入的同时创建新实例

public interface IFactory<T> {
    T Get();
}

接下来，我创建一个创建 ITranscoders 的工厂

public class TranscoderFactory: IFactory<ITranscoder> {
    public ITranscoder Get() {
        return new SimpleFFmpeg.Transcoder();
    }
}

然后我修改 PusherEngine 以要求在构造函数中依赖工厂：

using SimpleFFmpeg;
namespace PusherLib {
    public class PusherEngine {
        private readonly IFactory<ITranscoder> _transcoderFactory;
        private readonly List<VideoItem> _items;
        public PusherEngine(IFactory<ITranscoder> transcoderFactory) {
            _items = new List<VideoItem>();
            _transcoderFactory = transcoderFactory;
        }
        // ...
        public void processItems() {
            foreach (VideoItem item in _items) {
                ITranscoder t = _transcoderFactory.Get();
                t.Transcode(item.FileName);
            }
        }
        // ...
    }
}

最后，在程序中，它看起来像这样：

namespace Pusher {
    class Program {
        static void Main(string[] args) {
            IFactory<ITranscoder> f = new TranscoderFactory();
            PusherEngine pe = new PusherEngine(f);
            pe.addVideoItem(new VideoItem(...));
            pe.processItems();
        }
    }
}

问题

应该在哪个库/项目中定义 IFactory 接口？应该在哪个库/项目中定义转码器工厂？

他们住在转码器库中吗？在推手库中？还是在实际的前端应用程序中？我正在寻找最佳实践。

谢谢！

using SimpleFFmpeg;
namespace PusherLib {
    public class PusherEngine {
        private readonly ITranscoder _transcoder;
        private readonly List<VideoItem> _items;
        public PusherEngine(ITranscoder transcoder) {
            _items = new List<VideoItem>();
            _transcoder = transcoder;
        }
        // ...
        public void processItems() {
            foreach (VideoItem item in _items) {
                _transcoder.Transcode(item.FileName);
            }
        }
        // ...
    }
}

namespace Pusher {
    class Program {
        static void Main(string[] args) {
            ITranscoder t = new Transcoder();
            PusherEngine pe = new PusherEngine(t);
            pe.addVideoItem(new VideoItem(...));
            pe.processItems();
        }
    }
}