स्थिर सदस्यों के साथ .NET इंटरफ़ेस कैसे बनाएं?

Question

.NET 3.5 में, मैं एक सिंगलटन इंटरफेस बनाने के लिए करना चाहते हैं:

interface ISingleton <T> 
{ 
    public static T Instance {get;} 
} 

पाठ्यक्रम कि काम नहीं करता है, लेकिन मैं चाहता हूँ क्या है के

। कोई सुझाव?

संपादित करें: मैं बस यह जानना चाहता हूं कि सभी सिंगलटनों में क्लास प्रकार के इंस्टेंस नामक एक स्थिर संपत्ति होगी। यह हमेशा वहाँ है। एक इंटरफ़ेस इसे व्यक्त करने का एक स्पष्ट तरीका होगा।

Answer 1

एक इंटरफ़ेस मेरे ज्ञान के लिए, सिंगलटन नहीं हो सकता क्योंकि यह वास्तव में अस्तित्व में नहीं है। एक इंटरफेस एक अनुबंध है कि एक कार्यान्वयन का पालन करना चाहिए। इस प्रकार, कार्यान्वयन एक सिंगलटन हो सकता है, लेकिन इंटरफ़ेस नहीं कर सकता है।

Answer 2

इसके अलावा, यह काम नहीं करता है, जैसा कि आप कहते हैं, आप इस इंटरफ़ेस और कार्यान्वयन वर्ग का उपयोग कैसे करेंगे?

तुम एक फैक्टरी शैली इंटरफेस

interface ISingletonFactory<T> 
{ 
    public T Instance {get;} 
} 

public class SingletonFactory: ISingletonFactory<Singleton> 
{ 
    public Singleton Instance {get { return Singleton.Instance;}} 
} 

public class Singleton 
{ 
    private Singleton foo; 
    public static Singleton Instance { get { return foo; } } 
} 

Answer 3

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

Answer 4

मैं सिर्फ यह जानना चाहता हूं कि सभी सिंगलटन के पास क्लास प्रकार के इंस्टेंस नामक एक स्थिर संपत्ति होगी। यह हमेशा वहाँ है। एक इंटरफ़ेस इसे व्यक्त करने का एक स्पष्ट तरीका होगा।

इसके बजाय एक इकाई परीक्षण लिखें।

Answer 5

जैसा कि बताया गया है, आप यह नहीं कर सकते हैं और अच्छे कारण हैं कि आपको क्यों नहीं करना चाहिए।

जिस विधि में मैंने अतीत में लागू किया है वह एक इंटरफ़ेस और एक सार आधार वर्ग बनाता है जो इंटरफ़ेस लागू करता है। ऐसा कुछ दिखता है:

public interface IMyCompanySetting 
{ 
    XmlNode Serialize(); 
    IMyCompanySetting Deserialize(XmlNode pattern); 
    string SettingName { get; } 

स्ट्रिंग कुंजी {प्राप्त करें; } ऑब्जेक्ट सेटिंग वैल्यू {प्राप्त करें; सेट; } सेटिंगस्कोप स्कोप {प्राप्त करें; सेट; } }

public abstract class MyCompanySettingBase : IMyCompanySetting 
{ 
    public MyCompanySettingBase() {} 
    public MyCompanySettingBase(XmlNode pattern) 
    { 
     Deserialize(pattern); 
    } 
    #region IMyCompanySetting Members 

    public abstract XmlNode Serialize(); 
    public abstract IMyCompanySetting Deserialize(XmlNode pattern); 
    public abstract string SettingName{ get; } 
public abstract string Key { get; } 
    public abstract SettingScope Scope{ get; set; } 
    public abstract object SettingValue{ get; set; } 

    #endregion 

public static XmlNode WrapInSettingEnvelope(XmlNode innerNode, IMyCompanySetting theSetting) 
{ 
    // Write the top of the envelope. 
    XmlTextWriter xtw = null; 
    MemoryStream theStream = OpenSettingEnvelope(theSetting, ref xtw); 

    // Insert the message. 
    xtw.WriteNode(new XmlTextReader(innerNode.OuterXml, XmlNodeType.Element, null), true); 

    // Close the envelope. 
    XmlNode retNode = CloseSettingEnvelope(xtw, theStream); 
    return retNode; 

} 

public static MemoryStream OpenSettingEnvelope(IMyCompanySetting theSetting, ref XmlTextWriter theWriter) 
{ 
    MemoryStream theStream = new MemoryStream(); 
    theWriter = new XmlTextWriter(theStream, Encoding.ASCII); 
    System.Type messageType = theSetting.GetType(); 

    string[] fullAssembly = messageType.Assembly.ToString().Split(','); 
    string assemblyName = fullAssembly[0].Trim(); 

    theWriter.WriteStartElement(theSetting.SettingName); 
    theWriter.WriteAttributeString("type", messageType.ToString()); 
    theWriter.WriteAttributeString("assembly", assemblyName); 
    theWriter.WriteAttributeString("scope", ConfigurationManager.ScopeName(theSetting.Scope)); 

    return theStream; 
} 

public static XmlNode CloseSettingEnvelope(XmlTextWriter xtw, MemoryStream theStream) 
{ 
    XmlDocument retDoc = new XmlDocument(); 
    try 
    { 
     // Close the envelope. 
     xtw.WriteEndElement(); 
     xtw.Flush(); 

     // Return the node. 
     string xmlString = Encoding.ASCII.GetString(theStream.ToArray()); 
     retDoc.LoadXml(xmlString); 
    } 
    catch (XmlException) 
    { 
     string xmlString = Encoding.ASCII.GetString(theStream.ToArray()); 
     Trace.WriteLine(xmlString); 
     retDoc.LoadXml(@"<error/>"); 
    } 
    catch (Exception) 
    { 
     retDoc.LoadXml(@"<error/>"); 
    } 
    return retDoc.DocumentElement; 
} 

} 

Answer 6

ठीक है, मैं, इस सवाल का जवाब एक विकी हो पाता है क्योंकि मैं सिर्फ एक राय अपने प्रश्न का एक स्पर्शरेखा पर है कि पेशकश करने के लिए जा रहा हूँ।

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

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

Answer 7

मुझे पता है कि यह आपका प्रश्न नहीं है, लेकिन आपके पास कितने सिंगलेट हैं जो आपको इंटरफ़ेस की आवश्यकता है? यह मुझे खराब डिजाइन की तरह गंध करता है - क्या आप स्पष्ट रूप से समझा सकते हैं कि इन वर्गों को उदाहरणों के बजाय सिंगलेट क्यों होना चाहिए?यदि आपका उत्तर स्मृति है, तो मैं आपको अपने आवेदन को ओवरथिंक करने का सुझाव दूंगा, और यदि आप वास्तव में चिंतित हैं, तो फ्लाईवेट पैटर्न (या शायद एक साधारण फैक्ट्री पैटर्न) देखें। सीधे सवाल का जवाब न देने के लिए खेद है, लेकिन यह एक अच्छा विचार की तरह नहीं लगता है।

Answer 8

जब मैं अन्य पोस्टर कि एकमात्र बहुत ज्यादा इस्तेमाल किया अधिक कर रहे हैं से सहमत हैं, आपके सवाल का एक संभव समाधान व्युत्पन्न सिंगलटन का एक प्रकार पैरामीटर के साथ एक सार आधार वर्ग प्रदान करना है:

public abstract class Singleton<T> where T : Singleton<T> 
{ 
    private static T _instance; 

    public static T Instance 
    { 
    get { return _instance; } 
    protected set { _instance = value; } 
    } 
} 

किसी भी वर्ग है कि सिंगलटन से निकला सही प्रकार की एक स्थिर उदाहरण संपत्ति होगा: कुछ इस तरह उपयोग करने से पहले

public class MySingleton : Singleton<MySingleton> 
{ 
    static MySingleton() 
    { 
     Instance = new MySingleton(); 
    } 

    private MySingleton() { } 
} 

ही आप वास्तव में एक सिंगलटन की आवश्यकता है के बारे में या यदि आप एक सामान्य स्थिर वर्ग के साथ बेहतर होगा सोचना चाहिए।