0

我有一个静态类Manager，它应该在两层逻辑之间进行调整，通过在其中嵌套静态类来分配功能是一种不好的做法吗？我有大约两打不同的主题要管理，每个主题有 2 -3 个功能。并希望避免为此创建 2 打类

我的意思是使用这个：

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

类似于命名空间的东西，但在一个类中。

4

2 回答 2

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);
    }
}
于 2012-04-19T07:36:35.760 回答
0

我会说，是的。似乎不是一个糟糕的设计，imo。

还要考虑另一种方法：

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

并有一个类从这个集合中选择一个合适的注入。这样，您将避免上大课。

于 2012-04-19T07:29:18.150 回答