सबसे अच्छा तरीका है प्रकार के आधार पर

Question

संभव डुप्लिकेट:
C# - Is there a better alternative than this to ‘switch on type’?

पर विचार क्लासिक:

class Widget { } 
class RedWidget : Widget { } 
class BlueWidget : Widget { } 

अधिकांश भाग के लिए, मेरे यूआई में, मैं सभी Widget एस का इलाज कर सकते हैं। हालांकि, मामूली मतभेद हैं, जिन्हें मुझे if या switch के माध्यम से करने की आवश्यकता है।

संभावित दृष्टिकोण:

Enum संकेतक - निर्माता द्वारा निर्धारित

enum WidgetVariety { Red, Blue } 

class Widget { 
    public WidgetVariety Variety { get; protected set; } 
} 

class RedWidget : Widget { 
    public RedWidget() { 
     Variety = Red; 
    } 
} 

// Likewise for BlueWidget... 

switch (mywidget.Variety) { 
case WidgetVariety.Red: 
    // Red specific GUI stuff 

case WidgetVariety.Blue: 
    // Blue specific GUI stuff 
} 

उपयोग is

Widget w = ...; 
if (w is RedWidget) { 
    (RedWidget)w ... 
} 
else if (w is BlueWidget) { 
    (BlueWidget)w ... 
} 

कारण मैं इस का सहारा लिया गया है 1) के अधिकांश कोड पहले से ही कुछ हद तक लिखा है, लेकिन बहुत उलझन में है। 2) कोड का 9 0% समान है - मूल रूप से ग्रिड व्यू में केवल एक कॉलम को प्रकार के आधार पर अलग-अलग संभाला जाना चाहिए।

आप किसकी सिफारिश करेंगे? (या किसी को भी एक बेहतर समाधान है?)

---

संपादित मैं जानता हूँ कि मैं शायद आगंतुक पैटर्न की सिफारिश की हो जाएगा, लेकिन यह केवल इस मामले में विरल, मामूली अंतर के लिए जटिल लगता है।

संपादित करें 2 तो एक विशेष अंतर मुझे हार्ड टाइम सॉर्टिंग करना मुश्किल था, यह कॉलम दो प्रकार के बीच अलग है। एक मामले में, यह bool मान पुनर्प्राप्त करता है, और ग्रिड सेल को असाइन करता है। दूसरे मामले में, यह एक स्ट्रिंग मान मिलता है।

मैं इस मामले में लगता है, यह स्पष्ट है कि मैं निर्धारित कर सकते हैं होना चाहिए:

public object virtual GetColumn4Data(); 

public override GetColumn4Data() { return m_boolval; } 

public override GetColumn4Data() { return m_mystring; } 

यह object के उपयोग के कारण शुरू में मेरे लिए गलत महसूस किया है,। हालांकि, उस संपत्ति का प्रकार है जिसे मैं सेल में असाइन कर रहा हूं, इसलिए बेशक यह समझ में आता है!

कार्यालय आज ऐसा लगता है पर बहुत लंबे ...

Answer 1

एक और संभावना है। आभासी प्रेषण का उपयोग करें:

class Widget 
{ 
    public virtual void GuiStuff() { } 
} 
class RedWidget : Widget 
{ 
    public override void GuiStuff() 
    { 
     //... red-specific GUI stuff 
     base.GuiStuff(); 
    } 
} 
class BlueWidget : Widget 
{ 
    public override void GuiStuff() 
    { 
     //... blue-specific GUI stuff 
     base.GuiStuff(); 
    } 
} 

Answer 2

Subtype polymorphism, सबसे अच्छा समाधान है चेकों के इस प्रकार से परहेज मुख्य कारणों OO बनाया गया था से एक है।

Widget में एक विधि DoSomething() (शायद सार) हो सकती है और फिर RedWidget और BlueWidget इसे ओवरराइड कर देगी।

भी देखें मार्टिन फाउलर की Replace Conditional with Polymorphism:

देखा: आप एक सशर्त है कि एक वस्तु के प्रकार के आधार पर अलग व्यवहार चुनता है।

रिएक्टर: सशर्त के प्रत्येक चरण को सबक्लास में ओवरराइडिंग विधि में ले जाएं। मूल विधि सार बनाओ।

Answer 3

संपादन # 2 के तहत अपने प्रश्न के लिए, आप उप-वर्गों के बीच प्रकार को अलग करने के लिए एक सामान्य वर्ग का उपयोग कर सकते हैं, हालांकि यह आपके डिजाइन के आधार पर आपके लिए काम कर सकता है या नहीं। यह शायद अन्य कठिन डिजाइन निर्णयों का नेतृत्व करेगा।

असहज उदाहरण:

internal abstract class BaseClass 
{ 
    protected object mValue; // could also be defined as a T in BaseClass<T> 

    public object GetColumn4Data { get { return mValue; } } 
} 

// this is a group of classes with varying type 
internal abstract class BaseClass<T> : BaseClass 
{ 
    public T GetTypedColumn4Data 
    { 
     get { return (T)mValue; } 
     set { mValue = value; } 
    } 
} 

// these are not really necessary if you don't plan to extend them further 
// in that case, you would mark BaseClass<T> sealed instead of abstract 
internal sealed class BoolSubClass : BaseClass<bool> 
{ 
    // no override necessary so far 
} 

internal sealed class StringSubClass : BaseClass<string> 
{ 
    // no override necessary so far 
} 

लेकिन ध्यान दे, कि तुम सच में एक भी संदर्भ प्रकार कुछ संपत्ति या विधि पर एक अलग वापसी प्रकार होगा कि नहीं मिल सकता है। एक BaseClass संदर्भ सबसे अच्छा सामान्य प्रकार (जैसे object) पर वापस आ जाएगा।