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版本），接口很常见，有时会提供一个提供接口默认实现的类。

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

制作抽象类或使用处理器？

2 个答案: