एक इंटरफ़ेस उदाहरण के पीछे कंक्रीट प्रकार ढूँढना

Question

एक लंबी कहानी को कम करने के लिए मेरे पास एक सी # फ़ंक्शन है जो ऑब्जेक्ट इंस्टेंस के रूप में पास किए गए किसी दिए गए प्रकार पर कार्य करता है। सभी वर्ग ठीक होने पर ठीक काम करता है। हालांकि, जब ऑब्जेक्ट को इंटरफ़ेस के रूप में घोषित किया जाता है, तो मैं वास्तव में ठोस वर्ग को ढूंढना चाहता हूं और उस वर्ग प्रकार पर कार्रवाई करना चाहता हूं।

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 
} 

मैं चाहूँगा के खिलाफ यह पैरामीटर हो PerformAction में कोड प्रतिबिंब का उपयोग करें और देखते हैं कि यह सिर्फ आइए का एक उदाहरण नहीं है करने के लिए:

यहाँ हर जगह का बुरा उदाहरण (गलत संपत्ति आवरण आदि के साथ चमकीला) है लेकिन यह बी का एक उदाहरण है और GetProperties() के माध्यम से संपत्ति "बी" देखने के लिए। अगर मैं .GetType() का उपयोग करता हूं तो मुझे आईए का प्रकार मिलता है - जो मैं चाहता हूं।

प्रदर्शन एक्शन आईए के उदाहरण के अंतर्निहित कंक्रीट प्रकार को कैसे निर्धारित कर सकता है?

कुछ लोग सार कक्षा का उपयोग करने का सुझाव देने के लिए प्रेरित हो सकते हैं लेकिन यह केवल मेरे बुरे उदाहरण की सीमा है। चर मूल रूप से एक इंटरफेस उदाहरण के रूप में घोषित किया जाएगा।

Answer 1

Type objectType = myObject.GetType(); 

है जैसे कि यह जाँच अभी भी आप ठोस प्रकार देना चाहिए कर सकते हैं अपने उदाहरण के अनुसार प्रतिबिंब का उपयोग करने की जरूरत नहीं है।

Answer 2

आपके पास कभी इंटरफ़ेस के उदाहरण नहीं हो सकते हैं। तो यह निर्धारित करना कि आप एक इंटरफेस या ठोस प्रकार से निपट रहे हैं, यह संभव नहीं है क्योंकि आप हमेशा एक ठोस प्रकार से निपटेंगे। तो मुझे यकीन नहीं है कि आप कोई सवाल समझते हैं। आप वास्तव में क्या करने की कोशिश कर रहे हैं और क्यों?

Answer 3

क्या आप कर रहे हैं वास्तव में डिजाइन बिस्तर है, लेकिन आप यदि आप इस

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

शायद तुम 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

मुझे बुरा डिजाइन के बारे में सहमत होना होगा के लिए देख रहे हैं। यदि आपके पास इंटरफ़ेस है, तो ऐसा होना चाहिए क्योंकि कंक्रीट कार्यान्वयन की देखभाल किए बिना आपको कुछ सामान्य कार्यक्षमताओं का उपयोग करने की आवश्यकता है। यह देखते हुए कि आप उदाहरण हैं, ऐसा लगता है कि PerformAction विधि वास्तव में इंटरफ़ेस का हिस्सा होना चाहिए:

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);