嵌套类适配器模式？

Question

我有一个静态类Manager，它应该在两层逻辑之间适配，通过在里面嵌套静态类来划分功能是不是一种坏做法？我有大约24个不同的科目要管理，每个科目有2 -3个功能。并希望避免为此创建24个类

我的意思是使用这个：

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

如果你关心的是设计选择，有很多选择。

First，你可以把所有的东西都放到一个类中，这个类很难调试，并且混合了几个职责。

在第二个中，您可以创建嵌套类，正如您还提到的，在这种情况下，您可以更好地分离关注点/代码，但仍然将所有内容硬编码并保存在一个大的源代码文件中。

Third，它的可扩展性更强，你可以考虑任何你想要的容器模式。我在下面列出了一个，它可以让你的类保持分离，更容易测试，如果你关心的话，以及可交换的。

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

我会说，是的。这设计看起来不错，国际海事组织。

还可以考虑另一种实现此目的的方法：

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

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