C# 将多个不同实例切换到一个类中

我有一些课

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） 这里的事件类应该是接口类还是抽象类

---

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

简而言之，

接口在实现者之间共享契约，
抽象类在继承者之间共享契约和实现

由于语言的限制，您只能从一个类继承，因此您应该只在需要时使用抽象类，以防用户需要从另一个类继承并履行合同

似乎您在这里没有实现，因此接口将是更好的选择

我真的不明白你的第二个问题。是的，将交换机封装在类中被称为工厂模式，这并不少见。但看起来你已经这么做了。所以简而言之，
接口在实现者之间共享契约，
抽象类在继承者之间共享契约和实现

由于语言的限制，您只能从一个类继承，因此您应该只在需要时使用抽象类，以防用户需要从另一个类继承并履行合同

似乎您在这里没有实现，因此接口将是更好的选择

我真的不明白你的第二个问题。是的，将交换机封装在类中被称为工厂模式，这并不少见。但看起来你已经这么做了。所以没有什么可做的。
从接口开始从来都不是一个坏主意，因为许多设计模式都是基于接口的，例如，如果您想要实现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 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();
    }
}

要使用工厂，您可以使用依赖项注入容器（例如）进行注册，下面是一个非常简单的示例：

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

var container=newunitycontainer（）；
container.RegisterType（）；

每次你需要去工厂的时候：

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

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

var eventFactory=container.Resolve（）；
var someEvent=eventFactory.CreateEvent（“SomeCondition”）；

当然，尽管这种设计对于数据库抽象层等方面很有意义，但对于事件系统来说可能过于苛刻。
从接口开始从来都不是一个坏主意，因为许多设计模式都是基于它们的，例如，如果您想实现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 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();
    }
}

要使用工厂，您可以使用依赖项注入容器（例如）进行注册，下面是一个非常简单的示例：

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

var container=newunitycontainer（）；
container.RegisterType（）；

每次你需要去工厂的时候：

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

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

var eventFactory=container.Resolve（）；
var someEvent=eventFactory.CreateEvent（“SomeCondition”）；

当然，尽管这种设计对于数据库抽象层这样的东西很有意义，但对于您的事件系统来说，它可能有点过头了