0

我有一个设计问题。我正在使用某人编写并正在维护的编码 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
}
4

4 回答 4

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();
}
于 2012-12-13T02:15:43.207 回答
0

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

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

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

于 2012-12-13T02:12:03.107 回答
0

对于我所看到的这个类是一个“单例容器”，我认为这可以。如果存在更好的方法来做到这一点？我认为这取决于使用的上下文。

有用的链接： SingletonPattern ObjectFactory

于 2012-12-13T02:13:50.500 回答
0

如果您很难向西装推荐 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;
            }
        }
    }
}

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

另外：目前的设计很难维护......并且违反了 DRY。

于 2012-12-13T02:15:50.407 回答