ओओ डिज़ाइन - इंटरफ़ेस

Question

के माध्यम से कार्यान्वयन विवरण का खुलासा करना मेरे पास एक कक्षा है, जिसमें एक बड़ी डेटा संरचना में कुछ विवरण हैं, इस पर कुछ गणना करने के लिए एल्गोरिदम स्वीकार करते हैं, डेटा संरचना में इनपुट मान्य करने के तरीके हैं। लेकिन फिर मैं डेटा संरचना वापस करना चाहता हूं, ताकि इसे व्यू मॉडल द्वारा विभिन्न आउटपुट फॉर्म (स्ट्रिंग/सी # डेटाटेबल/कस्टम फ़ाइल आउटपुट) में परिवर्तित किया जा सके।

class MyProductsCollection { 
    private IDictionary<string, IDictionary<int, ISet<Period>>> products; 

    // ctors, verify input, add and run_algorithm methods 
} 

मुझे पता है कि आप उपयोग करना डिजाइन सिद्धांत "इंटरफेस नहीं कार्यान्वयन पर निर्भर करते हैं" अपेक्षा की जाती है, तो मैं वर्ग के लिए एक इंटरफेस बनाना चाहते हैं।

मैं निम्नलिखित इंटरफ़ेस लिखने से कैसे बच सकता हूं? कारण यह कार्यान्वयन के विवरण का खुलासा करेगा और उसी फॉर्म को वापस करने के लिए किसी अन्य ठोस कार्यान्वयन को बांध देगा।

interface IProductsCollection { 
    IDictionary<string, IDictionary<int, ISet<IPeriod>>> GetData(); 
    // other methods 
} 

कैसे मैं आसानी से डेटा संरचना पर पुनरावृति साफ इसे इस तरह प्रकट किए बिना आउटपुट की विभिन्न किस्मों के रूप में कर सकते हैं?

संपादित करें:

के बाद से वर्ग निर्माता में IFunc<IDictionary<string, IDictionary<int, ISet<IPeriod>>>> में ले जाता है डेटा संरचना पर पुनरावृति और गणना करने के लिए, मैं इसे एक और IFunc है, जो चल रहा गणना के बजाय उत्पादन बनाएगी साथ आपूर्ति कर सकता है। हालांकि, मुझे नहीं पता कि मैं कंक्रीट क्लास कन्स्ट्रक्टर से इसे कैसे कर सकता हूं।

Answer 1

IDictionary<string,IDictionary<int,ISet<Period>>> की संरचना वास्तव में बहुत संदिग्ध है - जब आप शब्दकोशों का शब्दकोश देखते हैं, तो अच्छी संभावना है कि आप आंतरिक शब्दकोश को समाहित करने के लिए कक्षा बनाने के लिए एक अवसर या दो चूक गए हैं।

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

interface IYearlyPeriods { 
    bool HasPeriodsForYear(int year); 
    ISet<Periond> GetPeriodsForYear(int year); 
} 

मुझे पता नहीं क्या समय में है है, तो आप एक डोमेन-विशिष्ट नाम का चयन करने की आवश्यकता होगी इंटरफ़ेस के लिए।

इसके अलावा, आप भी IDictionary के अगले स्तर लपेट कर सकते हैं:

interface IProductsCollection { 
    IProductDataSource GetDataSource(); 
    // other methods 
} 

मुख्य विचार में डोमेन-विशिष्ट इंटरफेस का उपयोग करने के लिए है:

interface IProductDataSource { 
    IEnumerable<string> ProductNames { get; } 
    IYearlyPeriods GetProductData(string productName); 
} 

अब तुम इस तरह एक अंतरफलक परिभाषित कर सकते हैं जेनेरिक संग्रह की जगह, ताकि आपके कोड के पाठकों और कार्यान्वयनकर्ताओं के पास कुछ भी पता चल सके कि दस्तावेज का जिक्र किए बिना अंदर क्या है।

आप भी आगे जाने, और जटिल संरचना है कि आप IProductPeriods कार्यान्वयन के IDictionary साथ आंतरिक रूप से रखने के साथ IDictionary बदल सकते थे। यदि आप IYearlyPeriods रखना चाहते हैं जो आप अपरिवर्तनीय उपयोगकर्ताओं के सामने आते हैं, लेकिन आप स्वयं को संशोधित करने में सक्षम होना चाहते हैं, तो आप एक परिवर्तनीय कार्यान्वयन कर सकते हैं, और कार्यान्वयन कक्षा में internal रख सकते हैं।

Answer 2

मैं IDictionary निजी रखने और इंटरफ़ेस में एक साधारण IEnumerable रखने का सुझाव दूंगा।

आपके मामले में यह एक कस्टम डीटीओ हो सकता है जो IDictionary<int, ISet<IPeriod>> की सभी नैतिकता को छुपाता है - जो पहले से ही काफी जटिल है और संभवतया आसानी से बदल सकता है क्योंकि आपको नई सुविधाओं को लागू करने की आवश्यकता है।

यह हो सकता है कुछ की तरह:

class ExposedPeriod 
{ 
     public int PeriodIdentifier { get; set; } 
     public IEnumerable<IPeriod> Periods { get; set; } 
} 

ExposedPeriod और PeriodIdentifier शायद हालांकि बेहतर नामों की जरूरत है। आपके डोमेन शब्दावली में अच्छे नाम मिल सकते हैं।