5

我最近（几个月前）换了工作，并继承了一个代码库，该代码库尽可能多地违反了 SOLID 原则中的每一项。似乎编写此代码的人决定详细研究每一个良好的编码实践，并尽可能频繁、最彻底地违反它们。

我是这个产品的唯一开发者——组织中没有人知道代码，而且代码库太大太复杂，无法完全重写。我正在研究我可以做出的最高价值的改变，以使代码库变得灵活和健壮。放弃该产品也不是一种选择。

产品中所有问题的根源都源于一组核心业务逻辑数据结构的类。这些类有很多问题，但我真正感兴趣的是以下内容：

public static class NetCollection
{
    private static Logger LogFile { get { return Logger.GetMethodLogger(2); } }
    // Declare local variables.
    private static Dictionary<string, NetObject> netObjectHashTable;
    private static Dictionary<string, NetTitle> titlePropertyHashTable;
    private static Dictionary<string, NetObject> referenceDataHashTable;
    private static Dictionary<int, SortedDictionary<string, int>> picklistHashTable;

    public static IEnumerable<NetObject> NetObjects
    {
        get
        {
            return netObjectHashTable.Values;
        }
    }

    static NetCollection()
    {
        netObjectHashTable = new Dictionary<string, NetObject>();
        titlePropertyHashTable = new Dictionary<string, NetTitle>();
        referenceDataHashTable = new Dictionary<string, NetObject>();
        picklistHashTable = new Dictionary<int, SortedDictionary<string, int>>();
    }

    public static void AddNetObject(NetObject newObject)
    {
        if (newObject == null)
            return;
        if (newObject.TitleType == "Reference Data")
        {
            // Check if hash table contains key
            if (!referenceDataHashTable.ContainsKey(newObject.ID.ToString()))
            {
                referenceDataHashTable.Add(newObject.ID.ToString(), newObject);
            }
        }
        else
        {
            // Check if hash table contains key
            if (!netObjectHashTable.ContainsKey(newObject.ID.ToString()))
            {
                netObjectHashTable.Add(newObject.ID.ToString(), newObject);
            }
        }
    }
}

为了简洁起见，我已经从这个类中剪掉了很多其他的方法。

如您所见，围绕这个类存在大量问题（在静态类中存储状态是一种巨大的代码气味——围绕该类编写整个应用程序简直是疯了）。

我目前的意图是将这个类重构为一个适当的单例类（并最终成为一个常规类，以便我可以使用户能够同时打开多个文档）。

我应该这样做吗？

进行此更改的最大风险是什么？我可以采取任何方法来降低进行此更改的风险吗？

4

4 回答 4

4

是的，转换为单例似乎是很好的第一步。它仍然不是线程安全的，但它是一个开始。然后，您可以将其从真正的单例更改为允许构造单独实例的单例，但也具有与单例相同的“默认”实例。（当然，您可以将“实例持有者”分离到一个单独的类中。）这将允许您开始编写可测试的代码，每次都以一个新的实例开始。

之后，您可以开始引入依赖注入，以便需要访问同一实例的每个类都可以获取它......并删除“默认”实例。

当然，如果您可以减少需要访问同一实例的类的数量，那就更好了。

对于线程，您要么需要锁定每个方法，要么使用ConcurrentDictionary.

于 2013-07-18T07:16:17.547 回答
2

如果您对这种类型如何在您的应用程序中流动一无所知，那么这是一项危险的任务。但是，如果您真的需要这样做而不可能破坏一切，我会喜欢：

知道我需要的是文档之间的不同划分，并且我知道（已被时间证明）这种类型适用于单个文档，让我们添加 Document slice。

假设Document有Name属性，我们可以考虑类似（示例）：

public static void AddNetObject(string documentName, NetObject newObject)
{
    ....
}

使所有字段非静态：

   //NO STATIC
    ...
    private Logger LogFile { get { return Logger.GetMethodLogger(2); } }   
    private Dictionary<string, NetObject> netObjectHashTable;
    private Dictionary<string, NetTitle> titlePropertyHashTable;
    private Dictionary<string, NetObject> referenceDataHashTable;
    private Dictionary<int, SortedDictionary<string, int>> picklistHashTable;

将它们移动到内部

private class NetDocument {
       public string DocumentName {get;set;} //DEFINE DOCUMENT IT RELATED TO !
       ...
       private Logger LogFile { get { return Logger.GetMethodLogger(2); } }   
       private Dictionary<string, NetObject> netObjectHashTable;
       ....

  }

因此，您可以在单个文档和与它们相关的数据之间创建具体的隔离。

在主课之后，你可以拥有：

public static class NetCollection
{
    ... 

    //Key: document name
    //Value: NetDocument data
    private Dictionary<string, NetDocument> documents = new ....
}

这只是一个大概的想法（草图），您肯定需要对其进行更改以适应您的需求。

于 2013-07-18T07:19:34.273 回答
0

你能把它包装在一个静态工厂类上吗？把你认为需要的所有东西都做成单例，并根据需要保持某些东西不变？它将解决一些问题并为您提供一些灵活性。

于 2013-07-18T07:15:41.680 回答
0

static类和单例之间没有真正的区别。是的，它的实现方式不同，但你有同样的问题（只是为了不拥有——static我认为没有必要采取行动）。

如果您能够获得“真实”实例，那就去做吧。但是仅仅因为 Lint 不抱怨而重构为 Singleton 并不是要走的路，恕我直言。

于 2013-07-18T07:18:55.653 回答