दिलचस्प पोस्ट
अजगर सूची में किसी आइटम की अंतिम घटना कैसे प्राप्त करें विंडोज थ्रेडिंग: _beginthread vs _beginthreadex बनाम CreateThread C ++ खोज आदेश के साथ regex का उपयोग कैसे करें? कैलेंडर आवर्ती / दोहराए जाने वाले कार्यक्रम – सर्वश्रेष्ठ संग्रहण विधि एक पृष्ठ पर सभी AJAX अनुरोधों के लिए "हुक" जोड़ें पुस्तकालय हेडर से जीसीसी चेतावनियों को दबाने के लिए कैसे? क्या अन्य ऑब्जेक्ट में जावा कॉल पेरेंट ओवरराइड विधि है लेकिन उपप्रकार नहीं? विंडो बनाम पेज बनाम UserControl WPF नेविगेशन के लिए? जिन्जा एक्सप्रेशन के संदर्भ टेम्पलेट वैरिएबल SKScene में बटन सेट करना पायथन: उपप्रकाशन के साथ आउटपुट कैसे पुनर्निर्देशित करें? मैं सी # में एक मल्टी-कैरेक्टर डिलीमीटर द्वारा स्ट्रिंग कैसे विभाजित करूं? ऑब्जेक्ट प्रोटोटाइप के तरीकों के भीतर सेट "इन्टरवॉल / सेट टाइम" के अंदर "इस" को संदर्भित करना जावास्क्रिप्ट में साहचर्य सरणी / हैशिंग कैसे करें वर्णों की गतिशील राशि पर आधारित फ़ॉन्ट-आकार के उत्तरदायी बनाने के लिए शुद्ध सीएसएस

कार्य रिक्त या रिक्त ऑब्जेक्ट वापस लेना चाहिए?

कार्यों से डेटा वापस करते समय सबसे अच्छा अभ्यास क्या है क्या यह एक अशक्त या खाली वस्तु वापस करना बेहतर है? और एक को दूसरे पर क्यों करना चाहिए?

इस पर विचार करो:

public UserEntity GetUserById(Guid userId) { //Imagine some code here to access database..... //Check if data was returned and return a null if none found if (!DataExists) return null; //Should I be doing this here instead? //return new UserEntity(); else return existingUserEntity; } 

इस कार्यक्रम में वैध मामलों को सामने आने दें कि GUID के साथ डेटाबेस में कोई उपयोगकर्ता जानकारी नहीं होगी। मैं सोच सकता हूं कि इस मामले में अपवाद फेंकना उचित नहीं होगा ?? इसके अलावा मैं इस धारणा के तहत हूं कि अपवाद हैंडलिंग प्रदर्शन को नुकसान पहुंचा सकता है।

वेब के समाधान से एकत्रित समाधान "कार्य रिक्त या रिक्त ऑब्जेक्ट वापस लेना चाहिए?"

रिटर्निंग नल आमतौर पर सबसे अच्छा विचार है यदि आप यह इंगित करना चाहते हैं कि कोई डेटा उपलब्ध नहीं है।

एक खाली वस्तु का अर्थ है कि डेटा वापस कर दिया गया है, जबकि रिक्त लौटकर स्पष्ट रूप से संकेत मिलता है कि कुछ भी नहीं लौटा दिया गया है।

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

यह इस बात पर निर्भर करता है कि आपके मामले के लिए सबसे ज्यादा क्या मायने रखता है।

क्या यह शून्य पर लौटने का मतलब है, जैसे "ऐसा कोई उपयोगकर्ता मौजूद नहीं है"?

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

या क्या यह एक अपवाद (एक ला "फाइलनोट फ़ाउंड") फेंकने का मतलब है यदि कॉलिंग कोड एक यूजर को अवैध आईडी के साथ मांग रहा है?

हालांकि – चिंताओं / एसआरपी के दृष्टिकोण से जुदाई से, पहले दो अधिक सही हैं। और तकनीकी रूप से सबसे पहले सबसे सही है (लेकिन केवल बाल द्वारा) – उपयोगकर्ता को प्राप्त करने के लिए GetUserById केवल एक चीज़ के लिए ज़िम्मेदार होना चाहिए। अपने खुद के "उपयोगकर्ता मौजूद नहीं है" मामले को वापस लेने के मामले में एसआरपी का उल्लंघन हो सकता है एक अलग जांच में अलग – bool DoesUserExist(id) उपयुक्त होगा यदि आप अपवाद फेंकना चुनते हैं।

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

सभी दृष्टिकोण स्वीकार्य हैं – यह एपीआई / आवेदन के बड़े संदर्भ के आधार पर निर्भर करता है।

निजी तौर पर, मैं नल का उपयोग करता हूँ यह स्पष्ट करता है कि वापसी करने के लिए कोई डेटा नहीं है। लेकिन ऐसे मामले हैं जब कोई नल वस्तु उपयोगी हो सकती है।

यदि आपकी वापसी का प्रकार एक सरणी है तो फिर एक रिक्त सरणी लौटाएं अन्यथा नल वापसी करें।

आपको एक अपवाद फेंकना चाहिए (केवल) अगर कोई विशिष्ट अनुबंध टूट गया है
आपके विशिष्ट उदाहरण में, एक ज्ञात आईडी के आधार पर UserEntity के लिए पूछना, यह तथ्य पर निर्भर करता है कि यदि गायब (हटाए गए) उपयोगकर्ता अपेक्षित केस हैं यदि हां, तो null वापसी करें, लेकिन अगर यह अपेक्षित मामला नहीं है, तो अपवाद छोड़ दें।
ध्यान दें कि यदि फ़ंक्शन को UserEntity GetUserByName(string name) कहा जाता है, तो यह संभवत: फेंक नहीं करेगा, परन्तु नल वापस लौटाएगा। रिक्त यूज़रएन्टीटी लौटने वाले दोनों मामलों में बेकार होगा।

तार, सरणियों और संग्रह के लिए स्थिति आम तौर पर अलग होती है। मुझे कुछ दिशानिर्देश प्रपत्र एमएस याद है कि तरीकों को 'रिक्त' सूची के रूप में null स्वीकार करनी चाहिए, लेकिन शून्य की बजाय शून्य की वापसी का संग्रह तार के लिए एक ही है ध्यान दें कि आप खाली एरे की घोषणा कर सकते हैं: int[] arr = new int[0];

यह एक व्यापार प्रश्न है, इस पर निर्भर करता है कि क्या विशिष्ट ग्रिड आईडी वाले उपयोगकर्ता का अस्तित्व इस फ़ंक्शन के लिए एक सामान्य सामान्य उपयोग का मामला है, या क्या यह एक विसंगति है, जो इस आवेदन को उपयोगकर्ता को प्रदान कर रहा है, इस प्रक्रिया को सफलतापूर्वक पूरा करने से रोक देगा करने के लिए वस्तु…

यदि यह "अपवाद" है, तो उस आईडी के साथ उपयोगकर्ता की अनुपस्थिति के कारण आवेदन को सफलतापूर्वक पूरा करने से आवेदन को रोक दिया जाएगा, (कहें कि हम ऐसे उत्पाद के लिए एक चालान बना रहे हैं जिसे हमने उत्पाद भेज दिया है … ), तो यह स्थिति एक ArgumentException (या कुछ अन्य कस्टम अपवाद) फेंक देना चाहिए।

यदि कोई लापता उपयोगकर्ता ठीक है, (इस फ़ंक्शन को कॉल करने के संभावित सामान्य परिणामों में से एक) तो फिर एक रिक्त वापसी करें ….

संपादित करें: (दूसरे उत्तर में एडम से टिप्पणी को संबोधित करने के लिए)

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

लेकिन अगर आवेदन के भीतर सभी प्रक्रियाओं को उपयोगकर्ता की आवश्यकता होती है, तो भी मैं इस पद्धति में अपवाद फेंक दूँगा …

मैं व्यक्तिगत रूप से रिक्त वापस आऊंगा, क्योंकि इसी तरह मैं कार्य करने के लिए डीएएल / रिपॉजिटरी लेयर की अपेक्षा करता हूं।

अगर यह अस्तित्व में नहीं है, तो कुछ भी वापस न करें जो कि वस्तु को सफलतापूर्वक लाया जा सके, null यहाँ खूबसूरती से काम करता है।

सबसे महत्वपूर्ण बात यह है कि आप अपने डीएएल / रेपो लेयर में संगत होना चाहते हैं, इस तरह आप इसका उपयोग कैसे करें, इसके बारे में भ्रमित नहीं होते हैं।

फिर भी एक अन्य दृष्टिकोण में कॉलबैक ऑब्जेक्ट या प्रतिनिधि को पास करना शामिल है जो मूल्य पर काम करेगा। यदि कोई मान नहीं मिला है, तो कॉलबैक नहीं कहा जाता है।

 public void GetUserById(Guid id, UserCallback callback) { // Lookup user if (userFound) callback(userEntity); // or callback.Call(userEntity); } 

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

 public void GetUserById(Guid id, UserCallback callback, NotFoundCallback notFound) { // Lookup user if (userFound) callback(userEntity); // or callback.Call(userEntity); else notFound(); // or notFound.Call(); } 

एक ही ऑब्जेक्ट का उपयोग करने वाले एक ही दृष्टिकोण की तरह लग सकता है:

 public void GetUserById(Guid id, UserCallback callback) { // Lookup user if (userFound) callback.Found(userEntity); else callback.NotFound(); } 

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

हम CSLA.NET का उपयोग करते हैं, और यह देखता है कि एक विफल डेटा प्राप्त करने के लिए "रिक्त" वस्तु वापस करना चाहिए यह वास्तव में काफी कष्टप्रद है, क्योंकि यह जांच के सम्मेलन की मांग है कि क्या obj.IsNew बजाय obj == null

पिछला पोस्टर के रूप में उल्लेख किया गया है, रिक्त वस्तुओं के कारण चुपके समस्याओं की संभावना को कम करने , निरर्थक वापसी मान कोड सीधे विफल होने के कारण हो जाएगा।

निजी तौर पर, मुझे लगता है कि null अधिक सुरुचिपूर्ण हैं।

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

आप इस से संभाल सकते हैं:

 अगर (User.Exists (आईडी)) {
   this.User = User.Fetch (आईडी);
 } अन्य {
   Response.Redirect ( "~ / notfound.aspx");
 }

… लेकिन यह हर बार डेटाबेस के लिए एक अतिरिक्त कॉल है, जो उच्च-ट्रैफ़िक पृष्ठों पर एक समस्या हो सकती है। जहाँ तक:

 this.User = User.Fetch (आईडी);

 अगर (this.User == नल) {
   Response.Redirect ( "~ / notfound.aspx");
 }

… केवल एक कॉल की आवश्यकता है

मैं null पसंद करता हूं, क्योंकि यह अशक्त-सहकारी ऑपरेटर ( ?? ) के साथ संगत है

मैं एक रिक्त ऑब्जेक्ट के बदले रिक्त नल कहूंगा

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

यह नियम मैं आम तौर पर पालन करता हूं:

  • यदि प्राथमिक कुंजी संचालन के द्वारा कोई परिणाम नहीं मिला, तो ObjectNotFoundException फेंकें
  • अगर किसी भी अन्य मानदंड से कोई भी परिणाम नहीं मिला, तो रिक्त वापसी करें।
  • यदि कोई गैर-मानदंड के आधार पर कोई परिणाम नहीं मिला है, जो कई ऑब्जेक्ट्स वापस कर सकता है, तो एक रिक्त संग्रह वापस आ जाता है।

मैं इसके लिए अभिमुख हूं

  • return null यदि ऑब्जेक्ट आईडी मौजूद नहीं है, यह पहले से ही नहीं जानता है कि यह मौजूद होना चाहिए या नहीं।
  • throw अगर ऑब्जेक्ट आईडी अस्तित्व में नहीं है जब यह मौजूद होना चाहिए

मैं इन दो परिस्थितियों को इन तीन प्रकार के तरीकों से अलग करता हूं। प्रथम:

 Boolean TryGetSomeObjectById(Int32 id, out SomeObject o) { if (InternalIdExists(id)) { o = InternalGetSomeObject(id); return true; } else { return false; } } 

दूसरा:

 SomeObject FindSomeObjectById(Int32 id) { SomeObject o; return TryGetObjectById(id, out o) ? o : null; } 

तीसरा:

 SomeObject GetSomeObjectById(Int32 id) { SomeObject o; if (!TryGetObjectById(id, out o)) { throw new SomeAppropriateException(); } return o; } 

यह संदर्भ के आधार पर अलग-अलग होगा, लेकिन अगर मैं एक विशेष ऑब्जेक्ट (उदाहरण के तौर पर) की तलाश कर रहा हूं, तो आम तौर पर मैं अशक्त लौटा दूँगा और अगर मैं ऑब्जेक्ट का सेट देख रहा हूं, लेकिन कोई भी नहीं है,

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

इस मामले में सबसे अच्छा एक मामले में वापसी "रिक्त" वहाँ कोई ऐसा उपयोगकर्ता नहीं है इसके अलावा अपनी विधि स्थिर बनाओ

संपादित करें:

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

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

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

हमारे बिजनेस ऑब्जेक्ट में हमारे पास 2 मुख्य तरीके हैं:

संदर्भों में चीजों को सरल रखने के लिए या आप ये सवाल करते हैं कि वे होंगे:

 // Returns null if user does not exist public UserEntity GetUserById(Guid userId) { } // Returns a New User if user does not exist public UserEntity GetNewOrExistingUserById(Guid userId) { } 

पहली विधि का उपयोग विशिष्ट संस्थाओं के लिए किया जाता है, दूसरी विधि विशेष रूप से वेब पृष्ठों पर संस्थाओं को जोड़ने या संपादित करते समय उपयोग की जाती है।

इससे हमें संदर्भ में दोनों दुनिया का सर्वश्रेष्ठ स्थान प्राप्त करने में सहायता मिलती है जहां उनका उपयोग किया जाता है।

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

जावा का उपयोग करते हुए हमें एक assert exists(object) : "You shouldn't try to access an object that doesn't exist"; जोड़ने के लिए कहा जाता assert exists(object) : "You shouldn't try to access an object that doesn't exist"; किसी भी पद्धति की शुरुआत में, जो "रिकंडिशन" (मुझे नहीं पता कि अंग्रेजी में शब्द क्या है) को व्यक्त करने के लिए रिक्त लौटा सकता है।

आईएमओ यह वास्तव में उपयोग करना आसान नहीं है, लेकिन मैं इसका उपयोग कर रहा हूं, बेहतर कुछ के लिए इंतजार कर रहा हूं।

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

 public Option<UserEntity> GetUserById(Guid userId) { //Imagine some code here to access database..... //Check if data was returned and return a null if none found if (!DataExists) return Option<UserEntity>.Nothing; else return Option.Just(existingUserEntity); } 

और इस तरह इस्तेमाल किया जा सकता है:

 Option<UserEntity> result = GetUserById(...); if (result.IsNothing()) { // deal with it } else { UserEntity value = result.GetValue(); } 

दुर्भाग्य से, हर कोई अपनी तरह से इस तरह के एक प्रकार के रोल लगता है

मैं आमतौर पर रिक्त वापसी करते हैं यह पता लगाने के लिए एक त्वरित और आसान तरीका प्रदान करता है कि कुछ अपवादों को फेंकने और पूरे स्थान पर कई प्रयास / पकड़ने के बिना कुछ खराब हो।

संग्रह प्रकारों के लिए मैं एक रिक्त संग्रह वापस करूँगा, अन्य सभी प्रकारों के लिए मैं किसी ऑब्जेक्ट को लौटने के लिए नल ओब्जेक्ट पैटर्न का उपयोग करना पसंद करता हूं, जो कि वापसी के प्रकार के समान अंतरफलक लागू करता है। पैटर्न के बारे में जानकारी के लिए लिंक टेक्स्ट की जांच करें

NullObject पैटर्न का प्रयोग करना यह होगा: –

 public UserEntity GetUserById(Guid userId) 

{// कल्पना करने के लिए यहां कुछ कोड का उपयोग करें …..

  //Check if data was returned and return a null if none found if (!DataExists) return new NullUserEntity(); //Should I be doing this here instead? return new UserEntity(); else return existingUserEntity; 

}

 class NullUserEntity: IUserEntity { public string getFirstName(){ return ""; } ...} 

दूसरों को जो कुछ भी कहते हैं, उन्हें डालने के लिए …

अपवाद असाधारण परिस्थितियों के लिए हैं

यदि यह विधि शुद्ध डेटा एक्सेस परत है, तो मैं कहूंगा कि एक पैरामीटर जो एक चुनिंदा बयान में शामिल होता है, यह उम्मीद करता है कि मुझे कोई ऐसी पंक्तियां नहीं मिलेंगी जिससे कोई ऑब्जेक्ट बन सके, और इसलिए शून्य लौटकर स्वीकार्य होगा क्योंकि यह डेटा एक्सेस लॉजिक है

दूसरी ओर, अगर मुझे अपने पैरामीटर की प्राथमिक कुंजी को प्रतिबिंबित करने की उम्मीद है और मुझे केवल एक पंक्ति वापस मिलनी चाहिए, अगर मुझे एक से अधिक परत मिले तो मैं एक अपवाद डालूंगा शून्य ठीक लौटने के लिए ठीक है, 2 नहीं है

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

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

मेरे छद्म-पीपी / कोड को माफ़ करो

मुझे लगता है कि यह वाकई परिणाम के इच्छित उपयोग पर निर्भर करता है।

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

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

उदाहरण:

 function saveTheRow($prim_key, $data) { $row = getRowByPrimKey($prim_key); // Populate the data here $row->save(); } 

यहां हम देख सकते हैं कि आपरेशनों की एक ही श्रृंखला इस प्रकार के सभी अभिलेखों का प्रबंधन करती है।

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

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

उदाहरण:

 function displayData($row_id) { // Logging of the error would happen in this function $row = getRow($row_id); if($row === null) { // Handle the error here } // Do stuff here with data } function getRow($row_id) { $row = null; try{ if(!$db->connected()) { throw excpetion("Couldn't Connect"); } $result = $db->query($some_query_using_row_id); if(count($result) == 0 ) { throw new exception("Couldn't find a record!"); } $row = $db->nextRow(); } catch (db_exception) { //Log db conn error, alert admin, etc... return null; // This way I know that null means an error occurred } return $row; } 

यह मेरा सामान्य नियम है यह अब तक अच्छी तरह से काम किया है।

दिलचस्प प्रश्न और मुझे लगता है कि कोई "सही" जवाब नहीं है, क्योंकि यह हमेशा आपके कोड की ज़िम्मेदारी पर निर्भर करता है। क्या आपकी पद्धति यह जानती है कि कोई भी डेटा नहीं मिला है या नहीं? ज्यादातर मामलों में जवाब "नहीं" है और यही वजह है कि कॉलर को संभालने की वजह से वह पूरी तरह से सही है।

संभवत: रिक्त-वापसी पद्धतियों से फेंकने के तरीकों का पता लगाने के लिए एक अच्छा तरीका है कि आपकी टीम में एक सम्मेलन का पता लगाया जाए: यदि कुछ पाने के लिए कुछ नहीं है, तो वे "कुछ" प्राप्त करने के तरीके को अपवाद फेंकना चाहिए नल की वापसी के तरीके अलग नाम दिए जा सकते हैं, शायद इसके बजाय "ढूंढें …"

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

उदाहरण:

 bool IsAdministrator(User user) { var groupsOfUser = GetGroupsOfUser(user); // This foreach would cause a run time exception if groupsOfUser is null. foreach (var groupOfUser in groupsOfUser) { if (groupOfUser.Name == "Administrators") { return true; } } return false; } 

I like not to return null from any method, but to use Option functional type instead. Methods that can return no result return an empty Option, rather than null.

Also, such methods that can return no result should indicate that through their name. I normally put Try or TryGet or TryFind at the beginning of the method's name to indicate that it may return an empty result (eg TryFindCustomer, TryLoadFile, etc.).

That lets the caller apply different techniques, like collection pipelining (see Martin Fowler's Collection Pipeline ) on the result.

Here is another example where returning Option instead of null is used to reduce code complexity: How to Reduce Cyclomatic Complexity: Option Functional Type

More meat to grind: let's say my DAL returns a NULL for GetPersonByID as advised by some. What should my (rather thin) BLL do if it receives a NULL? Pass that NULL on up and let the end consumer worry about it (in this case, an ASP.Net page)? How about having the BLL throw an exception?

The BLL may be being used by ASP.Net and Win App, or another class library – I think it is unfair to expect the end consumer to intrinsically "know" that the method GetPersonByID returns a null (unless null types are used, I guess).

My take (for what it's worth) is that my DAL returns NULL if nothing is found. FOR SOME OBJECTS, that's ok – it could be a 0:many list of things, so not having any things is fine (eg a list of favourite books). In this case, my BLL returns an empty list. For most single entity things (eg user, account, invoice) if I don't have one, then that's definitely a problem and a throw a costly exception. However, seeing as retrieving a user by a unique identifier that's been previously given by the application should always return a user, the exception is a "proper" exception, as in it's exceptional. The end consumer of the BLL (ASP.Net, f'rinstance) only ever expects things to be hunky-dory, so an Unhandled Exception Handler will be used instead of wrapping every single call to GetPersonByID in a try – catch block.

If there is a glaring problem in my approach, please let me know as I am always keen to learn. As other posters have said, exceptions are costly things, and the "checking first" approach is good, but exceptions should be just that – exceptional.

I'm enjoying this post, lot's of good suggestions for "it depends" scenarios 🙂

I am perplexed at the number of answers (all over the web) that say you need two methods: an "IsItThere()" method and a "GetItForMe()" method and so this leads to a race condition. What is wrong with a function that returns null, assigning it to a variable, and checking the variable for Null all in one test? My former C code was peppered with

if ( NULL != (variable = function(arguments…)) ) {

So you get the value (or null) in a variable, and the result all at once. Has this idiom been forgotten? क्यूं कर?

I agree with most posts here, which tend towards null .

My reasoning is that generating an empty object with non-nullable properties may cause bugs. For example, an entity with an int ID property would have an initial value of ID = 0 , which is an entirely valid value. Should that object, under some circumstance, get saved to database, it would be a bad thing.

For anything with an iterator I would always use the empty collection. कुछ इस तरह

 foreach (var eachValue in collection ?? new List<Type>(0)) 

is code smell in my opinion. Collection properties shouldn't be null, ever.

An edge case is String . Many people say, String.IsNullOrEmpty isn't really necessary, but you cannot always distinguish between an empty string and null. Furthermore, some database systems (Oracle) won't distinguish between them at all ( '' gets stored as DBNULL ), so you're forced to handle them equally. The reason for that is, most string values either come from user input or from external systems, while neither textboxes nor most exchange formats have different representations for '' and null . So even if the user wants to remove a value, he cannot do anything more than clearing the input control. Also the distinction of nullable and non-nullable nvarchar database fields is more than questionable, if your DBMS is not oracle – a mandatory field that allows '' is weird, your UI would never allow this, so your constraints do not map. So the answer here, in my opinion is, handle them equally, always.

Concerning your question regarding exceptions and performance: If you throw an exception which you cannot handle completely in your program logic, you have to abort, at some point, whatever your program is doing, and ask the user to redo whatever he just did. In that case, the performance penalty of a catch is really the least of your worries – having to ask the user is the elephant in the room (which means re-rendering the whole UI, or sending some HTML through the internet). So if you don't follow the anti-pattern of " Program Flow with Exceptions ", don't bother, just throw one if it makes sense. Even in borderline cases, such as "Validation Exception", performance is really not an issue, since you have to ask the user again, in any case.

I think functions should not return null, for the health of your code-base. I can think of a few reasons:

There will be a large quantity of guard clauses treating null reference if (f() != null) .

What is null , is it an accepted answer or a problem? Is null a valid state for a specific object? (imagine that you are a client for the code). I mean all reference types can be null, but should they?

Having null hanging around will almost always give a few unexpected NullRef exceptions from time to time as your code-base grows.

There are some solutions, tester-doer pattern or implementing the option type from functional programming.

You should be throwing an exception if it is an exceptional circumstance that you call that code with an invalid user ID. If it is NOT an exceptional circumstance, then what you are essentially doing is using a "getter" method to test whether a user exists or not. That is like trying to open a file to see if it exists or not (lets stick to c#/java here) instead of using the exists method, or trying to access dictionary elements and seeing if they exist by looking at the return value instead of using the "contains" method first.

Therefore, it is likely you are after an additional method such as "exists" to first check if there is such a user. Performance of exceptions is definitely not a reason to just not use them at all unless you have genuine performance issues.