Question

I have a design question. I’m working with a Coded UI test framework that someone wrote and I am maintaining. I am convinced the way this is designed incorrectly but I thought I would get some other opinions. It’s basically a large static class whose sole purpose is to create and return other objects.

Good/Bad…why? I am lobbying to take on a pretty significant refactor and want to please my case convincingly to my manager.

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

This is something like a singleton pattern but it does not become clear from the provided code why it is designed this way.

var x = ParentClass.ChildClass1.SomeMethod();

could easily be replaced with

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

and then you can get rid of ParentClass.ChildClass1 and ParentClass.childClass1 unless ParentClass.ChildClass1 is used several times and carries state from method call to method call.

But while this does not really look elegant and might be overly verbose, I would not consider this a major issue.

Personally I would have implemented it this way but it is hard to tell if this would work for all the omitted code.

[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();
}