अनुबंधों के लिए अलग-अलग संपत्ति मूल्य

Question

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

उदाहरण:

1. Class1 इम्प्लीमेन्ट्स Interface1, Interface2
2. Interface1.GetData() डाटाबेस 1
3. Interface2.GetData (करने के लिए DatabaseName सेट है) डाटाबेस 2

को DatabaseName सेट है

मैं उन मानों को GetData() विधियों में कॉन्फ़िगर कर सकता हूं लेकिन मुझे इसे करने का क्लीनर तरीका चाहिए।

कोई भी पैटर्न अनुशंसा यह है कि डीआई, डोमेन संचालित, यहां तक ​​कि बुनियादी विरासत उदाहरण जो उपरोक्त को पूरा करता है वह है जिसे मैं ढूंढ रहा हूं।

Answer 1

ऐसा लगता है आप सभी की जरूरत की तरह explicit interface implementation है:

public class Class1 : Interface1, Interface2 
{ 
    // Note the lack of access modifier here. That's important! 
    Data Interface1.GetData() 
    { 
     // Implementation for Interface1 
    } 

    Data Interface2.GetData() 
    { 
     // Implementation for Interface2 
    } 
} 

जाहिर है दो तरीकों डेटाबेस नाम या इसी तरह के निर्दिष्ट करने के लिए एक पैरामीटर के साथ एक आम तरीका कॉल कर सकते हैं।

Answer 2

पुनर्रचना आम तौर पर एक कोड गंध और बहुत तथ्य यह है कि आप एक स्थिति है जहाँ आप 2 अमूर्त जो बेनकाब इसी तरह की सुविधा कोड है गंध लागू करना में समाप्त हो गया देख से प्रेरित है। समस्या की अधिक समझ के बिना मैं आपको एक निर्णायक उत्तर प्रदान करने में सक्षम नहीं हूं लेकिन सीमित समझ के साथ मैं प्रस्ताव दूंगा। प्रत्येक इंटरफेस को कार्यान्वित करने के लिए 2 अलग-अलग ठोस कार्यान्वयन करें और एक कारखाना है जिसे क्लाइंट को इंजेक्शन दिया जाएगा और क्लाइंट को जानबूझकर निर्णय लेने में मदद मिलेगी, जिसमें इन कार्यान्वयन की आवश्यकता है। यदि इन ठोस वर्गों में सामान्य कार्यक्षमता साझा होती है तो आप हमेशा एक सामान्य अभिभावक वर्ग में अमूर्त हो सकते हैं।

public interface ISQLReader 
    { 
     string GetData(); 
    } 

    public interface IOracleReader 
    { 
     string GetData(); 
    } 

    public abstract class Reader 
    { 
     protected void CommonFunctionaility() 
     { 

     } 
    } 
    public class MSSQLReader : Reader, ISQLReader 
    { 
     public string GetData() 
     { 
      return "MSSQL"; 
     } 
    } 

    public class OracleReader : Reader, IOracleReader 
    { 
     public string GetData() 
     { 
      return "Oracle"; 
     } 
    } 

    public interface IReaderFactory 
    { 
     OracleReader CreateOracleReader(); 
     MSSQLReader CreateMSSQLReader(); 
    } 

    public class ReaderFactory : IReaderFactory 
    { 
     public MSSQLReader CreateMSSQLReader() => new MSSQLReader(); 

     public OracleReader CreateOracleReader() => new OracleReader(); 
    } 

    public class ReaderClient 
    { 
     private IReaderFactory _factory; 
     public ReaderClient(IReaderFactory factory) 
     { 
      this._factory = factory; 
     } 
    } 

स्पष्ट इंटरफेस कार्यान्वयन तकनीक है कि कार्यक्षमता के उपयोग को प्रतिबंधित कर देना चाहिए जब तक ग्राहक बना दिया है और एक विचार निर्णय लेने से वहाँ स्पष्ट डाली है।