कई से बचने के लिए कैसे अशक्त चेकों

Question

संभावित डुप्लिकेट यदि:

p.OrganisationalUnit.Parent.Head.CurrentAllocation.Person; 

:
Deep Null checking, is there a better way?
C# elegant way to check if a property's property is null

मैं इस तरह एक गहरी ऑब्जेक्ट मॉडल में एक देखने क्या करना है

वैसे भी इसे निकालने के लिए वैसे भी है और अगर कोई ओ च श्रृंखला एक

if (p.org == null && p.org.Parent == null && p.org.Parent.Head . . .  

Answer 1

आप अशक्त-सुरक्षित भिन्नता ऑपरेटर ?. लिए देख रहे हैं करने के लिए बिना अशक्त (ऑरगेनाइजेशनलयूनिट, माता पिता, सिर, आदि), (भी सुरक्षित नेविगेशन के रूप में जाना जाता है) है कि कुछ भाषाएँ (जैसे ग्रोवी) है, लेकिन दुर्भाग्य से सी # में यह ऑपरेटर नहीं है।

एक दिन उम्मीद है कि यह लागू किया जाएगा ....

एरिक Lippert द्वारा भी this post देखें। वह वाक्यविन्यास प्रस्तावित करता है .? है।

Answer 2

क्या आपने Law of Demeter के बारे में सुना है?

कॉल के ऐसे लंबे अनुक्रमों को चेन करना एक अच्छा विचार नहीं है। यह उन वर्गों के बीच भयानक निर्भरता बनाता है जिनकी आपको आवश्यकता नहीं है।

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

Answer 3

अपने शीर्षक में सवाल का जवाब करने के लिए, आप 'Demeter के कानून' लागू करने और()

एक विधि GetHeadOfParentOrganizationalUnit कहा जाता है मुझे यकीन है कि समाधान अपने विशिष्ट मामले के लिए लागू होता है अगर नहीं कर रहा हूँ बनाने के द्वारा से बच सकते हैं, लेकिन यह देखने के लायक है कि क्या आप उन सभी शून्य जांच को खत्म कर सकते हैं। बाहर a link

Answer 4

चेक this article:

भी देखें।

p.With(x => x.OrganisationalUnit) 
.With(x => x.Parent) 
.With(x => x.Head) 
.With(x => x.CurrentAllocation 
.With(x => x.Person); 

Answer 5

आपको लगता है कि पकड़ने के लिए और साथ ही बुनियादी अपवाद हैंडलिंग का उपयोग कर सकते हैं: यह एक महान समाधान है कि आप उस तरह बातें लिखने के लिए अनुमति देता है प्रस्तुत करता है। मैं उस समाधान के बारे में पागल नहीं हूँ, लेकिन यह एक विकल्प है। यदि ये नेस्टेड नल सामान्य ऑपरेशन हैं, तो अपवाद शायद सही उत्तर नहीं हैं:

public class A 
{ 
} 
public class B 
{ 
    public A a; 
} 
public class C 
{ 
    public B b; 
} 
class Program 
{ 
    static A GetA(C c) 
    { 
     A myA; 
     try 
     { 
      myA = c.b.a; 
     } 
     catch 
     { 
      myA = null; 
     } 
     return myA; 
    }   

    static void Main(string[] args) 
    { 
     C theC = new C(); 
     theC.b = new B(); 
     theC.b.a = new A(); 
     A goodA = GetA(theC); 
     if (goodA != null) 
     { 
      Console.WriteLine("Expected nominal path."); 
     } 
     else 
     { 
      Console.WriteLine("Unexpected nominal path."); 
     } 
     theC.b.a = null; 
     A badA = GetA(theC); 
     if (badA == null) 
     { 
      Console.WriteLine("Expected off-nominal path."); 
     } 
     else 
     { 
      Console.WriteLine("Unexpected off-nominal path."); 
     } 

    } 

}