创建一个抽象类还是使用处理器？

Question

我正在开发一个类来比较两个目录，并在目标目录中不存在源目录中的目录/文件时运行操作。

下面是该类的原型：

public abstract class IdenticalDirectories
{

    private DirectoryInfo _sourceDirectory;
    private DirectoryInfo _destinationDirectory;

    protected abstract void DirectoryExists(DirectoryInfo sourceDirectory, DirectoryInfo destinationDirectory);
    protected abstract void DirectoryDoesNotExist(DirectoryInfo sourceDirectory, DirectoryInfo destinationDirectory);
    protected abstract void FileExists(DirectoryInfo sourceDirectory, DirectoryInfo destinationDirectory);
    protected abstract void FileDoesNotExist(DirectoryInfo sourceDirectory, DirectoryInfo destinationDirectory);

    public IdenticalDirectories(DirectoryInfo sourceDirectory, DirectoryInfo destinationDirectory)
    {
        ...
    }

    public void Run()
    {

        foreach (DirectoryInfo sourceSubDirectory in _sourceDirectory.GetDirectories()) 
        {
            DirectoryInfo destinationSubDirectory = this.GetDestinationDirectoryInfo(subDirectory);

            if (destinationSubDirectory.Exists()) {
                this.DirectoryExists(sourceSubDirectory, destinationSubDirectory);
            } else {
                this.DirectoryDoesNotExist(sourceSubDirectory, destinationSubDirectory);
            }

            foreach (FileInfo sourceFile in sourceSubDirectory.GetFiles()) {
                FileInfo destinationFile = this.GetDestinationFileInfo(sourceFile);

                if (destinationFile.Exists()) {
                    this.FileExists(sourceFile, destinationFile);
                } else {
                    this.FileDoesNotExist(sourceFile, destinationFile);
                }
            }
        }
    }
}

上面的原型是一个抽象类。我想知道使该类成为非抽象类并让 Run 方法接收处理器是否会更好？例如。

public void Run(IIdenticalDirectoriesProcessor processor)
{

    foreach (DirectoryInfo sourceSubDirectory in _sourceDirectory.GetDirectories()) {
        DirectoryInfo destinationSubDirectory = this.GetDestinationDirectoryInfo(subDirectory);

        if (destinationSubDirectory.Exists()) {
            processor.DirectoryExists(sourceSubDirectory, destinationSubDirectory);
        } else {
            processor.DirectoryDoesNotExist(sourceSubDirectory, destinationSubDirectory);
        }


        foreach (FileInfo sourceFile in sourceSubDirectory.GetFiles()) {
            FileInfo destinationFile = this.GetDestinationFileInfo(sourceFile);

            if (destinationFile.Exists()) {
                processor.FileExists(sourceFile, destinationFile);
            } else {
                processor.FileDoesNotExist(sourceFile, destinationFile);
            }

        }

    }

}

您认为每种实施方式的优缺点是什么？

Answer 1

传入 IIdenticalDirectoriesProcessor 可以为您提供动态运行时灵活性，并且可以使 IdenticalDirectories 类更易于测试，并且不会像您最初提出的抽象/派生类解决方案那样将 IIdenticalDirectoriesProcessor 的实现耦合到 IdenticalDirectories 类。

当我现在只有 1 或 2 个抽象方法要重写时，我通常只接受 Func 或 Action 委托，而不是创建接口。这为您提供了最高程度的解耦。然而，超过 1 或 2 个就会变得笨重，因此您需要选择更传统的实现。

只是我的意见，介意。

Answer 2

在 .NET 中，委托是实现回调的首选方式。在不支持委托的其他语言（即大多数版本的 Java）中，接口是常见的，有时类提供接口的默认实现。

在仅支持单继承的语言中，使用抽象类有一个明显的缺点：它耗尽了使用者的一个继承槽。这不是接口问题。