向外界隐藏内部服务以确保使用正确的高级服务[关闭]

Question

我正在开发一个电子商务网站。我有包含属性和照片的广告实体。属性写入数据库，照片存储在文件系统中。

我在我的基础设施项目中创建了一个WriterService，该服务负责保存广告......在后台它应该知道属性转到数据库，照片转到文件系统......但是这个细节是与外界无关...外界应使用WriterService保存广告。

这是我的作家服务：

public class WriterService
{
    private DbWriter _dbWriter;
    private IFileWriter _fileWriter;

    // I believe I need to change the constructor in order to achieve my goal
    public WriterService(DbWriter dbWriter, IFileWriter fileWriter)
    {
        _dbWriter = dbWriter;
        _fileWriter = fileWriter;
    }

    public void WriterSomething(string text, Stream image)
    {
        _dbWriter.Write(text);
        _fileWriter.Write(image);
    }
}

现在在我的基础设施层我有DbWriter 和FileWriter 的实现，DbWriter 看起来像这样：

public DbWriter
{
    public void Write(string text) {/* write text to DB */}
}

FileWriter 可以有不同的实现：

public interface IFileWriter
{
   void Write(Stream image);
}

照片可能会写入本地磁盘或 AWS S3 存储桶：

public DiskDriveWriter : IFileWriter
{
    public void Write(Stream image) {/* write image to Disk */}
}

public AWSCloudWriter : IFileWriter
{
    public void Write(Stream image) {/* write image to AWS */}
}

我想强制外部世界（我的解决方案中的其他项目）使用WriterService，所以如果他们想保存一些图像他们不应该直接使用AWSCloudWriter，他们总是必须通过@987654335 来执行此操作@。可以强制执行吗？

---

更新

为了避免一个很长的问题，我创建了this code review 来解释我要解决的问题。

Answer 1

我使用适配器将中间类映射到最终的 AWS/磁盘写入器，从而对实施者隐藏它们。

所有这些代码都在一个单独的类库中

IFileWriter

    internal interface IFileWriter
    {
        void Write(string text);
    }

两个实现 IFileWriter 的类

    internal class AWSWriter : IFileWriter
    {
        public void Write(string text)
        {
            //Write to AWS
        }
    }

    internal class DiskDriveWriter : IFileWriter
    {
        public void Write(string text)
        {
            //Write to disk
        }
    }

适配器的抽象基类

    public abstract class AbstractFileWriterAdapter
    {
        internal IFileWriter FileWriter { get; set; }
    }

两个适配器，一个用于 AWS，另一个用于 DiskWriter

    public class AWSFileWriterAdapter: AbstractFileWriterAdapter
    {
        public AWSFileWriterAdapter()
        {
            FileWriter = new AWSWriter();
        }
    }

    public class DiskDriveWriterAdapter:AbstractFileWriterAdapter
    {
        public DiskDriveWriterAdapter()
        {
            FileWriter = new DiskDriveWriter();
        }
    }

作家服务

public class WriterService
{
    AbstractFileWriterAdapter _writer;

    public WriterService(AbstractFileWriterAdapter writer)
    {
        _writer = writer;
    }

    public void WriteMessage(string text)
    {
        _writer.FileWriter.Write(text);
    }
}

最后来自不同项目的调用

            var awsAdapter = new AWSFileWriterAdapter();
            var service1 = new WriterService(awsAdapter);
            service1.WriteMessage("Some fancy text to AWS!!");


            var diskDriveAdapter = new DiskDriveWriterAdapter();
            var service2 = new WriterService(diskDriveAdapter);
            service2.WriteMessage("Some text to the drive!!");

Answer 2

如果你把IFileWriterinternal和WriterService的构造函数设置为internal，它会起作用。

internal interface IFileWriter

internal WriterService(IFileWriter fileWriter)

类似这样的：

internal interface IWriter
{
    void Write(string text);
}

internal class WriterB : IWriter
{
    public void Write(string text) { Console.WriteLine($"A is writing '{text}'"); }
}

internal class WriterA : IWriter
{
    public void Write(string text) { Console.WriteLine($"B is writing '{text}'"); }
}

public class WriterService
{
    private readonly IWriter x;

    internal WriterService(IWriter x) { this.x = x; }

    public void Write(string text) { x.Write(text); }

    public static WriterService WithA() { return new WriterService(new WriterA()); }

    public static WriterService WithB() { return new WriterService(new WriterB()); }
}


public class Program
{
    public static void Main(string[] args)
    {
        var s = new WriterService(new WriterA());

        s.Write("Hello!");

        WriterService.WithA().Write("Hello again!");

        WriterService.WithB().Write("And again!");
    }
}