Question

我有一个静态类Manager它应该在两层逻辑之间进行调整，这是不好的做法通过在其中嵌套静态类来分离功能？我有大约24个不同的科目，每个科目有2-3个功能。并且希望避免为此创建二十几个课程

我的意思是用这个：

static class Manager
{
    static class Type1
    {
        static void Method1();
        static void Method2();
        static void Method3(); 
    }
    static class Type2
    {
        static void Method4();
        static void Method5();
        static void Method6(); 
    }
    static class Type3
    {
        static void Method7();
        static void Method8();
        static void Method9();
    }
}

而不是：

static class Manager
{
        static void Method1();
        static void Method2();
        static void Method3(); 
        static void Method4();
        static void Method5();
        static void Method6(); 
        static void Method7();
        static void Method8();
        static void Method9();
}

类似名称空间，但在类中。

Answer 1

如果您有关于设计选择，有很多选择。

首先，您可以将所有内容都集中到一个类中，这个类非常难以调试并混合了多个职责。

第二，您可以创建嵌套类，正如您所指出的那样，您可以更好地分离关注点/代码，但仍然可以将所有内容硬编码并放在一个大的源代码文件中。

第三，可扩展性更强，您可以考虑任何容器模式。我在下面列出了一个可以保持你的课程分离的内容，如果你关心，可以更容易测试，以及可交换。

interface IManagementRole 
{
}

class Dummy1: IManagementRole
{
    public void Method1() { Console.WriteLine("Dummy1.Method1()"); }
    public void Method2() { Console.WriteLine("Dummy1.Method2()"); }
}

class Dummy2: IManagementRole
{
    public void Method3() { Console.WriteLine("Dummy2.Method3()"); }
    public void Method4() { Console.WriteLine("Dummy2.Method4()"); }
}

static class Manager
{
    private static Dictionary<Type, IManagementRole> myTypes = new Dictionary<Type, IManagementRole>();

    static Manager()
    {
        myTypes.Add(typeof(Dummy1), new Dummy1());
        myTypes.Add(typeof(Dummy2), new Dummy2());
    }

    public static T GetManagableType<T>() where T: class
    {
        if (myTypes.ContainsKey(typeof(T)))
        {
            return myTypes[typeof(T)] as T;
        }

        throw new ArgumentException("Type is not a managable type.", "T");
    }
}

class Program
{
    public static void Main(string[] args)
    {
        Manager.GetManagableType<Dummy1>().Method1();
        Manager.GetManagableType<Dummy1>().Method2();
        Manager.GetManagableType<Dummy2>().Method3();

        Console.Write("Press any key to continue . . . ");
        Console.ReadKey(true);
    }
}

Answer 2

我会说，是的。看起来不是一个糟糕的设计，imo。

另请考虑另一种方法：

您可以拥有List<Type> list = bew List<Type>{new Type1(), new Type2()..., new TypeN()};

并且有一个类从该集合中选择一个适合注入的类。这样你就可以避免上大班。

嵌套类适配器模式？

2 个答案: