將多個不同的實例切換到一個類中

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）事件類應該是接口類還是抽象類？

2）如何將switch語句移到更有意義的類中。 我應該在這里使用Factory還是缺少任何設計模式？

Answer 1

總之，一個interface實現者之間合同的股票，一個abstract class的繼承者之間的合同份額和實施 。

由於語言的限制，您只能從一個類繼承，因此，僅在需要時才使用抽象類，以防用戶需要從另一個類繼承並履行合同。

似乎您在這里沒有實現，因此接口將是更好的選擇。

我真的沒有第二個問題。 是的，將您的交換機封裝在一個類中將被稱為工廠模式，並且並非罕見。 但是看來您已經做到了。 所以...那里沒事做。

Answer 2

從接口開始絕不是一個壞主意，因為許多設計模式都基於它們，例如，如果您想實現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();
    }
}

要使用工廠，您可以使用依賴項注入容器（例如Unity ）進行注冊，這是一個非常簡單的示例：

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

每次您需要去工廠時：

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

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

當然，盡管這種設計對於諸如數據庫抽象層之類的東西非常有意義，但對於事件系統而言可能過於矯kill過正。