设计模式：子类调用基类

Question

我有一些“处理程序”可以触发“代理”（执行某些任务的对象-这里不重要）。

处理程序在监听不同类型的事件：

- 时间事件：每10秒，10分钟（...） - 文件系统事件：文件复制/移动/删除后 - 数据库事件：当记录被添加到数据库表中时 - 邮件事件：当我在我的Office 365邮箱中收到电子邮件时

每个处理程序必须具备以下特点：

- 开始和停止方法（开始/停止捕获事件） - 相关代理的实例 - 触发代理的方式（Process方法+特定的参数集）

每个处理程序应该在特定事件触发时触发相应的代理。

我想从基础处理程序类触发代理，以便我可以将逻辑集中处理（触发事件，捕获异常，管理线程等）。但是，基础处理程序不知道如何调用代理（何时调用此函数，向Process方法发送什么参数），只有专门的子处理程序才知道如何做到这一点。

我唯一找到的方法是在基础处理程序中实现一个接受Action参数的Execute方法...我不喜欢这种方法，因为它并不是很直观（子类需要调用基类，否则什么也不会发生）。我希望能找到更好的设计来处理这个问题。另外，我可以告诉你，我的开发人员会告诉我他们不理解如何使用这个系统。

abstract class Handler : IHandler
{
    public IBroker Broker { get; protected set; }

    public event ProcessedEventHandler Processed;
    protected void OnProcessed(ProcessExecutionResult result) => Processed?.Invoke(this, result);

    public static IHandler Create(IBroker broker)
    {
        if (broker is ITimerTriggeredBroker)
            return new TimeHandler((ITimerTriggeredBroker)broker);
        return null;
    }

    protected Handler(IBroker broker)
    {
        if (broker == null) throw new ArgumentNullException(nameof(broker));
        Broker = broker;
    }

    public abstract void Start();
    public abstract void Stop();

    protected void Execute(Action action)
    {
        var res = new ProcessExecutionResult();
        try
        {
            action?.Invoke();
            res.IsSuccess = true;
        }
        catch (Exception ex)
        {
            res.Exception = ex;
            res.IsSuccess = false;
        }
        finally
        {
            OnProcessed(res);
        }
    }
}

时间处理器（处理与时间相关的事件）

class TimeHandler : Handler
{
    private readonly Timer _timer;
    private readonly DateTime _start;
    private readonly TimeSpan _frequency;

    public TimeHandler(ITimerTriggeredBroker broker)
        : base(broker)
    {
        _start = broker.Trigger.StartTime;
        _frequency = broker.Trigger.Frequency;
        _timer = new Timer(_ => Execute(broker.Process));
    }
 (...)
}

文件处理程序（处理与文件系统相关的事件）

class FileHandler : Handler
{
    private readonly FileSystemWatcher _watcher = new FileSystemWatcher();

    public FileHandler(IFileTriggeredBroker broker)
        : base(broker)
    {
        if (!Directory.Exists(broker.Trigger.DirectoryPath))
            throw new DirectoryNotFoundException("Unable to locate the supplied directory");

        _watcher.Filter = broker.Trigger.Filter;
        _watcher.Path = broker.Trigger.DirectoryPath;
        _watcher.NotifyFilter = NotifyFilters.CreationTime | NotifyFilters.DirectoryName |
                                NotifyFilters.FileName;

        _watcher.Created += (s, a) =>
        {
            if (IsCopied(a.FullPath)) Execute(() => broker.Process(a.FullPath));
        };
    }

- user4478810

---

你打算如何注入 IHandler > Handler > TimedHandler？ - Nikhil Vartak

“只有专门的子处理程序才知道如何做到这一点。”——听起来像是多态/虚方法的工作。但是很难确定，因为您提供了足够广泛的问题细节。代码片段无法提供足够的上下文，并且有许多方法可以处理模糊陈述的问题。如果您得到一个好答案，那只会在评论中进行大量的来回交流后才能得到。否则，您将只会得到许多随机的猜测。请改进问题。从一个好的[mcve]开始，精确地解释您遇到的问题。 - Peter Duniho

Answer 1

你正在尝试实现的目标有几个方面：

1. 架构应该易于程序员理解和遵循。它应该在他们编程时指导他们并保护他们免受错误。

2. 它应该是强大的。例如，你应该确保在观察文件夹中创建的每个文件都会被处理。

在我的答案中，我将忽略强韧性方面。请认真考虑这一点。FileSystemWatcher不能保证传递所有创建的文件。此外，建议您将FileSystemWatcher事件的处理与其他线程分离或使用.NET任务来完成。

此外，我认为您应该考虑使用队列，如Microsoft MQ、Azure队列、RabbitMQ。你可以直接做这个，或者使用像MassTransit这样的系统。

以下是我提出的一个架构，它将使你的程序员更容易构建。

总体描述

将应用程序划分为文件夹或不同的程序集，以清晰地区分框架和特定的处理程序/代理。

对于每种处理类型，我们创建一个特定的消息类并让处理程序和代理实现专门针对消息类型的通用接口。

我们将利用C#的高级类型系统，以确保很难犯错误，并且编译器将帮助程序员使用正确的东西。为此，我们使用基于消息类型类的通用接口和类。

主程序

在这里，我们将设置一个管理器，该管理器将注册所有处理程序和代理及其各自的消息。这是一个独立的示例，建议您使用依赖注入系统，例如AutoFac，以进一步优化此过程。

static void Main(string[] args)
{
    var manager = new Manager();
    manager.Register<FileHandlerMessage>(new FileHandler(), new FileBroker());
    manager.Register<TimeHandlerMessage>(new TimeHandler(), new TimeBroker());

    manager.Start();

    Console.ReadLine();

    manager.Stop();
}

管理器

Manager 类的作用是组织处理程序和代理的正确使用。

class Manager
{
    private List<IGenericHandler> handlers = new List<IGenericHandler>();

    public void Register<M>(IHandler<M> handler, IBroker<M> broker) where M : Message
    {
        handlers.Add(handler);
    }

    public void Start()
    {
        foreach ( var handler in handlers )
        {
            handler.Start();
        }
    }
    public void Stop()
    {
        foreach (var handler in handlers)
        {
            handler.Stop();
        }
    }
}

消息

针对每个类型的经纪人，我们将定义一个特定的消息类，它派生自一个共同的基类：

abstract class Message
{
}

class FileHandlerMessage : Message
{
    public string FileName { get; set; }
}

处理程序

interface IGenericHandler
{
    void Start();
    void Stop();
}

interface IHandler<M> : IGenericHandler where M : Message
{
    void SetBroker(IBroker<M> broker);
}

class FileHandler : IHandler<FileHandlerMessage>
{
    private IBroker<FileHandlerMessage> broker;

    public FileHandler()
    {
    }

    public void SetBroker(IBroker<FileHandlerMessage> fileBroker)
    {
        this.broker = fileBroker;
    }

    public void Start()
    {
        // do something
        var message = new FileHandlerMessage();
        broker.Process(message);
    }

    public void Stop()
    {
        // do something
    }
}

class TimeHandler : IHandler<TimeHandlerMessage>
{
    private IBroker<TimeHandlerMessage> broker;

    public void SetBroker(IBroker<TimeHandlerMessage>  broker)
    {
        this.broker = broker;
    }
    public void Start()
    {
        // do something
        var message = new TimeHandlerMessage();
        broker.Process(message);
    }

    public void Stop()
    {
        // do something
        throw new NotImplementedException();
    }
}

经纪人

class FileBroker : IBroker<FileHandlerMessage>
{
    public void Process(FileHandlerMessage message)
    {
        throw new NotImplementedException();
    }
}

class TimeBroker : IBroker<TimeHandlerMessage>
{
    public void Process(TimeHandlerMessage message)
    {
        throw new NotImplementedException();
    }
}

- tomislav_t