मान लीजिए कि मेरी प्रथम श्रेणी में एक सार्वजनिक संपत्ति है जो निर्यात की जाने वाली फ़ाइल के शीर्षकों को लौटाती है। उदाहरण के लिए:

private readonly List<string> fileHeaders = new List<string>
{
    "Last Name", 
    "First Name", 
    "Middle Name", 
    "Suffix", 
    "Degree",           
};

public List<string> FileHeaders
{
    get { return fileHeaders; }
}

अब मेरे पास एक class B है कि जो फ़ाइल हेडर इसे निर्यात करता है उसमें केवल इतना ही अंतर है कि इसका एक और कॉलम हेडर है, उदाहरण के लिए एड्रेस कॉलम।

एक अच्छी वस्तु उन्मुख डिजाइन क्या है जो ऐसा कर सकती है?

c#
0
Bohn 25 नवम्बर 2015, 00:56

3 जवाब

सबसे बढ़िया उत्तर

मैं इस समाधान को एक इंटरफ़ेस और अमूर्त आधार वर्ग के साथ पसंद करूँगा जो व्युत्पन्न वर्गों में कार्यान्वयन को लागू करता है।

यह SOLID ओपन-क्लोज्ड सिद्धांत को कवर करता है

public interface IFileHeaders
{
    IList<string> GetFileHeaders();
}

public abstract class FileHeaderBase : IFileHeaders
{
    protected abstract IList<string> FileHeaders { get; }

    public IList<string> GetFileHeaders() => FileHeaders;
}

यह एक बुनियादी कार्यान्वयन को शामिल करता है:

public class FileHeaderList1 : FileHeaderBase
{
    private readonly IList<string> _fileHeaders = new List<string>
    {
        "Last Name" ,
        "First Name" ,
        "Middle Name" ,
        "Suffix" ,
        "Degree" ,
    };

    protected override IList<string> FileHeaders => _fileHeaders;        
}

यह आलसी लोडिंग को कवर करता है:

public class FileHeaderList2 : FileHeaderBase
{
    private IList<string> _fileHeaders;

    protected override IList<string> FileHeaders
    {
        get
        {
            if ( _fileHeaders == null )
            {
                _fileHeaders = new List<string>
                {
                    "Address" ,
                };
            }
            return _fileHeaders;
        }
    }
}

यह निर्भरता इंजेक्शन को शामिल करता है:

public class FileHeaderList3 : FileHeaderBase
{
    private readonly IList<string> _fileHeaders;

    public FileHeaderList3( IList<string> fileHeaders )
    {
        _fileHeaders = fileHeaders;
    }

    protected override IList<string> FileHeaders => _fileHeaders;
}
1
Sievajet 24 नवम्बर 2015, 22:25

fileHeaders बेस क्लास का संरक्षित सदस्य बनाएं। कुछ इस तरह:

public class Base
{
    protected List<string> fileHeaders;
    public List<string> FileHeaders
    {
        get
        {
            return fileHeaders;
        }
    }
}

public class A : Base
{
    public A()
    {
        fileHeaders = new List<string>
        {"Last Name", "First Name", "Middle Name", "Suffix", "Degree"};
    }
}

public class B : Base
{
    public B()
    {
        fileHeaders = new List<string>
        {"Last Name", "First Name", "Middle Name", "Suffix", "Degree", "Something Else"};
    }
}

आप यह भी समझ सकते हैं, अगर इसका अर्थ (शब्दार्थ) है, तो बस A आधार वर्ग हो और B का उत्तराधिकार हो, उदाहरण के लिए, यह सिर्फ B का मामला था स्तंभ । तो कुछ इस तरह:

public class A
{
    protected readonly List<string> fileHeaders = new List<string>
    {
        "Last Name", "First Name", "Middle Name", "Suffix", "Degree", 
    };

    public List<string> FileHeaders
    {
        get
        {
            return fileHeaders;
        }
    }
}

public class B : A
{
    public B()
    {
        fileHeaders.Add("Something Else");
    }
}
4
Matt Burland 24 नवम्बर 2015, 22:03

चूंकि दोनों उदाहरण केवल डेटा में भिन्न होते हैं, इसलिए सूची के साथ केवल एक वर्ग को सदस्य के रूप में क्यों न बनाएं और केवल संपत्ति (ऊपर के रूप में) पढ़ें और इसे निर्माणकर्ता में एक पैरामीटर के साथ प्रारंभ करें? विभिन्न वर्गों के लिए कोई ज़रूरत नहीं है।

2
Dieter Meemken 24 नवम्बर 2015, 22:09