问题 我应该如何建模我的代码以在这种特定情况下最大化代码重用？

有两种非常简单的方法：

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

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

如果将其设为抽象基类，则必须继承它，可以强制在具体对象中实现此方法。

using System;
using System.Collections.Generic;

public abstract class OutboxManagerBase
{
private List<string> _OutboxMsgs;

public 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.
}

protected abstract void SendMessagesToVendor();

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.
}
}



public class OutBoxImp1 : OutboxManagerBase
{
    protected override void SendMessagesToVendor()
    {
        throw new NotImplementedException();
    }
}

你可以做到的一种方法是使用接口。

public interface IVendorSender
{
    IEnumerable<OutboxMsg> GetMessages();
}

然后在构造函数中将实例作为参数。

public class OutboxManager 
{
    private readonly IVendorSender _vendorSender; 

    public OutboxManager(IVendorSender vendorSender)
    {
        _vendorSender = vendorSender ?? new DefaultSender();
    }

    private void SendMessagesToVendor()   // <== THIS CODE CHANGES EACH IMPLEMENTATION
    {
        _vendorSender.GetMessages(); // Do stuff...
    }    
}

它看起来像你在那里的大部分路。

一些基本步骤：

1无论供应商是什么，都要弄清楚代码的哪些部分是相同的。
2将它们写入可重复使用的模块（可能是.dll）
3确定每个供应商的更改。
4确定（上述）代码 - 为此编写特定模块。
5确定（上述）配置 - 为这些配置方案创建配置方案。

然后，您的.exe将正确地调用相应的 OutboxManager 对象为正确的供应商。

创建一个抽象基类，并将需要更改的方法更改为抽象保护，例如

public abstract 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.
    }

    protected abstract void SendMessagesToVendor();   // <== THIS CODE CHANGES 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（）的实现，共享实现在抽象基类中定义。

同样来自Copsey先生。清单解决方案＃1确实是分类。无论是运气还是技巧，您已经构建了代码以使其易于实现。

根据供应商之间差异的性质，如果有很多共同的功能，另一种选择可能是拥有一个包含每个供应商记录的数据库，并且有几个控制处理的标志。如果你可以把它分解为“如果flag1是真的那么做其他事做B事情;总是做事情C;如果flag2是真的做事情D其他我们已经完成了”，然后而不是重复一堆代码跨供应商你或许可以让数据控制处理。

哦，我可能会添加或许显而易见：如果唯一的区别是数据值，那么当然只是将数据值存储在某处。想要一个简单的例子，如果供应商之间的唯一区别是您连接的域名，那么只需创建一个包含vendorid和域名的表，读取值并将其插入。