क्या GOF सिंगलटन पैटर्न के लिए कोई व्यवहार्य विकल्प हैं?

91

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

GOF सिंगलटन पैटर्न के लिए उनके कोई विशिष्ट विकल्प हैं?

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

आपके पास और क्या विचार है?

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

design-patterns singleton

— CodingWithoutComments
स्रोत

क्या? यह न तो अच्छा है और न ही बुरा है, लेकिन मैं इसे कैसे बदल सकता हूं? सभी लोगों के लिए, जो कहते हैं कि यह अच्छा है - भाग न लें। आप सभी लोग जो कहते हैं कि यह बुरा है, मुझे यह दिखा कर साबित करें कि मैं इसके बिना कैसे रह सकता हूं। मेरे लिए तर्क लगता है।

— S.Lott

@CodingWithoutComents: पूरी पोस्ट पढ़ी। यही कारण है कि मुझे समझ में नहीं आया कि "अगर आप सिंगलेट्स ठीक हैं तो जवाब न दें"।

— S.Lott

2

खैर, अगर ऐसा है तो मैं माफी माँगता हूँ। मुझे लगा कि मैंने ध्रुवीकरण से बचने के लिए महत्वपूर्ण कदम उठाए हैं। मुझे लगा कि मैंने एक तरह से सवाल पूछा है कि सिंगलेट्स के प्रेमी और नफरत करने वाले दोनों दूर जा सकते हैं, एक प्रोग्रामर के रूप में हम सभी के पास विकल्प हैं - कि उनका कभी भी केवल एक ही सही तरीका नहीं है

— CodingWithoutComments

यदि मैं सिंग्लेटन्स का उपयोग करता हूं, तो उनके आसपास काम करने के तरीके में मेरा कोई संभावित योगदान नहीं है। मुझे ध्रुवीकरण लगता है।

— S.Lott

9

मैं हर रोज सिंगलटन का उपयोग करता हूं लेकिन क्या यह मुझे सोचने से रोकता है कि संभवतः चीजों को करने का एक बेहतर तरीका हो सकता है? डिज़ाइन पैटर्न केवल 14 वर्षों के लिए ही रहा है। क्या मैं उन्हें बाइबल की सच्चाई के रूप में लेता हूँ? क्या हम बॉक्स के बाहर सोचने की कोशिश करना बंद कर देते हैं? क्या हम सीएस के अनुशासन को आगे बढ़ाने की कोशिश नहीं करते?

— CodingWithoutComments

76

एलेक्स मिलर " पैटर्न आई हेट " निम्नलिखित उद्धरण देते हैं:

"जब एक सिंगलटन जवाब की तरह लगता है, मुझे लगता है कि यह अक्सर समझदार होता है:

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

— जसेक Szymański
स्रोत

2

मुझे पता है कि यह 5 साल का है, लेकिन क्या आप इस पर विस्तार कर सकते हैं? मुझे लगता है कि मुझे सिखाया गया था कि एक सिंगलटन बनाने का सही तरीका एक इंटरफ़ेस था। मुझे दिलचस्पी होगी अगर मैं जो कर रहा था वह 'ठीक' था, और जैसा कि मुझे बताया गया है उतना भयानक नहीं था।

— प्यूरफेरेट

97

Singletons को हल करने के उचित तरीके को समझने के लिए, आपको यह समझने की आवश्यकता है कि Singletons (और सामान्य रूप से वैश्विक स्थिति) में क्या गलत है:

सिंगलटन निर्भरता को छिपाते हैं।

वह महत्वपूर्ण क्यों है?

क्योंकि यदि आप निर्भरता को छिपाते हैं तो आप युग्मन की मात्रा का ट्रैक खो देते हैं।

आप यह तर्क दे सकते हैं

void purchaseLaptop(String creditCardNumber, int price){
  CreditCardProcessor.getInstance().debit(creditCardNumber, amount);
  Cart.getInstance().addLaptop();
}

से सरल है

void purchaseLaptop(CreditCardProcessor creditCardProcessor, Cart cart, 
                    String creditCardNumber, int price){
  creditCardProcessor.debit(creditCardNumber, amount);
  cart.addLaptop();
}

लेकिन कम से कम दूसरा एपीआई यह स्पष्ट करता है कि विधि के सहयोगी क्या हैं।

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

— रासमस फेबर
स्रोत

+1 समस्या की जड़ पर चर्चा करने के लिए, न कि इसके चारों ओर कैसे काम करें।

— फिल

9

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

— हरि करम सिंह

1

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

— मार्टिन ब्लिस

@HariKaramSingh आप इसके आसपास काम करने के लिए सब्सक्राइब / पब्लिश पैटर्न या सिस्टम-वाइड इवेंट बस (जिसे सभी संबंधित पार्टियों में साझा किया जाना चाहिए, न कि सिंगलटन) का उपयोग कर सकते हैं।

— विक्टर सोरोकिन

4

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

— हरि करम सिंह

14

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

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

संक्षेप में, आपको क्या करने की आवश्यकता है? जब भी कोई वस्तु दूसरे पर निर्भर करती है, तो उसे केवल उसके कंस्ट्रक्टर (आपकी कक्षा में कोई नया कीवर्ड नहीं) के माध्यम से इसका उदाहरण प्राप्त होगा।

class NeedyClass {

    private ExSingletonClass exSingleton;

    public NeedyClass(ExSingletonClass exSingleton){
        this.exSingleton = exSingleton;
    }

    // Here goes some code that uses the exSingleton object
}

और फिर, कारखाना।

class FactoryOfNeedy {

    private ExSingletonClass exSingleton;

    public FactoryOfNeedy() {
        this.exSingleton = new ExSingletonClass();
    }

    public NeedyClass buildNeedy() {
        return new NeedyClass(this.exSingleton);
    }
}

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

आशा है कि ये आपकी मदद करेगा। कृपया कोई ग़लती बताएं।

— seuvitor
स्रोत

5

यह सुनिश्चित करने के लिए कि आपका कारखाना केवल एक बार आपको निजी बाधा की आवश्यकता है और निर्माण की विधि को एक स्थिर विधि के रूप में परिभाषित किया जाए।

— जुलिएन ग्रेनियर

16

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

— बॉब सोमरस

केवल एक इंस्टेंस होने का एक और तरीका है। आप अपने कारखाने को केवल एक बार इंस्टेंट कर सकते हैं। संकलक द्वारा इसे लागू करने की आवश्यकता नहीं है। यह उन unittests के साथ भी मदद करता है जहां आप एक अलग उदाहरण चाहते हैं ।

— 11:12 बजे

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

— meustrus

तो मूल रूप से इस दृष्टिकोण का लाभ यह है कि आपको केवल एक ऑब्जेक्ट इंस्टेंस (फैक्ट्री) के चारों ओर फेरबदल करना होगा बजाय संभावित वस्तुओं के एक पूरे झुंड के लिए (जिसके लिए आप सिंगलेट्स का उपयोग नहीं करना चाहते हैं)?

— हरि करम सिंह

9

वसंत या कोई अन्य IoC- कंटेनर उस में काफी अच्छा काम करता है। चूंकि कक्षाएं एप्लिकेशन के बाहर बनाई और प्रबंधित की जाती हैं, इसलिए कंटेनर साधारण कक्षाओं को एकल बना सकते हैं और जहां आवश्यकता होती है, वहां इंजेक्ट कर सकते हैं।

— काई
स्रोत

उपरोक्त विषयों के बारे में कोई लिंक मिला?

— CodingWithoutComments

ये चौखटे जावा के लिए विशिष्ट लगती हैं - कोई अन्य भाषा-विशिष्ट विकल्प? या भाषा-अज्ञेयवादी?

— CodingWithoutComments

.NET के लिए: कैसल विंडसर Castleproject.org/container/index.html Microsoft एकता msdn.microsoft.com/en-us/library/cc468366.aspx यूनिटी वास्तव में एक निर्भरता इंजेक्शन फ्रेमवर्क है, लेकिन यह शायद इस विषय के लिए काम करेगा।

— एरिक वैन ब्राकेल

1

इसके लिए बहुत अधिक वोट क्यों नहीं हैं? सिंग्लॉन से बचने के लिए आईओसी सही समाधान है।

— संदीप जिंदल

@CodingWithoutComments मुझे पता है कि PHP के पास सिम्फनी सर्विस कंटेनर है। माणिक दोस्तों पर निर्भरता को इंजेक्ट करने के अन्य तरीके हैं। क्या आपके पास एक विशिष्ट भाषा है जिसमें आप रुचि रखते हैं?

— ब्यूपर

9

किसी भी पैटर्न से बचने के लिए आपको अपने रास्ते से बाहर नहीं जाना चाहिए। एक पैटर्न का उपयोग या तो एक डिजाइन निर्णय या एक प्राकृतिक फिट है (यह बस जगह में गिरता है)। जब आप एक सिस्टम डिज़ाइन कर रहे होते हैं, तो आपके पास एक पैटर्न का उपयोग करने या पैटर्न का उपयोग न करने का विकल्प होता है। हालाँकि, आपको किसी भी चीज़ से बचने के लिए अपने रास्ते से बाहर नहीं जाना चाहिए जो अंततः एक डिज़ाइन विकल्प है।

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

सिंग्लटन की उपयुक्तता (या उसकी कमी) स्थिति पर निर्भर करती है। यह एक डिजाइन निर्णय है जिसे बनाया जाना चाहिए और उस निर्णय के परिणामों को समझना चाहिए (और प्रलेखित)।

— थॉमस ओवेन्स
स्रोत

मैं एक ही बात कहने जा रहा था, लेकिन यह उनके सवाल का बहुत जवाब नहीं देता है :)

— स्वाति

2

कृपया अपने उत्तर में इस बारे में बात करें कि यह उचित है या उचित नहीं है। मान जाओ ना।

— कोडिंगविथआउटकमिशन

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

— थॉमस ओवंस

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

— थॉमस ओवंस

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

— थॉमस ओवंस

5

मोनोस्टेट (रॉबर्ट सी। मार्टिन के एजाइल सॉफ्टवेयर डेवलपमेंट में वर्णित) सिंगलटन का एक विकल्प है। इस पैटर्न में कक्षा का डेटा सभी स्थिर हैं लेकिन गेटर्स / सेटर गैर-स्थिर हैं।

उदाहरण के लिए:

public class MonoStateExample
{
    private static int x;

    public int getX()
    {
        return x;
    }

    public void setX(int xVal)
    {
        x = xVal;
    }
}

public class MonoDriver
{
    public static void main(String args[])
    {
        MonoStateExample m1 = new MonoStateExample();
        m1.setX(10);

        MonoStateExample m2 = new MonoStateExample();
        if(m1.getX() == m2.getX())
        {
            //singleton behavior
        }
    }
}

मोनोस्टेट का सिंगलटन के साथ समान व्यवहार है, लेकिन ऐसा इस तरह से होता है जहां प्रोग्रामर को इस तथ्य के बारे में जरूरी नहीं पता है कि एक सिंगलटन का उपयोग किया जा रहा है।

— मार्क एम
स्रोत

यह अधिक वोटों का हकदार है; मैं Google से एक मोनो-रिफ़्रेशर की तलाश में यहाँ आया था!

— Mahemoff

@ मर्क मुझे ऐसा लगता है कि थ्रेड सेफ्टी के मामले में इस डिज़ाइन को बंद करना बहुत कठिन है। क्या मैं MonoStateExample में प्रत्येक स्थिर वैरिएबल के लिए एक इंस्टेंस लॉक बनाता हूं, या क्या मैं एक लॉक बनाता हूं जो सभी संपत्तियों का लाभ उठाता है? दोनों में गंभीर रुकावटें हैं जो आसानी से एक सिंगलटन पैटर्न में निष्पादित होती हैं।

— मार्टिन ब्लिस

यह उदाहरण सिंगलटन पैटर्न का एक वैकल्पिक है, लेकिन सिंगलटन पैटर्न की समस्याओं का समाधान नहीं करता है।

— संदीप जिंदल

4

सिंगलटन पैटर्न मौजूद है क्योंकि ऐसी परिस्थितियाँ होती है जब एक कर रहे हैं एक वस्तु सेवाओं का एक सेट प्रदान करने के लिए की जरूरत है ।

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

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

*pseudocode* currentContainer.GetServiceByObjectType(singletonType)
//Under the covers the object might be a singleton, but this is hidden to the consumer.

एकल वैश्विक के बजाय

*pseudocode* singletonType.Instance

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

नियंत्रण का उलटा भी देखें , विचार यह है कि एकल उपभोक्ता को सीधे उजागर करके, आप उपभोक्ता और वस्तु उदाहरण के बीच एक निर्भरता बनाते हैं, न कि वस्तु द्वारा प्रदान की गई वस्तु सेवाएं।

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

— पॉप कैटलिन
स्रोत

मैं सेवित कंटेनरों के आपके उदाहरण का काफी पालन नहीं करता। क्या आपके पास एक ऑनलाइन संसाधन है जिससे आप लिंक कर सकते हैं?

— CodingWithoutComments

"कैसल प्रोजेक्ट - विंडसर कंटेनर" Castleproject.org/container/index.html पर एक नज़र डालें । दुर्भाग्य से इस विषय के बारे में अमूर्त प्रकाशन खोजना बहुत कठिन है।

— पॉप कैटलिन

2

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

(हालांकि, मैं तर्क दूंगा कि पहली जगह में सिंगलटन का उपयोग करने का यह गलत तरीका है)

— डेविड कोएले
स्रोत

1

यदि आपका मुद्दा यह है कि आप राज्य रखना चाहते हैं, तो आप MumbleManager वर्ग चाहते हैं। इससे पहले कि आप एक सिस्टम के साथ काम करना शुरू करें, आपका क्लाइंट एक MumbleManager बनाता है, जहाँ Mumble सिस्टम का नाम है। उसके माध्यम से राज्य को बनाए रखा जाता है। संभावना है कि आपके MumbleManager में एक संपत्ति बैग होगा जो आपके राज्य को रखता है।

इस प्रकार की शैली बहुत सी-सी लगती है और जैसे बहुत वस्तु नहीं है - आप पाएंगे कि आपके सिस्टम को परिभाषित करने वाले ऑब्जेक्ट्स में एक ही MumbleManager का संदर्भ होगा।

— इमारत का बंद
स्रोत

सिंगलटन के खिलाफ या उसके खिलाफ पैरवी किए बिना, मुझे यह कहना होगा कि यह समाधान एक प्रतिमान है। MumbleManager एक "ईश्वर वर्ग" बन जाता है जिसमें सभी प्रकार के असमान ज्ञान होते हैं, जो एकल उत्तरदायित्व का उल्लंघन करता है। यह सभी अनुप्रयोग देखभाल के लिए एक सिंगलटन हो सकता है।

— मार्टिन ब्लिस

0

एक प्लेन ऑब्जेक्ट और एक फैक्ट्री ऑब्जेक्ट का उपयोग करें। फैक्ट्री केवल उदाहरण की जानकारी (उदाहरण के लिए इसमें शामिल है) और व्यवहार के साथ उदाहरण और सादा वस्तु विवरण को पुलिस के लिए जिम्मेदार है।

— डेविड
स्रोत

1

क्या एक कारखाने में अक्सर एक सिंगलटन नहीं होता है? इस तरह मैं आमतौर पर लागू किए गए फ़ैक्टरी पैटर्न को देखता हूं।

— थॉमस ओवंस

0

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

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

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

— Mecki
स्रोत

0

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

— user18834
स्रोत

0

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

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

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

— workmad3
स्रोत

1

मैं पूरी तरह से समझता हूं कि आप क्या कह रहे हैं। और मैं पूरी तरह से सहमत हूं। हालाँकि, आपका उत्तर अभी भी विशेष रूप से मेरे प्रश्न का उत्तर नहीं देता है। मैं यह नहीं चाहता था कि "सिंग्लटन का उपयोग करना कब उचित है?" मैं सिर्फ एकल के लिए व्यवहार्य विकल्पों में रुचि रखता था।

— CodingWithoutComments

0

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

— मनेरिको कोराज़ी
स्रोत

0

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

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

अधिकांश पैटर्न और एल्गोरिदम की तरह, एक सिंगलटन 'सिर्फ इसलिए कि यह शांत है' का उपयोग करना गलत नाम है। मुझे वास्तव में 'ब्लैक-बॉक्स' कॉल की आवश्यकता थी जो एक सिंगलटन की तरह लग रहा था। और IMO प्रश्न से निपटने का तरीका है: पैटर्न से अवगत रहें, लेकिन यह भी देखें कि इसका दायरा व्यापक है और किस स्तर पर यह अद्वितीय होना चाहिए।

— staticsan
स्रोत

-1

आपका क्या मतलब है, इससे बचने के लिए मेरी तकनीकें क्या हैं?

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

लेकिन वहाँ नहीं हैं। मुझे सिंगलटन पैटर्न से बचना नहीं है। यह बस पैदा नहीं करता है।

— DrPizza
स्रोत