सी # का कितना उपयोगी है ?? ऑपरेटर?

Question

तो क्या मैं चिंतित हूं ?? ऑपरेटर, लेकिन अभी भी इसका उपयोग करने में असमर्थ रहा है। मैं आमतौर पर इसके बारे में सोचो, जब मैं की तरह कुछ कर रहा हूँ:

var x = (someObject as someType).someMember; 

तो someObject वैध है और someMember रिक्त है, मैं कर सकता

var x = (someObject as someType).someMember ?? defaultValue; 

लेकिन लगभग हमेशा मैं समस्याओं में मिलता है जब someObject रिक्त है, तथा ?? मुझे खुद को शून्य जांचने से कोई क्लीनर बनाने में मदद नहीं करता है।

क्या आप लोगों के लिए क्या उपयोग किया जाता है ?? व्यावहारिक स्थितियों में?

Answer 1

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

IMHO, क्या अधिक से अधिक की आवश्यकता है ?? एक "शून्य-dereference" ऑपरेटर है जो आपको लंबी संपत्ति और/या विधि श्रृंखलाओं को एक साथ श्रृंखला की अनुमति देता है, उदा। a.b().c.d().e नल-नेस के लिए प्रत्येक मध्यवर्ती चरण का परीक्षण किए बिना। Groovy भाषा में Safe Navigation operator है और यह बहुत आसान है।

सौभाग्य से, ऐसा लगता है कि सी # टीम इस फीचर अंतर से अवगत है। C# टीम के लिए यह connect.microsoft.com suggestion देखें, सी # भाषा में एक नल-डीरेंसेंस ऑपरेटर जोड़ने के लिए।

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

एक? .b? .c ?? डी

मतलब अगर कोई, ए.बी. या ए.बी.टी. नल उपयोग डी है।

हम भविष्य में रिलीज के लिए इस पर विचार कर रहे हैं, लेकिन यह सी # 4.0 में नहीं होगा।

एक बार फिर धन्यवाद,

मैड्स Torgersen, सी # भाषा अपराह्न

आप भी सी # में इस सुविधा चाहते हैं, कनेक्ट साइट पर suggestion करने के लिए अपने वोट जोड़ने! :-)

एक वैकल्पिक हल मैं इस सुविधा की कमी से बचने के लिए का उपयोग क्या this blog post में वर्णित है की तरह एक विस्तार विधि, कोड इस तरह की अनुमति देने के लिए है:

string s = h.MetaData 
      .NullSafe(meta => meta.GetExtendedName()) 
      .NullSafe(s => s.Trim().ToLower()) 

इस कोड को या तो h.MetaData.GetExtendedName().Trim().ToLower() देता है या यह रिटर्न शून्य अगर एच, एच। मेटाडेटा, या एच। मेटाडेटा। GetExtendedName() शून्य है। मैंने इसे शून्य या खाली तारों, या शून्य या खाली संग्रहों की जांच करने के लिए भी बढ़ाया है। यहां दिए गए कोड का उपयोग मैं इन एक्सटेंशन विधियों को परिभाषित करने के लिए करता हूं:

public static class NullSafeExtensions 
{ 
    /// <summary> 
    /// Tests for null objects without re-computing values or assigning temporary variables. Similar to 
    /// Groovy's "safe-dereference" operator .? which returns null if the object is null, and de-references 
    /// if the object is not null. 
    /// </summary> 
    /// <typeparam name="TResult">resulting type of the expression</typeparam> 
    /// <typeparam name="TCheck">type of object to check for null</typeparam> 
    /// <param name="check">value to check for null</param> 
    /// <param name="valueIfNotNull">delegate to compute if check is not null</param> 
    /// <returns>null if check is null, the delegate's results otherwise</returns> 
    public static TResult NullSafe<TCheck, TResult>(this TCheck check, Func<TCheck, TResult> valueIfNotNull) 
     where TResult : class 
     where TCheck : class 
    { 
     return check == null ? null : valueIfNotNull(check); 
    } 

    /// <summary> 
    /// Tests for null/empty strings without re-computing values or assigning temporary variables 
    /// </summary> 
    /// <typeparam name="TResult">resulting type of the expression</typeparam> 
    /// <param name="check">value to check for null</param> 
    /// <param name="valueIfNotNullOrEmpty">delegate to compute non-null value</param> 
    /// <returns>null if check is null, the delegate's results otherwise</returns> 
    public static TResult CheckNullOrEmpty<TResult>(this string check, Func<string, TResult> valueIfNotNullOrEmpty) 
     where TResult : class 
    { 
     return string.IsNullOrEmpty(check) ? null : valueIfNotNullOrEmpty(check); 
    } 
    /// <summary> 
    /// Tests for null/empty collections without re-computing values or assigning temporary variables 
    /// </summary> 
    /// <typeparam name="TResult">resulting type of the expression</typeparam> 
    /// <typeparam name="TCheck">type of collection or array to check</typeparam> 
    /// <param name="check">value to check for null</param> 
    /// <param name="valueIfNotNullOrEmpty">delegate to compute non-null value</param> 
    /// <returns>null if check is null, the delegate's results otherwise</returns> 
    public static TResult CheckNullOrEmpty<TCheck, TResult>(this TCheck check, Func<TCheck, TResult> valueIfNotNullOrEmpty) 
     where TCheck : ICollection 
     where TResult : class 
    { 
     return (check == null || check.Count == 0) ? null : valueIfNotNullOrEmpty(check); 
    } 
} 

Answer 2

?? असल में एक शून्य जांच ऑपरेटर है।

कारण अपने कोड मुसीबत में हो जाता है

है कि अगर "someObject रिक्त है, तो .someMember एक अशक्त वस्तु पर एक संपत्ति है आप पहली बार अशक्त के लिए someObject जाँच करना होगा

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

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

Answer 3

मैं आमतौर पर तारों या नाखून के लिए इसका उपयोग करता हूं प्रकार

string s = someString ?? "Default message"; 

तुलना में आसान

string s; 
    if(someString == null) 
    s = "Default Message";   
    else 
    s = someString; 

या

है

string s = someString != null ? someString : "Default Message"; 

Answer 4

?? ऑपरेटर एसक्यूएल में coalesce विधि की तरह, यह आप पहली गैर शून्य मान हो जाता है।

var result = value1 ?? value2 ?? value3 ?? value4 ?? defaultValue; 

Answer 5

आपके मामले में आप एक स्थिर संपत्ति के रूप में DefaultObject बना सकते हैं और नीचे की तरह उपयोग कर सकते हैं ...

var x = (someObject as someType ?? someType.DefaultObject).someMember; 

जहाँ आपके DefaultObject एक स्थिर, केवल पढ़ने के लिए वस्तु वापस आ जाएगी।

तरह EventArgs.Empty, String.Empty आदि ...

Answer 6

मैं आप के रूप में ठीक उसी समस्या थी गया है, लेकिन LinqToXML एक टैग का उपयोग कर दस्तावेज़ में नहीं हो सकता है की अंतरिक्ष में इतना ?? प्रतिसाद नहीं का उपयोग कर उस टैग पर संपत्ति को एकत्रित करने के लिए व्यवहार्य नहीं है।

चूंकि सी # में वैश्विक चर के रूप में ऐसी कोई चीज नहीं है, सबकुछ कक्षा में है, इसलिए मुझे लगता है, जैसे ?? ज्यादातर बेकार है।

यहां तक ​​कि एक साधारण संपत्ति गेटर की तरह:

MyObject MyObj() { get { return _myObj ?? new MyObj(); } } 

शायद बेहतर एक प्रारंभकर्ता द्वारा कार्य किया है ...

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

Answer 7

सबसे उपयोगी है जब निरर्थक प्रकारों से निपटना है।

bool? whatabool; 
//... 
bool realBool = whatabool ?? false; 

बिना ?? आपको निम्नलिखित लिखना होगा, जो अधिक भ्रमित है।

bool realbool = false; 
if (whatabool.HasValue) 
    realbool = whatabool.Value; 

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

Answer 8

मैं इसे उन तरीकों से काम करने में उपयोग करता हूं जो सामान्य ऑपरेशन के तहत शून्य लौट सकते हैं।

उदाहरण के लिए, मान लें कि मेरे पास एक कंटेनर क्लास है जिसमें एक गेट विधि है जो कंटेनर में कोई कुंजी नहीं है (या शायद शून्य एक वैध संघ है)।

string GetStringRep(object key) { 
    object o = container.Get(key) ?? "null"; 
    return o.ToString(); 
} 

स्पष्ट रूप से, इन दो दृश्यों के बराबर हैं:

foo = bar != null ? bar : baz; 
foo = bar ?? baz; 

दूसरा केवल अधिक संक्षिप्त है तो मैं कुछ इस तरह कर सकते हैं।

Answer 9

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

यदि मैं अपने दिमाग को जल्दी से पार्स करने के लिए प्रशिक्षित करने जा रहा हूं ??, मुझे ऐसी स्थिति खोजने की ज़रूरत है जहां यह स्पष्ट लाभ दिखाए - कुछ ऐसा नहीं किया जा सकता है, या कहीं भी यह एक महत्वपूर्ण राशि बचाता है टाइपिंग का

और यह कहां है ?? मेरे लिए गिरता है। यह इतनी बार उपयोगी है और?: और यदि/अन्य ऐसे त्वरित और पठनीय विकल्प हैं जो वास्तव में एक अलग वाक्यविन्यास का उपयोग करने में थोड़ा सा बिंदु लगता है जो कुछ नया नहीं प्राप्त करता है।

ए = बी ?? सी ?? डी ?? ई; बहुत अच्छा लगता है। लेकिन मुझे ऐसा करने की ज़रूरत नहीं है!

मुझे जो परेशान लगता है वह है कि मैं उपयोग करना चाहता हूं ??, लेकिन हर बार मुझे लगता है कि "ओह, शायद मैं इसका उपयोग कर सकता हूं?", मुझे एहसास है कि मैं ऑब्जेक्ट का उपयोग नहीं करना चाहता, लेकिन इसका एक सदस्य

नाम = (उपयोगकर्ता == शून्य)? "डो": उपयोगकर्ता। नाम;

और दुर्भाग्य से ,?? यहाँ मदद नहीं करता है।

Answer 10

मैं अक्सर गुणों में आलसी तत्काल वस्तुओं के लिए इसका उपयोग करता हूं, उदा।

public MyObject MyProperty 
{ 
    get 
    { 
     return this.myField ?? (this.myField = new MyObject()); 
    } 
} 

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

public MyObject MyProperty 
{ 
    get 
    { 
     if (this.myField == null) 
     { 
      this.myField = new MyObject(); 
     } 

     return this.myField; 
    } 
} 

Answer 11

बस एक के रूप में

FYI करें, त्रिगुट ऑपरेटर अशक्त कोलेसिंग ऑपरेटर से आईएल का एक अलग अनुक्रम उत्पन्न करता है।

// string s = null; 
// string y = s != null ? s : "Default"; 
    ldloc.0 
    brtrue.s notnull1 
    ldstr "Default" 
    br.s isnull1 
    notnull1: ldloc.0 
    isnull1: stloc.1 

और इस तरह की तरह दिखता है उत्तरार्द्ध:

// y = s ?? "Default"; 
    ldloc.0 
    dup 
    brtrue.s notnull2 
    pop 
    ldstr "Default" 
    notnull2: stloc.1 

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

Answer 12

मैं अन्य डेटा प्रकारों में स्ट्रिंग को पार्स करते समय अक्सर नल-कोलेसिंग ऑपरेटर का उपयोग करता हूं। मेरे पास एक्सटेंशन विधियों का एक सेट है जो Int32.TryParse जैसी चीज़ों को लपेटता है और मेरे शेष कोड में आउटपुट पैरामीटर को उजागर करने के बजाए एक निरर्थक int वापस करता है। फिर मैं स्ट्रिंग को पार्स कर सकता हूं और कोड की एक पंक्ति में पार्स विफल होने पर डिफ़ॉल्ट मान प्रदान कर सकता हूं।

// ToNullableInt(), is an extension method on string that returns null 
// if the input is null and returns null if Int32.TryParse fails. 

int startPage = Request.QueryString["start"].ToNullableInt() ?? 0; 

Answer 13

मैं app.config सामान

string somethingsweet = ConfigurationManager.AppSettings["somesetting"] ?? "sugar";