Question

我有一个设计问题。我正在使用有人编写的Coded UI测试框架，我正在维护。我确信这个设计方式不正确，但我想我会得到一些其他意见。它基本上是一个大型静态类，其唯一目的是创建和返回其他对象。

好/坏......为什么呢？我正在游说接受一个非常重要的重构，并且想让我的案子令我信服地取悦我的经理。

public static class ParentClass
{
    private static ChildClass1 childClass1;
    private static ChildClass2 childClass2;
    // 10+ more of the same

    // Properties
    public ChildClass1 ChildClass1
    {
        get 
        {
            if (childClass1 == null)
            {
                childClass1 = new ChildClass1();
            }
            return childClass1;
        }
     }

    public ChildClass2 ChildClass2
    {
        get 
        {
            if (childClass2 == null)
            {
                childClass2 = new ChildClass2();
            }
            return childClass2;
        }
    }
    // 10+ more of the same
}



[TestClass]
public class TestClass1
{
    [TestMethod]
    public void TestMethod1()
    {
        var x = ParentClass.ChildClass1.SomeMethod();
        Assert.IsNotNull(x);
    }

    [TestMethod]
    public void TestMethod2()
    {
        var x = ParentClass.ChildClass2.SomeMethod();
        Assert.IsNotNull(x);
    }

    // 10+ more of the same
}

Answer 1

这类似于单例模式，但是从提供的代码中可以看出为什么它是以这种方式设计的。

var x = ParentClass.ChildClass1.SomeMethod();

很容易被替换为

var x = new ChildClass1().SomeMethod();

然后你可以摆脱ParentClass.ChildClass1和ParentClass.childClass1，除非多次使用ParentClass.ChildClass1并将方法调用的状态带到方法调用。

虽然这看起来并不优雅，但可能过于冗长，但我不认为这是一个重大问题。

就个人而言，我会以这种方式实现它，但很难判断这是否适用于所有省略的代码。

[TestClass]
public class TestClass1
{
    private static void ExecuteTestCore<T>() where T : new(), IHaveAMethod
    {
        var x = new T().SomeMethod();

        Assert.IsNotNull(x);
    }

    [TestMethod]
    public void TestMethod1()
    {
        TestClass1.ExecuteTestCore<ChildClass1>();
    }

    [TestMethod]
    public void TestMethod2()
    {
        TestClass1.ExecuteTestCore<ChildClass2>();
    }

    // 10+ more of the same.
}

internal interface IHaveAMethod
{
    void SomeMethod();
}

Answer 2

如果不知道它是如何使用的话，很难判断这是“好”还是“坏”，但我建议看一下IoC容器。他们提供这种类型的功能和开箱即用的更多功能

通常，如果将IoC容器用作依赖注入的一部分，它可能非常有用。如果你没有使用DI，那么这个静态类可能不是很有帮助

https://stackoverflow.com/questions/2515124/whats-the-simplest-ioc-container-for-c

Answer 3

我可以看到这个类是一个“单例容器”我认为这可以。如果存在更好的方法吗？我认为这取决于使用情况。

有用的链接： SingletonPattern ObjectFactory

Answer 4

如果您很难向西装提出IoC（正如其他人所建议的那样）..或者向他们展示更小的代码？

public class ParentClass<T> where T : class, new() {
    private static T _instance = null;
    private static readonly object _locker = new object();

    public static T GetObject() {
        if (_instance == null) {
            lock (_locker) {
                if (_instance == null) {
                    return new T();
                }
                return _instance;
            }
        }
    }
}

（免责声明：未经测试。可能不是最好的线程安全实现）

另外：现在的设计难以维持......并且干扰了干扰。

使用Static类作为其他对象的集合/容器

4 个答案: