के साथ नल ऑब्जेक्ट्स Instantiating ?? ऑपरेटर

Question

निम्नलिखित विशिष्ट परिदृश्य पर विचार करें:

if(anObject == null) 
{ 
anObject = new AClass(); 
} 

मैं सोच रहा हूँ क्या उपयोग करके निम्न प्रतिस्थापन के बारे में सोचा है ?? ऑपरेटर:

anObject = anObject ?? new AClass(); 

मुझे यकीन नहीं है कि मुझे दूसरे फॉर्म का उपयोग करना चाहिए या नहीं। यह एक अच्छा शॉर्टेंड जैसा लगता है, लेकिन शुरुआत में anObject = anObject निर्माण लगता है जैसे यह कोड-गंध का थोड़ा सा हो सकता है।

क्या यह करने के लिए एक उचित बात है, या क्या कोई बेहतर शॉर्टेंड है कि मुझे याद आ रही है? या शायद, "यह तीन लाइनें है, इसे खत्म करो!"

Answer 1

अद्यतन:

ओ आर मैपर के रूप में बताया गया है, सवाल यह है कि स्वयं काम एक कोड-गंध है के साथ क्या करना है। यह मेरी पुस्तक में 6 और दो 3 एस है। असाइनमेंट शायद ही एक महंगी ऑपरेशन है, और आप इसे अधिकांश गणित ऑपरेटरों के साथ किसी भी दर पर अन्य क्षेत्रों में करते हैं।

मुझे लगता है कि यह कोड गंध नहीं है।

---

मैं सभी आलसी वस्तुओं के लिए समय (अपने उदाहरण पर एक मामूली बदलाव) कि कार्य करें:

return _myClass ?? (_myClass = new MyClass()); 

मुझे लगता है कि यह ठीक है। विचित्र रूप से पर्याप्त मैं Lazy<T> का उपयोग नहीं करता ... यकीन नहीं क्यों, लेकिन फिर मैं अक्सर आलसी वस्तुओं को नहीं बनाता। Lazy<T> इसके इरादे में अधिक अभिव्यक्तिपूर्ण है, जैसा कि आप पढ़ सकते हैं कि आइटम आलसी रूप से तत्काल है, लेकिन तकनीकी रूप से यह किसी मौजूदा आइटम पर object ओवरहेड जोड़ता है। मैं वास्तव में किसी भी तरह से वास्तव में चिंता नहीं करता हूं।

"इसे प्राप्त करने" के लिए, मुझे लगता है कि यह शायद उस श्रेणी में पड़ता है। मुझे लगता है कि इस मामले में प्रत्येक के लिए खुद को।

Answer 2

अभिव्यक्ति के परिणाम को उसी वैरिएबल पर वापस निर्दिष्ट किए बिना - उदा। a = b ?? new AClass(); - उस पैटर्न ठीक है और यह एक "fallback" नया डिफ़ॉल्ट उदाहरण की तरह कुछ के लिए कार्य करता है:

private MyClass anObject; 

// ... 

(anObject ?? new MyClass()).DoSomething(); 

इस मामले में, नव निर्मित वस्तु बाद में पुन: उपयोग के लिए संग्रहीत नहीं है।

जब एक ही चर को बताए, ऐसा लगता है आप lazily कुछ आरंभ कर रहे हैं, जो मामले Lazy<T> का उपयोग करने में जाने के लिए अधिक अर्थपूर्ण तरीका होगा:

private Lazy<MyClass> anObject = new Lazy<MyClass>(); 

// ... 

anObject.Value.DoSomething(); 

उदाहरण नवीनतम जब बना दी जाएगी अंतिम पंक्ति निष्पादित करता है।

Answer 3

void Main() 
{ 
    AClass anObject = null; 

    // option A 
    if (anObject == null) 
    { 
     anObject = new AClass(); 
    } 
    // option B 
    anObject = anObject ? new AClass(); 
} 

विकल्प बी के अनुकूलित आईएल कोड के साथ विकल्प एक तुलना:

Option A       Option B       Description 
IL_0000: ldnull     IL_0000: ldnull     // Push a null reference on the stack. 
IL_0001: stloc.0  // anObject IL_0001: stloc.0  // anObject // Pop a value from stack into local variable 0. 
IL_0002: ldloc.0  // anObject IL_0002: ldloc.0  // anObject // Load local variable 0 onto stack 
            IL_0003: dup      // Duplicate the value on the top of the stack. 
IL_0003: brtrue.s IL_000B  IL_0004: brtrue.s IL_000C  // Branch to target if value is non-zero 
            IL_0006: pop      // Pop value from the stack 
IL_0005: newobj  AClass..ctor IL_0007: newobj  AClass..ctor // Allocate an uninitialized object or value type and call ctor 
IL_000A: stloc.0  // anObject IL_000C: stloc.0  // anObject // Pop a value from stack into local variable 0. 

आप देख सकते हैं वहाँ बहुत कम दोनों के बीच अंतर है - परिणाम कुछ और में विकल्प बी (त्रिगुट ऑपरेटर का उपयोग) ढेर संचालन।

जब तक आपके कंप्यूटर घड़ी की कल पर चलता है आप अपने अंतिम कोड में कोई अंतर दिखाई कई चीजों के साथ के रूप में तो होगा - जो भी अपने कोड के लिए सबसे अधिक पठनीय है।

विधि 1 गैर लेज़ी:

Answer 4

पैटर्न है कि मैं WPF दृश्य मॉडल में इस्तेमाल किया (जो वह जगह है जहाँ मैं इस पैटर्न ज्यादातर इस्तेमाल किया देखें) देखा है के एक जोड़े हैं

public class ViewModel 
{ 
    private readonly SomeValue _value; 

    public ViewModel() 
    { 
     _value = new SomeValue(); 
    } 

    public SomeValue Value { get { return _value; } } 
} 

विधि 1 आलसी:

public class ViewModel 
{ 
    private readonly Lazy<SomeValue> _value = new Lazy<SomeValue>(() => new SomeValue()); 

    public SomeValue Value { get { return _value.Value; } } 
} 

विधि 2:

public class ViewModel 
{ 
    private SomeValue _value; 

    public SomeValue Value { get { return _value ?? (_value = new SomeValue()); } } 
} 

विधि 1 और विधि 2 के बीच प्रमुख अंतर यह है कि वस्तु कब और कैसे बनाई जाती है। विधि 1 आलसी Lazy(T) का उपयोग करता है जो सृजन के लिए ओवरहेड जोड़ता है। यह केवल बड़ी वस्तुओं के लिए वास्तव में जरूरी है और डब्ल्यूपीएफ मॉडल बहुत भारी भारोत्तोलन नहीं करते हैं। ऑब्जेक्ट सृजन को उचित रखने के लिए बड़ी वस्तुएं आंतरिक रूप से आलस्य का लाभ ले सकती हैं।

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