c# - 将多个不同的实例切换到一个类中

Question

我有一些课，

public abstract class Event{
}

public class EventA : Event{
   public string Id{get; private set;}
   public string Name{get; private set;}
   public EventA(string id, string name){
     Id = id;
     Name = name;
   }
} 

public class EventB : Event{
   public string Prop{get; private set;}
   public string Prop1{get; private set;}
   public EventA(string prop, string prop1){
     Prop = prop;
     Prop1 = prop1;
   }
}

public class EventC : Event{
   // .........
}  

public class EventD : Event{
   // .........
}  

public class SomeClass{
    public Event SomeMethod(){
       switch(SomeCondition){
          case "FirstCondition":
                return new EventA(...);
          case "SecondCondition":
                return new EventC(...); 
          case "ThirdCondition":
                return new EventC(...);
          case "FourthCondition":
                return new EventD(...);

       }
    }
}

现在我有两个问题，

1)这里的事件类应该是接口(interface)还是抽象类？

2) 如何将 switch 语句移动到一个更有意义的类中。我应该在这里使用工厂还是缺少任何设计模式？

Answer 1

从接口(interface)开始从来都不是一个坏主意，因为许多设计模式都基于它们，例如，如果您想实现 IoC 或工厂。

所以事件可以变成 IEvent:

public interface IEvent
{
}

现在，假设您的所有事件都必须以某种方式初始化，或者它们应该共享一些通用的基本实现，那么您可以使用一个抽象类，所有事件实现都将从该抽象类继承:

public abstract BaseEvent : IEvent
{
     protected BaseEvent(string name);

     //Method must be implemented
     public abstract SomeMethod();

     //Method can be overriden
     public virtual DoSomething()
     {
     }
}

然后，您可以创建实际的“事件”实现，它们都共享一个公共(public)接口(interface)和一些您可以使用多态性进行修改的基本功能，例如:

public EventA : BaseEvent
{
    public EventA() : base("Event A")
    {
    }

    public override SomeMethod()
    {
    }

    public override DoSomething()
    {
    }
}

最后，回答你的问题，你将如何初始化你的对象？

这真的取决于您的应用程序需要什么，这个实现会经常改变吗？您是否需要一个抽象层，允许您在以后用更新或不同的技术(例如新的数据库系统)替换整个实现，这是一个涉及不同团队的大项目吗？

对于一个永远不会改变的简单系统，您可以像您已经在做的那样做一些事情，对于一个更复杂的系统，您可以使用 IoC 容器，您在问题中建议的工厂模式或两者的组合，这里是工厂模式的简单实现:

public interface IEventFactory
{
    IEvent CreateEvent(string someCondition);
}

public class EventFactory : IEventFactory
{
    public IEvent CreateEvent(string someCondition)
    {
        switch(SomeCondition){
            case "FirstCondition":
                return new EventA();
            case "SecondCondition":
                return new EventB(); 
            case "ThirdCondition":
                return new EventC();
            case "FourthCondition":
                return new EventD();
    }
}

要使用工厂，您可以使用依赖注入(inject)容器(例如 Unity )注册它，这是一个非常简单的示例:

var container = new UnityContainer();
container.RegisterType<IEventFactory, EventFactory >();

并且每次需要获取工厂时:

var eventFactory = container.Resolve<IEventFactory>();

var someEvent = eventFactory.CreateEvent("SomeCondition");

当然，虽然这种设计对于数据库抽象层之类的东西很有意义，但对于您的事件系统来说可能有点过分了。