Umwandlung eines Schnittstellentyps in eine implementierende Klasse

Question

Meine Frage bezieht sich auf das folgende Beispiel, das ich angegeben habe. Ich denke, das ist ein Anti-Muster. Nicht sicher, ob es einen Namen hat. Was ich möchte, ist, auf die spezifischen Implementierungen zugreifen zu können. Beim Versuch, Antworten zu vermeiden, die nur eine Meinung darüber sein könnten, ob dieses Muster schlecht/gut ist, würde ich gerne einen besseren Weg finden, dieses Problem zu überdenken, und wenn es einen Namen für dieses (Anti-) Muster gibt.

interface WTF 
{ 
    Type type; 
} 

enum Type 
{ 
    A, 
    B 
} 

interface A : WTF 
{ 
    Type type = Type.A; 

    void MethodA(); 
} 

interface B : WTF 
{ 
    Type type = Type.B; 

    void MethodB(); 
} 



void Foo(List<WTF> list) 
{ 
    foreach(var i in list) 
    { 
    switch(i.type) 
    { 
     case Type.A: 
     A a = (A)i; 
     a.MethodA(); 
     break; 
     case Type.B: 
     B b = (B)i; 
     b.MethodB(); 
     break; 
    } 
    } 
} 

Answer 1

Warum müssen Sie einen anderen Namen angeben? In diesem Fall ist diese beste Weg ist, wie folgt aus:

interface WTF 
{ 
    Type type; 
    void Method(); 
} 

enum Type 

interface A : WTF 
{ 

} 

interface B : WTF 
{ 


} 
void Foo(List<WTF> list) 
{ 
    foreach(var i in list) 
    { 
    i.Method(); 
    } 
}