做一个抽象类还是使用处理器？答案

【问题标题】：Make an abstract class or use a processor?做一个抽象类还是使用处理器？
【发布时间】：2010-06-09 00:08:50
【问题描述】：

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

这是该类的原型：

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);
            }

        }

    }

}

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

【问题讨论】：

标签： c# interface abstract-class

【解决方案1】：

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

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

请注意我的意见。

【讨论】：

【解决方案2】：

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

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

【讨论】：