已更新:有关我如何实现该解决方案，请参阅问题结尾。

很抱歉这个问题措辞不佳，但我不确定如何提出它才是最好的。我不确定如何设计一个可以重复使用的解决方案，其中大部分代码每次实现时都完全相同，但部分实现每次都会发生变化，但遵循相似的模式。我尽量避免复制和粘贴代码。

我们有一个内部数据消息系统，用于跨不同机器上的数据库更新表。我们正在扩展我们的消息服务以将数据发送给外部供应商，我想编写一个简单的解决方案，如果我们决定将数据发送给多个供应商，可以重复使用。该代码将被编译成一个 EXE 文件并定期运行以向供应商的数据服务发送消息。

以下是代码作用的粗略概述:

public class OutboxManager 
{
    private List<OutboxMsg> _OutboxMsgs;

    public void DistributeOutboxMessages()
    {
        try {
            RetrieveMessages();
            SendMessagesToVendor();
            MarkMessagesAsProcessed();
        }
        catch Exception ex {
            LogErrorMessageInDb(ex);
        }
    }

    private void RetrieveMessages() 
    {
      //retrieve messages from the database; poplate _OutboxMsgs.
      //This code stays the same in each implementation.
    }

    private void SendMessagesToVendor()   // <== THIS CODE CHANGES EACH IMPLEMENTATION
    {
      //vendor-specific code goes here.
      //This code is specific to each implementation.
    }

    private void MarkMessagesAsProcessed()
    {
      //If SendMessageToVendor() worked, run this method to update this db.
      //This code stays the same in each implementation.
    }

    private void LogErrorMessageInDb(Exception ex)
    {
      //This code writes an error message to the database
      //This code stays the same in each implementation.
    }
}

我想以这样一种方式编写此代码，即我可以重新使用未更改的部分，而不必诉诸复制和粘贴并填写 SendMessagesToVendor() 的代码.我希望开发人员能够使用 OutboxManager 并编写所有已编写的数据库代码，但被迫提供他们自己的向供应商发送数据的实现。

我确信有很好的面向对象原则可以帮助我解决这个问题，但我不确定最好使用哪一个。

这是我最终采用的解决方案，灵感来自 Victor's answer和 Reed's answer (and comments)使用接口(interface)模型。所有相同的方法都在那里，但现在它们隐藏在用户可以在必要时更新的界面中。

直到我意识到我允许类的使用者插入他们自己的类以进行数据访问 (IOutboxMgrDataProvider) 和错误记录 (IErrorLogger)。虽然我仍然提供默认实现，因为我不希望这段代码发生变化，但消费者仍然可以用自己的代码覆盖它们。除了写出多个构造函数(I may change to named and optional parameters)之外，更改我的实现确实没有花很多时间。

public class OutboxManager
{
    private IEnumerable<OutboxMsg> _OutboxMsgs;
    private IOutboxMgrDataProvider _OutboxMgrDataProvider;
    private IVendorMessenger _VendorMessenger;
    private IErrorLogger _ErrorLogger;

    //This is the default constructor, forcing the consumer to provide
    //the implementation of IVendorMessenger.
    public OutboxManager(IVendorMessenger messenger)
    {
         _VendorMessenger = messenger;
         _OutboxMgrDataProvider = new DefaultOutboxMgrDataProvider();
         _ErrorLogger = new DefaultErrorLogger();
    }

    //... Other constructors here that have parameters for DataProvider
    //    and ErrorLogger.

    public void DistributeOutboxMessages()
    {
         try {
              _OutboxMsgs = _OutboxMgrDataProvider.RetrieveMessages();
              foreach om in _OutboxMsgs
              {
                  if (_VendorMessenger.SendMessageToVendor(om))
                      _OutboxMgrDataProvider.MarkMessageAsProcessed(om)
              }
         }
         catch Exception ex {
             _ErrorLogger.LogErrorMessage(ex)
         }
    }

}

//...interface code: IVendorMessenger, IOutboxMgrDataProvider, IErrorLogger
//...default implementations: DefaultOutboxMgrDataProvider(),
//                            DefaultErrorLogger()

最佳答案

有两种非常简单的方法:

1. 将 OutboxManager 设为抽象类，并为每个供应商提供一个子类。 SendMessagesToVendor 可以标记为抽象的，强制每个供应商重新实现它。这种方法很简单，非常符合 OO 原则，并且还具有允许您为其他方法提供实现的优点，但如果您以后想要允许的话，仍然允许覆盖供应商特定版本。

2. 让 OutboxManager 封装一些其他类或接口(interface)，这些类或接口(interface)提供 SendMessagesToVendor 中所需的供应商特定信息。这可以很容易地成为每个供应商实现的一个小接口(interface)，SendMessagesToVendor 可以使用这个接口(interface)实现来发送它的消息。这样做的好处是允许您在此处编写一些代码——可能会减少供应商之间的重复。它还可能使您的 SendMessagesToVendor 方法更加一致，并且更容易测试，因为您只需要依赖此处所需的特定供应商功能。这也可能实现为作为相关(但略有不同)方法传入的委托(delegate)(不过，我个人更喜欢通过委托(delegate)实现接口(interface))。

关于c# - 在这种特定情况下，我应该如何建模我的代码以最大限度地重用代码？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3389588/