दिलचस्प पोस्ट
एक्सएचटीएमएल में सभी वैध स्वयं समापन तत्व क्या हैं (जैसा कि प्रमुख ब्राउज़रों द्वारा लागू किया गया है)? एंड्रॉइड: कस्टम सरलकर्सर एडेप्टर में नया दृश्य और बाइंड दृश्य देखें नोड मॉड्यूल को स्थापित नहीं किया जा सकता जिसे Windows 7 x64 / VS2012 पर संकलन की आवश्यकता है BluetoothAdapter में किए गए राज्य परिवर्तनों का पता लगा रहा है? क्लास से XSD स्कीमा कैसे तैयार करें? क्या मैं UITextView पर ऑटो की गई लिंक का रंग बदल सकता हूँ? मैं मैक और PHP में जुड़े क्लाइंट के आईपी पते कैसे प्राप्त करूं? प्रोटोकॉल का उपयोग केवल सामान्य बाधा के रूप में किया जा सकता है क्योंकि इसमें स्वयं या संबद्ध प्रकार की आवश्यकताएं हैं उल्का: सर्वर पर Meteor.wrapAsync का उचित उपयोग जावास्क्रिप्ट समापन से लूप के बाहर चर में प्रवेश करें //! क्यूटी सोर्स कोड में संपूर्ण परियोजना खोजें और बदलें (नेटबीन्स) स्टोरीबोर्ड का उपयोग करते हुए प्रोग्राममिक रूप से प्रारंभिक दृश्य नियंत्रक सेट करें मैं कैसे देख सकता हूँ कि जीआईटी के साथ क्या करने जा रहा हूँ? हेक्स बाइट के रूप में एक स्ट्रिंग प्रिंट करें?

सिंगलटन: इसे कैसे इस्तेमाल किया जाना चाहिए

संपादित करें: दूसरे प्रश्न से मैंने एक जवाब दिया जिसमें कई प्रश्नों / उत्तरों के बारे में लिपटे गए हैं: सिंगलटन के बारे में अधिक जानकारी:

तो मैंने धागा सिंगलेटन्स पढ़ लिया है : अच्छा डिजाइन या एक बैसाखी?
और तर्क अभी भी संताप है।

मैं सिंगेटन को एक डिजाइन पैटर्न के रूप में देखता हूं (अच्छा और बुरे)

सिंगलटन के साथ समस्या पैटर्न नहीं बल्कि उपयोगकर्ताओं (खेद सभी) है। हर कोई और उनके पिता सोचते हैं कि वे एक सही तरीके से लागू कर सकते हैं (और मैंने कई साक्षात्कारों से किया है, ज्यादातर लोग नहीं कर सकते हैं)। इसके अलावा, क्योंकि सभी लोग सोचते हैं कि वे सही सिंगलटन को लागू कर सकते हैं, वे पैटर्न का दुरुपयोग करते हैं और उन स्थितियों में इसका इस्तेमाल करते हैं जो उपयुक्त नहीं हैं (सिंगलटन के साथ वैश्विक वैरिएबल की जगह!)।

इसलिए मुख्य प्रश्नों का उत्तर देने की आवश्यकता है:

  • आपको सिंगलटन का उपयोग कब करना चाहिए
  • आप एक सिंगलटन को सही तरीके से कैसे कार्यान्वित करते हैं

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


तो गेंद रोलिंग करें:
मैं अपना हाथ पकड़ कर रखूंगा और कहूँगा कि मैं यही उपयोग करता हूं, लेकिन शायद समस्याएं हैं
मुझे पसंद है "स्कॉट मायर्स" इस विषय की अपनी पुस्तकों में "प्रभावी सी ++"

Singletons का उपयोग करने के लिए अच्छी स्थिति (बहुत से नहीं):

  • लॉगिंग फ़्रेमवर्क
  • धागा रीसाइक्लिंग पूल
/* * C++ Singleton * Limitation: Single Threaded Design * See: http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf * For problems associated with locking in multi threaded applications * * Limitation: * If you use this Singleton (A) within a destructor of another Singleton (B) * This Singleton (A) must be fully constructed before the constructor of (B) * is called. */ class MySingleton { private: // Private Constructor MySingleton(); // Stop the compiler generating methods of copy the object MySingleton(MySingleton const& copy); // Not Implemented MySingleton& operator=(MySingleton const& copy); // Not Implemented public: static MySingleton& getInstance() { // The only instance // Guaranteed to be lazy initialized // Guaranteed that it will be destroyed correctly static MySingleton instance; return instance; } }; 

ठीक। हमें कुछ आलोचनाएं और अन्य कार्यान्वयन एक साथ मिलें।
🙂

Solutions Collecting From Web of "सिंगलटन: इसे कैसे इस्तेमाल किया जाना चाहिए"

आप सभी गलत हैं प्रश्न पढ़ें उत्तर:

सिंगलटन का उपयोग करें यदि:

  • यदि आपको सिस्टम में एक प्रकार के एक और केवल एक ऑब्जेक्ट की आवश्यकता है

सिंगलटन का उपयोग न करें यदि:

  • यदि आप मेमोरी को सहेजना चाहते हैं
  • अगर आप कुछ नया करने की कोशिश करना चाहते हैं
  • यदि आप यह दिखाना चाहते हैं कि आप कितना जानते हैं
  • क्योंकि हर कोई यह कर रहा है (विकिपीडिया में कार्गो पंथ प्रोग्रामर देखें)
  • उपयोगकर्ता इंटरफ़ेस विजेट्स में
  • यह एक कैश माना जाता है
  • स्ट्रिंग्स में
  • सत्रों में
  • मैं पूरे दिन लंबे समय तक जा सकता हूं

सर्वश्रेष्ठ सिंगलटन कैसे बनाएं:

  • छोटे, बेहतर मैं एक minimalist हूँ
  • सुनिश्चित करें कि यह धागा सुरक्षित है
  • सुनिश्चित करें कि यह कभी भी रिक्त नहीं है
  • सुनिश्चित करें कि यह केवल एक बार बनाया गया है
  • आलसी या सिस्टम प्रारंभ करना? अपनी आवश्यकताओं तक
  • कभी-कभी ओएस या जेवीएम आपके लिए सिंगलटन बनाता है (उदाहरण के लिए जावा में हर कक्षा की परिभाषा एक सिंगलटन है)
  • एक नाशक प्रदान करें या किसी तरह कैसे संसाधनों निपटाने के लिए बाहर निकालने के लिए
  • थोड़ा मेमोरी का उपयोग करें

सिंग्लटन्स आपको एक क्लास में दो बुरे लक्षणों को संयोजित करने की क्षमता प्रदान करते हैं। यह काफी हर तरह से गलत है

एक सिंगलटन आपको देता है:

  1. वस्तु के लिए वैश्विक पहुंच, और
  2. एक गारंटी है कि इस प्रकार के एक से अधिक ऑब्जेक्ट कभी भी नहीं बनाए जा सकते हैं

नंबर एक सीधा है ग्लोबल्स आमतौर पर खराब होते हैं जब तक हमें वास्तव में इसकी ज़रूरत नहीं होती, हमें वस्तुओं को विश्व स्तर पर सुलभ नहीं करना चाहिए।

संख्या दो की तरह लग सकता है यह समझ में आता है, लेकिन इसके बारे में सोचते हैं। पिछली बार जब आप ** गलती से * एक मौजूदा वस्तु को संदर्भित करने के बजाय एक नया ऑब्जेक्ट बनाया था? चूंकि इसे C ++ टैग किया गया है, चलो उस भाषा के उदाहरण का उपयोग करते हैं। क्या आप अकसर गलती से लिखते हैं

 std::ostream os; os << "hello world\n"; 

जब आप लिखना चाहते थे

 std::cout << "hello world\n"; 

बिलकूल नही। हमें इस त्रुटि के विरुद्ध सुरक्षा की आवश्यकता नहीं है, क्योंकि इस तरह की त्रुटि अभी नहीं होती है। अगर ऐसा होता है, तो सही प्रतिक्रिया घर जाना और 12-20 घंटों के लिए सो रही है और आशा है कि आप बेहतर महसूस करेंगे।

यदि केवल एक वस्तु की आवश्यकता है, तो बस एक उदाहरण बनाएँ अगर एक ऑब्जेक्ट विश्व स्तर पर पहुंच योग्य होना चाहिए, तो इसे वैश्विक बनाएं लेकिन इसका अर्थ यह नहीं है कि इसके अन्य उदाहरणों को बनाने में असंभव होना चाहिए।

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

इसलिए एक सिंगलटन का उपयोग किया जाना चाहिए और यदि केवल, हमें दोनों गुणों की ज़रूरत होती है: यदि हमें वैश्विक पहुंच की आवश्यकता होती है (जो कि दुर्लभ है, क्योंकि ग्लोबल्स को आम तौर पर निराश किया जाता है) और हमें किसी को कभी भी एक से अधिक उदाहरण बनाने से रोकने की आवश्यकता है वर्ग (जो मुझे एक डिजाइन मुद्दे की तरह लगता है) एकमात्र कारण यह है कि मैं यह देख सकता हूं कि दो उदाहरण बनाने से हमारे आवेदन की स्थिति भ्रष्ट हो जाएगी – संभवतः क्योंकि क्लास में कई स्थैतिक सदस्य हैं या इसी तरह की मूर्खता उस स्थिति में उस वर्ग को ठीक करने का स्पष्ट उत्तर है यह एकमात्र उदाहरण होने पर निर्भर नहीं होना चाहिए

यदि आपको किसी ऑब्जेक्ट पर ग्लोबल ऐक्सेस की आवश्यकता है, तो इसे एक वैश्विक std::cout , जैसे std::cout लेकिन उन उदाहरणों की संख्या को सीमित नहीं करें जिन्हें बनाया जा सकता है।

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

यदि आपको दोनों गुणों की आवश्यकता है, तो 1) इसे सिंगलटन बनायें, और 2) मुझे बताएं कि आपको इसकी क्या आवश्यकता है, क्योंकि मुझे इस तरह के मामले की कल्पना करने में कठिन समय आ रहा है।

सिंगलटन के साथ समस्या उनका कार्यान्वयन नहीं है यह है कि वे दो अलग-अलग अवधारणाओं का सामना करते हैं, जिनमें से कोई भी स्पष्ट रूप से वांछनीय है।

1) सिंगलाटन एक ऑब्जेक्ट के लिए एक वैश्विक एक्सेस मैकेनाइजेशन प्रदान करते हैं। यद्यपि वे अल्पसंख्यक रूप से अधिक थ्रेसेफ या अल्पसंख्यक रूप से अधिक भरोसेमंद भाषाओं में अच्छी तरह से परिभाषित प्रारंभिक आदेश के बिना हो सकते हैं, लेकिन यह उपयोग अभी भी एक वैश्विक चर के नैतिक बराबर है। यह एक वैश्विक वैरिएबल है जो कुछ अजीब वाक्यविन्यास (foo :: get_instance () के बजाय g_foo के अनुसार तैयार किया गया है), लेकिन यह सटीक एक ही उद्देश्य (पूरे कार्यक्रम में एक एकल ऑब्जेक्ट तक पहुंच योग्य) करता है और इसमें सटीक समान कमियां हैं।

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

पैटर्न के साथ एक बात: सामान्य नहीं है वे सभी मामलों में जब वे उपयोगी होते हैं, और जब वे विफल होते हैं

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

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

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

सिंग्लॉटन मूल रूप से आपको जटिल वैश्विक राज्य की भाषाओं में रहने देते हैं जो अन्यथा जटिल वैश्विक चर वाले होते हैं।

जावा विशेष रूप से ग्लोबल वेरिएबल्स के प्रतिस्थापन के रूप में सिंगलटन का उपयोग करता है, क्योंकि सब कुछ एक कक्षा के अंदर ही होना चाहिए। वैश्विक वैरिएबल के निकटतम यह सार्वजनिक स्थैतिक चर है, जिसका इस्तेमाल इन्हें import static रूप से वैश्विक रूप में किया जा सकता है

सी ++ में ग्लोबल वैरिएबल हैं, लेकिन जिस क्रम में वैश्विक क्लास वैरिएबल के कंस्ट्रक्शर्स का उपयोग किया जाता है वह अनिर्धारित है। जैसे, एक सिंगलटन आपको वैश्विक वैरिएबल के निर्माण को स्थगित करने की सुविधा देता है, जब तक कि वेरिएबल की आवश्यकता नहीं होती है।

पायथन और रूबी जैसी भाषाएं बहुत कम उपयोग करती हैं क्योंकि आप वैश्विक वैरिएबल का उपयोग किसी मॉड्यूल के भीतर कर सकते हैं।

तो जब एक सिंगलटन का उपयोग करना अच्छा / बुरा है? एक वैश्विक चर का उपयोग करने के लिए जब यह अच्छा होगा / बहुत अच्छा होगा

एलेक्जेंडरको द्वारा आधुनिक सी + + डिजाइन में एक धागा सुरक्षित, विरासत जेनेरिक सिंगलटन है।

मेरे 2p- मूल्य के लिए, मुझे लगता है कि यह महत्वपूर्ण है कि आपने अपने एकल गीतों के लिए जीवनकाल निर्धारित किया हो (जब उनका उपयोग करना बिल्कुल आवश्यक है)। मैं सामान्य रूप से स्थैतिक get() फ़ंक्शन को कुछ भी प्रारंभ नहीं करने देता, और मुख्य अनुप्रयोग के कुछ समर्पित अनुभाग को सेट-अप और विनाश छोड़ देता है। यह सिंगलटन के बीच निर्भरता को उजागर करने में मदद करता है – लेकिन, जैसा कि ऊपर जोर दिया गया है, संभव है कि अगर संभव हो तो उनसे बचें।

  • आप एक सिंगलटन को सही तरीके से कैसे कार्यान्वित करते हैं

एक ऐसा मुद्दा है जिसे मैंने पहले कभी नहीं देखा है, जो मैंने पिछली नौकरी में भाग लिया था। हमारे पास C ++ सिंगलटन थे जो DLL के बीच साझा किए गए थे, और एक क्लास का एक उदाहरण सुनिश्चित करने के सामान्य यांत्रिकी बस काम नहीं करते। समस्या ये है कि प्रत्येक DLL को EXE के साथ-साथ स्थिर चर का अपना सेट मिलता है यदि आपका get_instance फ़ंक्शन इनलाइन या स्थिर लाइब्रेरी का हिस्सा है, तो प्रत्येक DLL "एकलटन" की अपनी प्रतिलिपि के साथ चल जाएगा

समाधान यह सुनिश्चित करने के लिए है कि सिंगलटन कोड केवल एक DLL या EXE में परिभाषित किया गया है, या उदाहरणों को पार्सलेट करने के लिए उन गुणों के साथ सिंगलटन मैनेजमेंट बनाएं।

पहला उदाहरण धागा सुरक्षित नहीं है – अगर दो धागे को एक ही समय में मिलते हैं, तो वह स्थैतिक एक पीआईटीए होने वाला है। म्यूटक्स के कुछ फार्म में मदद मिलेगी

जैसा कि अन्य लोगों ने उल्लेख किया है, Singletons के प्रमुख downsides में उन्हें विस्तार करने में असमर्थता शामिल है, और एक से अधिक उदाहरणों को तत्काल करने की शक्ति खोने, उदा। परीक्षण उद्देश्यों के लिए

सिंगलटन के कुछ उपयोगी पहलू:

  1. आलसी या अपफ्रन्टएशन
  2. किसी वस्तु के लिए आसान जो सेटअप और / या राज्य की आवश्यकता है

हालांकि, इन लाभों को प्राप्त करने के लिए आपको सिंगलटन का उपयोग करने की आवश्यकता नहीं है आप एक सामान्य ऑब्जेक्ट लिख सकते हैं जो काम करता है, और उसके बाद लोगों को एक फैक्ट्री (एक अलग ऑब्जेक्ट) के माध्यम से इसका उपयोग कर सकते हैं। कारखाने केवल एक को तत्काल तब्दील करने और इसे पुनः उपयोग करने की चिंता कर सकता है, आदि। यदि आवश्यकता हो, तो। इसके अलावा, यदि आप एक ठोस वर्ग के बजाय एक इंटरफ़ेस के लिए प्रोग्राम करते हैं, तो कारखाने रणनीति का उपयोग कर सकता है, यानी आप अंतरफलक के विभिन्न कार्यान्वयन में और बाहर स्विच कर सकते हैं।

अंत में, एक कारखाना वसंत आदि जैसी निर्भरता इंजेक्शन प्रौद्योगिकियों के लिए खुद को उधार देता है।

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

यदि आप हर बार ऐसा करते हैं, तो प्रदर्शन बहुत अपमानित होगा इसे एक सिंगलटन में उपयोग करते हुए, आप उस हिट को एक बार लेते हैं और उसके बाद सभी कॉलों को ऐसा करना नहीं पड़ता है।

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

इसलिए भी लॉगर्स या थ्रेड पूल के उदाहरण अमान्य हैं और रणनीतियों द्वारा प्रतिस्थापित किया जाना चाहिए।

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

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

लेकिन जब मुझे एक सिंगलटन की तरह कुछ चाहिए, तो मैं अक्सर श्वेरज़ काउंटर का उपयोग करने के लिए इसे समाप्त करना चाहता हूं।

मैं एक साक्षात्कार परीक्षण के रूप में सिंगलाटन का उपयोग करता हूं।

जब मैं डेवलपर को कुछ डिज़ाइन पैटर्न का नाम देने के लिए कहता हूं, यदि वे सिंगलटन नाम कर सकते हैं, तो वे किराए पर नहीं ले रहे हैं।

विरोधी उपयोग:

अत्यधिक सिंगलटन उपयोग के साथ एक बड़ी समस्या यह है कि पैटर्न वैकल्पिक रूप से आसान विस्तार और स्वैपिंग को रोकता है। सिंगलटन का उपयोग किया जाता है, जहां वर्ग-नाम कठिन कोडित होता है।

मुझे लगता है कि यह सी # के लिए सबसे मजबूत संस्करण है:

 using System; using System.Collections; using System.Threading; namespace DoFactory.GangOfFour.Singleton.RealWorld { // MainApp test application class MainApp { static void Main() { LoadBalancer b1 = LoadBalancer.GetLoadBalancer(); LoadBalancer b2 = LoadBalancer.GetLoadBalancer(); LoadBalancer b3 = LoadBalancer.GetLoadBalancer(); LoadBalancer b4 = LoadBalancer.GetLoadBalancer(); // Same instance? if (b1 == b2 && b2 == b3 && b3 == b4) { Console.WriteLine("Same instance\n"); } // All are the same instance -- use b1 arbitrarily // Load balance 15 server requests for (int i = 0; i < 15; i++) { Console.WriteLine(b1.Server); } // Wait for user Console.Read(); } } // "Singleton" class LoadBalancer { private static LoadBalancer instance; private ArrayList servers = new ArrayList(); private Random random = new Random(); // Lock synchronization object private static object syncLock = new object(); // Constructor (protected) protected LoadBalancer() { // List of available servers servers.Add("ServerI"); servers.Add("ServerII"); servers.Add("ServerIII"); servers.Add("ServerIV"); servers.Add("ServerV"); } public static LoadBalancer GetLoadBalancer() { // Support multithreaded applications through // 'Double checked locking' pattern which (once // the instance exists) avoids locking each // time the method is invoked if (instance == null) { lock (syncLock) { if (instance == null) { instance = new LoadBalancer(); } } } return instance; } // Simple, but effective random load balancer public string Server { get { int r = random.Next(servers.Count); return servers[r].ToString(); } } } } 

यहां एनएटी-अनुकूलित संस्करण है :

 using System; using System.Collections; namespace DoFactory.GangOfFour.Singleton.NETOptimized { // MainApp test application class MainApp { static void Main() { LoadBalancer b1 = LoadBalancer.GetLoadBalancer(); LoadBalancer b2 = LoadBalancer.GetLoadBalancer(); LoadBalancer b3 = LoadBalancer.GetLoadBalancer(); LoadBalancer b4 = LoadBalancer.GetLoadBalancer(); // Confirm these are the same instance if (b1 == b2 && b2 == b3 && b3 == b4) { Console.WriteLine("Same instance\n"); } // All are the same instance -- use b1 arbitrarily // Load balance 15 requests for a server for (int i = 0; i < 15; i++) { Console.WriteLine(b1.Server); } // Wait for user Console.Read(); } } // Singleton sealed class LoadBalancer { // Static members are lazily initialized. // .NET guarantees thread safety for static initialization private static readonly LoadBalancer instance = new LoadBalancer(); private ArrayList servers = new ArrayList(); private Random random = new Random(); // Note: constructor is private. private LoadBalancer() { // List of available servers servers.Add("ServerI"); servers.Add("ServerII"); servers.Add("ServerIII"); servers.Add("ServerIV"); servers.Add("ServerV"); } public static LoadBalancer GetLoadBalancer() { return instance; } // Simple, but effective load balancer public string Server { get { int r = random.Next(servers.Count); return servers[r].ToString(); } } } } 

आप dotfactory.com पर यह पैटर्न पा सकते हैं

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

एक सिंगलटन वैश्विक रूप से सुलभ ऑब्जेक्ट (अब से गाओ) के लिए एक कार्यान्वयन है, हालांकि सभी गाओ एकल गीत नहीं हैं।

लॉगगरों को स्वयं अकेले नहीं होना चाहिए लेकिन लॉग इन करने का मतलब आदर्श रूप से विश्व स्तर पर पहुंच-योग्य होना चाहिए, जहां से लॉग संदेश जहां से लॉग किया गया हो वहां से यह कैसे उत्पन्न किया जा सकता है।

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

इसके साथ दिमाग में, जीओए इस तरह शुरू हो सकते हैं:

 namespace { T1 * pt1 = NULL; T2 * pt2 = NULL; T3 * pt3 = NULL; T4 * pt4 = NULL; } int main( int argc, char* argv[]) { T1 t1(args1); T2 t2(args2); T3 t3(args3); T4 t4(args4); pt1 = &t1; pt2 = &t2; pt3 = &t3; pt4 = &t4; dostuff(); } T1& getT1() { return *pt1; } T2& getT2() { return *pt2; } T3& getT3() { return *pt3; } T4& getT4() { return *pt4; } 

इसे कुरूपता के रूप में किया जाना चाहिए, और स्पष्ट रूप से लोड किए गए लाइब्रेरी में स्पष्ट रूप से ऐसे ऑब्जेक्ट शामिल होते हैं, जिन्हें आप शायद अपने जीवनकाल का प्रबंधन करने के लिए कुछ अन्य तंत्र चाहते हैं। (जब आप लाइब्रेरी लोड करते हैं तो उन्हें प्राप्त होने वाले ऑब्जेक्ट में रखें)।

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

मैं अभी भी नहीं मिलता है क्यों एक सिंगलटन वैश्विक होना चाहिए।

मैं एक सिंगलटन का उत्पादन करने जा रहा था, जहां मैं क्लाइंट के अंदर एक निजी स्थिर स्थैतिक चर के रूप में डेटाबेस को छुपाता था और क्लास फ़ंक्शंस करता हूं जो उपयोगकर्ता को डाटाबेस को उजागर किए बिना डेटाबेस का उपयोग करता है।

मुझे नहीं पता कि यह कार्यक्षमता खराब क्यों होगी।

I find them useful when I have a class that encapsulates a lot of memory. For example in a recent game I've been working on I have an influence map class that contains a collection of very large arrays of contiguous memory. I want that all allocated at startup, all freed at shutdown and I definitely want only one copy of it. I also have to access it from many places. I find the singleton pattern to be very useful in this case.

I'm sure there are other solutions but I find this one very useful and easy to implement.

In desktop apps (I know, only us dinosaurs write these anymore!) they are essential for getting relatively unchanging global application settings – the user language, path to help files, user preferences etc which would otherwise have to propogate into every class and every dialog.

Edit – of course these should be read-only !

Another implementation

 class Singleton { public: static Singleton& Instance() { // lazy initialize if (instance_ == NULL) instance_ = new Singleton(); return *instance_; } private: Singleton() {}; static Singleton *instance_; };