Suchen des konkreten Typs hinter einer Schnittstelleninstanz

Question

Kurz gesagt, ich habe eine C# -Funktion, die eine Aufgabe für einen bestimmten Typ ausführt, der als Objektinstanz übergeben wird. Alles funktioniert gut, wenn eine Klasseninstanz übergeben wird. Wenn das Objekt jedoch als Schnittstelle deklariert wird, möchte ich wirklich die konkrete Klasse finden und die Aktion für diesen Klassentyp ausführen.

Hier ist das allgegenwärtige schlechte Beispiel (glänzend mit falscher Eigenschaft Gehäuse usw.):

public interface IA 
{ 
    int a { get; set; } 
} 
public class B : IA 
{ 
    public int a { get; set; } 
    public int b { get; set; } 
} 
public class C : IA 
{ 
    public int a { get; set; } 
    public int c { get; set; } 
} 

// snip 

IA myBObject = new B(); 
PerformAction(myBObject); 

IA myCObject = new C(); 
PerformAction(myCObject); 

// snip 

void PerformAction(object myObject) 
{ 
    Type objectType = myObject.GetType(); // Here is where I get typeof(IA) 
    if (objectType.IsInterface) 
    { 
     // I want to determine the actual Concrete Type, i.e. either B or C 
     // objectType = DetermineConcreteType(objectType); 
    } 
    // snip - other actions on objectType 
} 

ich der Code in Perform möchte Reflexion verwenden dagegen Parameter sind und sieht, dass es nicht nur eine Instanz von IA ist aber das ist eine Instanz von B und die Eigenschaft "b" über GetProperties() zu sehen. Wenn ich .GetType() verwende, bekomme ich den Typ von IA - nicht was ich will.

Wie kann PerformAction den zugrunde liegenden Beton-Typ der Instanz von IA bestimmen?

Einige könnten versucht sein, die Verwendung einer abstrakten Klasse vorzuschlagen, aber das ist nur die Einschränkung meines schlechten Beispiels. Die Variable wird ursprünglich als Schnittstelleninstanz deklariert.

Answer 1

Type objectType = myObject.GetType(); 

Sollten Sie noch die konkrete Art geben, nach Ihrem Beispiel.

Answer 2

Sie können nie Instanzen einer Schnittstelle haben. Es ist also nicht möglich, festzustellen, ob Sie mit einer Schnittstelle oder einem konkreten Typ zu tun haben, da Sie immer mit einem konkreten Typ arbeiten werden. Ich bin mir also nicht sicher, ob du eine Frage stellst. Was genau versuchst du zu tun und warum?

Answer 3

Was Sie tun, ist wirklich Design Bett, aber Sie haben keine Reflektion verwenden Sie es wie diese

überprüfen

void PerformAction(object myObject) 
{ 
    B objectType = myObject as B; // Here is where I get typeof(IA) 
    if (objectType != null) 
    { 
     //use objectType.b 
    } 
    else 
    { 
     //Same with A 
    } 
    // snip - other actions on objectType 
} 

Answer 4

suchen Sie vielleicht für die is operator

void PerformAction(object myObject) 
{ 
    if (myObject is B) 
    { 
     B myBObject = myObject as B; 
     myBObject.b = 1; 
    } 

    if (myObject is C) 
    { 
     C myCObject = myObject as C; 
     myCObject.c = 1; 
    } 

    // snip - other actions on objectType 
} 

Answer 5

ich über das schlechte Design zustimmen. Wenn Sie eine Schnittstelle haben, sollte es sein, weil Sie einige allgemeine Funktionalität verwenden müssen, ohne sich darum zu kümmern, was die konkrete Implementierung ist. Als Beispiel, klingt es wie die PerformAction-Methode sollte eigentlich ein Teil der Schnittstelle sein:

public interface IA 
{ 
    int a { get; set; } 
    void PerformAction(); 
} 

public class B: IA 
{ 
    public int a { get; set; } 
    public int b { get; set; } 

    public void PerformAction() 
    { 
     // perform action specific to B 
    } 
} 

public class C : IA 
{ 
    public int a { get; set; } 
    public int c { get; set; } 

    public void PerformAction() 
    { 
     // perform action specific to C 
    } 
} 

void PerformActionOn(IA instance) 
{ 
    if (instance == null) throw new ArgumentNullException("instance"); 

    instance.PerformAction(); 

    // Do some other common work... 
} 


B b = new B(); 
C c = new C(); 

PerformActionOn(b); 
PerformActionOn(c);