कौन सा पसंद किया जाता है: अशक्त <टी> ।हैसवाल्यू या अशक्त <टी>! = अशक्त!

Question

मैंने हमेशा इस्तेमाल किया Nullable<>.HasValueक्योंकि मुझे शब्दार्थ पसंद था। हालाँकि, हाल ही में मैं किसी और के मौजूदा कोडबेस पर काम कर रहा था जहाँ वे Nullable<> != nullइसके बजाय विशेष रूप से इस्तेमाल करते थे।

क्या एक के बाद एक का उपयोग करने का कारण है, या यह पूरी तरह से वरीयता है?

1. int? a;
   if (a.HasValue)
       // ...

बनाम

2. int? b;
   if (b != null)
       // ...

Comments

मैंने इसी तरह का प्रश्न पूछा ... कुछ अच्छे उत्तर मिले: stackoverflow.com/questions/633286/…

— नेलटाउनडाउन

व्यक्तिगत रूप से , मैं उपयोग करूँगा HasValueक्योंकि मुझे लगता है कि शब्द प्रतीकों की तुलना में अधिक पठनीय हैं। हालांकि यह सब आपके ऊपर है, और आपकी मौजूदा शैली के साथ क्या फिट बैठता है।

— जेक पेट्रोल्स

.HasValueअधिक समझ में आता है क्योंकि यह दर्शाता है कि प्रकार एक प्रकार के T?बजाय टाइप का है जो अशांत हो सकता है जैसे कि तार।

— user3791372

Answer 1

कंपाइलर कॉल के साथ अशक्त तुलना को बदल देता है HasValue, इसलिए कोई वास्तविक अंतर नहीं है। बस जो भी अधिक पठनीय है / आपके और आपके सहयोगियों के लिए अधिक समझ में आता है।

Comments

मुझे लगता है कि "जो भी अधिक सुसंगत है / एक मौजूदा कोडिंग शैली का अनुसरण करेगा।"

— जोश ली

वाह। मुझे इस सिन्थेटिक शुगर से नफरत है। int? x = nullमुझे यह भ्रम देता है कि एक अशक्त उदाहरण एक संदर्भ प्रकार है। लेकिन सच्चाई यह है कि Nullable <T> एक मूल्य प्रकार है। ऐसा लगता है कि मुझे ऐसा करने के लिए एक NullReferenceException मिलेगी int? x = null; Use(x.HasValue):।

— KFL

@ केएफएल यदि सिंटैक्टिक शुगर आपको परेशान करता है, तो Nullable<int>इसके बजाय बस का उपयोग करें int?।

— कोल जॉनसन

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

— एंडर्स

यह बहुत ही मूर्खतापूर्ण है कि अशक्त को अशक्त करने में सक्षम होने के बारे में शिकायत करने के लिए या इसे अशक्त कहा जाने वाले अशक्त की तुलना करें । समस्या यह है कि लोग "संदर्भ प्रकार" को "अशक्त हो सकते हैं" के साथ भ्रमित कर रहे हैं, लेकिन यह एक वैचारिक भ्रम है। भविष्य C # में गैर-अशक्त संदर्भ प्रकार होंगे।

— जिम बेल्टर

Answer 2

मैं पसंद करता हूं (a != null)ताकि वाक्यविन्यास संदर्भ प्रकारों से मेल खाए।

Comments

जो काफी निश्चित रूप से भ्रामक है, क्योंकि Nullable<>है नहीं एक संदर्भ प्रकार।

— लुआं

हां, लेकिन यह तथ्य आमतौर पर उस बिंदु पर बहुत कम मायने रखता है जिस पर आप अशक्त हैं।

— cbp

यह केवल भ्रमित करने के लिए भ्रामक है। दो अलग-अलग प्रकारों के लिए एक सुसंगत वाक्यविन्यास का उपयोग करने का मतलब यह नहीं है कि वे एक ही प्रकार हैं। C # में अशक्त संदर्भ प्रकार हैं (सभी संदर्भ प्रकार वर्तमान में अशक्त हैं, लेकिन यह भविष्य में बदल जाएगा) और अशक्त मान प्रकार। सभी अशक्त प्रकारों के लिए एक सुसंगत वाक्यविन्यास का उपयोग करना समझ में आता है। किसी भी तरह से इसका मतलब यह नहीं है कि अशक्त मान प्रकार संदर्भ प्रकार हैं, या कि अशक्त संदर्भ प्रकार मान प्रकार हैं।

— जिम बाल्टर

मैं पसंद HasValueहै क्योंकि यह अधिक से अधिक पठनीय है!= null

— कोनराड

यदि आप एक ही कोड लिखने की विभिन्न शैलियों को नहीं मिलाते हैं तो कोडिंग संगति अधिक पठनीय है। चूंकि सभी जगहों पर एक .HasValue प्रॉपर्टी नहीं है, इसलिए इसका उपयोग तब से होता है! = बढ़ी हुई निरंतरता के लिए शून्य। मेरे मतों में।

— ColacX

Answer 3

मैंने एक अशक्त इंट को मान प्रदान करने के लिए विभिन्न तरीकों का उपयोग करके इस पर कुछ शोध किया। यहाँ है, जब मैंने विभिन्न चीजें कीं। स्पष्ट करना चाहिए कि क्या चल रहा है। ध्यान रखें: Nullable<something>या शॉर्टहैंड something?एक संरचना है जिसके लिए कंपाइलर हमें शून्य के साथ उपयोग करने के लिए बहुत काम कर रहा है जैसे कि यह एक वर्ग था।
जैसा कि आप नीचे देखेंगे, SomeNullable == nullऔर SomeNullable.HasValueहमेशा एक सही या गलत वापसी करेंगे। हालांकि नीचे प्रदर्शित नहीं किया गया है, SomeNullable == 3यह भी मान्य है (कुछ को मानना ​​संभव है int?)।
जबकि SomeNullable.Valueहमें एक रनटाइम त्रुटि मिलती है यदि हम को सौंपा गया nullहै SomeNullable। यह वास्तव में एकमात्र मामला है जहां नलबल हमें एक समस्या पैदा कर सकता है, अतिभारित ऑपरेटरों के संयोजन के कारण, अतिभारितobject.Equals(obj) विधि, और संकलक अनुकूलन और बंदर व्यवसाय।

यहाँ कुछ कोड का विवरण दिया गया है जो मैं चला रहा था, और यह लेबल में किस आउटपुट का उत्पादन करता है:

int? val = null;
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

ठीक है, अगले आरंभीकरण विधि का प्रयास करें:

int? val = new int?();
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

पहले जैसा ही सब। ध्यान रखें कि int? val = new int?(null);निर्माणकर्ता को दिए गए अशक्त के साथ , प्रारंभिक संकलन में, एक कंपाइल समय त्रुटि उत्पन्न होगी, क्योंकि अशक्त वस्तु का VALUE शून्य नहीं है। यह केवल आवरण वस्तु ही है जो अशक्त को बराबर कर सकती है।

इसी तरह, हम एक संकलन समय त्रुटि प्राप्त करेंगे:

int? val = new int?();
val.Value = null;

उल्लेख नहीं है कि val.Valueवैसे भी केवल पढ़ने के लिए संपत्ति है, जिसका अर्थ है कि हम भी कुछ का उपयोग नहीं कर सकते हैं:

val.Value = 3;

लेकिन फिर से, बहुरूपिक ओवरलोड किए गए निहित रूपांतरण ऑपरेटरों ने हमें ऐसा करने दिया:

val = 3;

हालांकि, जब तक यह सही काम करता है तो पॉलीसोमिंग व्हाटमचैलिट्स के बारे में चिंता करने की ज़रूरत नहीं है? :)

Comments

"ध्यान रखें: अशक्त <कुछ> या आशुलिपि कुछ? एक वर्ग है।" ये गलत है! अशक्त <T> एक संरचना है। यह शून्य के बराबर होने पर लौटने के लिए बराबर और == ऑपरेटर को ओवरलोड करता है। कंपाइलर इस तुलना के लिए कोई फैंसी काम नहीं करता है।

— andrewjs

@andrewjs - आप सही कह रहे हैं कि यह एक संरचना है (एक वर्ग नहीं), लेकिन आप गलत हैं कि यह == ऑपरेटर को ओवरलोड करता है। यदि आप Nullable<X>VisualStudio 2013 और F12 में टाइप करते हैं, तो आप देखेंगे कि यह केवल Xऔर उसके लिए, और Equals(object other)विधि में रूपांतरण को ओवरलोड करता है। हालांकि, मुझे लगता है कि == ऑपरेटर डिफ़ॉल्ट रूप से उस पद्धति का उपयोग करता है, इसलिए प्रभाव समान है। मैं वास्तव में कुछ समय के लिए इस तथ्य पर इस उत्तर को अद्यतन करने के लिए अर्थ रखता हूं, लेकिन मैं आलसी और / या व्यस्त हूं। यह टिप्पणी अभी के लिए करनी होगी :)

— पेरिन लार्सन

मैंने ildasm के माध्यम से त्वरित जांच की और आप कंपाइलर के बारे में कुछ जादू कर रहे हैं; एक अशक्त <T> वस्तु की तुलना अशक्त करना वास्तव में HasValue के लिए एक कॉल में अनुवाद करता है। दिलचस्प!

— andrewjs

@andrewjs दरअसल, कंपाइलर एक टन काम करता है नलबल को ऑप्टिमाइज़ करने का। उदाहरण के लिए, यदि आप एक अशक्त प्रकार का मान निर्दिष्ट करते हैं, तो यह वास्तव में एक अशक्त नहीं होगा (जैसे, int? val = 42; val.GetType() == typeof(int))। तो न केवल अशक्त एक संरचना है जो शून्य के बराबर हो सकती है, यह अक्सर एक अशक्त भी नहीं है! : D उसी तरह, जब आप एक अशक्त मूल्य को बॉक्स करते हैं, तो आप मुक्केबाजी कर रहे हैं int, नहीं int?- और जब आपके int?पास कोई मूल्य नहीं है, तो आपको nullएक बॉक्स वाले अशक्त मूल्य के बजाय मिलता है । मूल रूप से इसका मतलब है कि

— अशक्त

@JimBalter सच में? यह तो बहुत ही मज़ेदार है। तो मेमोरी प्रोफाइलर आपको कक्षा में एक अशक्त क्षेत्र के बारे में क्या बताता है? आप ऐसे मान प्रकार की घोषणा कैसे करते हैं जो C # में किसी अन्य मान प्रकार से प्राप्त होता है? आप अपने स्वयं के अशक्त प्रकार को कैसे घोषित करते हैं जो .NET के अशक्त प्रकार के समान है? Null.NET में एक प्रकार कब से है ? क्या आप सीएलआर / सी # विनिर्देश में भाग की ओर इशारा कर सकते हैं, जहां यह कहा गया है? Nullables को CLR विनिर्देश में अच्छी तरह से परिभाषित किया गया है, उनका व्यवहार "अमूर्तन का कार्यान्वयन" नहीं है - यह एक अनुबंध है । लेकिन अगर आप जो सबसे अच्छा कर सकते हैं वह है विज्ञापन होमिनम अटैक, खुद का आनंद लें।

— लुआं नोव

Answer 4

VB.Net में। जब आप ".HasValue" का उपयोग कर सकते हैं तो "कुछ भी नहीं" का उपयोग न करें। मैंने सिर्फ एक "हल किया है" ऑपरेशन रनटाइम को अस्थिर कर सकता है "मध्यम विश्वास की त्रुटि" IsNot Nothing "के साथ" .HasValue "को एक स्थान पर रखकर। मुझे सच में समझ नहीं आया कि क्यों, लेकिन कंपाइलर में कुछ अलग हो रहा है। मुझे लगता है कि C # में "! = Null" एक ही मुद्दा हो सकता है।

Comments

मैं HasValueपठनीयता के कारण पसंद करूंगा । IsNot Nothingवास्तव में एक बदसूरत अभिव्यक्ति है (दोहरे नकार के कारण)।

— स्टेफन स्टाइनगर

@steffan "IsNot Nothing" दोहरा निषेध नहीं है। "कुछ भी नहीं एक नकारात्मक नहीं है, यह एक असतत मात्रा है, यहां तक ​​कि प्रोग्रामिंग के दायरे के बाहर भी। "यह मात्रा कुछ भी नहीं है।" व्याकरणिक रूप से, ठीक यही कहना है कि "यह मात्रा शून्य नहीं है।" और न ही एक दोहरी नकारात्मक है।

— जम्बपियानो

ऐसा नहीं है कि मैं यहां सत्य की अनुपस्थिति से असहमत नहीं होना चाहता, लेकिन अभी आता हूं। कुछ भी स्पष्ट नहीं है, ठीक है, अत्यधिक नकारात्मक। क्यों नहीं कुछ सकारात्मक और HasValue की तरह स्पष्ट लिखें? यह एक व्याकरण परीक्षण नहीं है, यह कोडिंग है, जहां मुख्य उद्देश्य स्पष्टता है।

— रैंडी गमेज

jumbpiano: मैं मानता हूँ कि यह दोहरा नकार नहीं है, लेकिन यह एक एकल नकार है और यह लगभग उतना ही बदसूरत है और एक साधारण सकारात्मक अभिव्यक्ति के रूप में स्पष्ट नहीं है।

— केवह हैदरी

Answer 5

यदि आप linq का उपयोग करते हैं और अपने कोड को छोटा रखना चाहते हैं, तो मैं हमेशा उपयोग करने की सलाह देता हूं !=null

और यही कारण है:

आज्ञा देना कल्पना हम कुछ वर्ग है Fooएक साथ नल डबल चरSomeDouble

public class Foo
{
    public double? SomeDouble;
    //some other properties
}   

यदि हमारे कोड में कहीं भी हम सभी को एक अशक्त शून्य के साथ प्राप्त करना चाहते हैं Foo के संग्रह से कुछ डबल मान (संग्रह में कुछ फ़ॉल्स को भी शून्य माना जा सकता है), हम अपने फ़ंक्शन को लिखने के लिए कम से कम तीन तरीके से समाप्त करते हैं (यदि हम उपयोग C # 6):

public IEnumerable<Foo> GetNonNullFoosWithSomeDoubleValues(IEnumerable<Foo> foos)
{
     return foos.Where(foo => foo?.SomeDouble != null);
     return foos.Where(foo=>foo?.SomeDouble.HasValue); // compile time error
     return foos.Where(foo=>foo?.SomeDouble.HasValue == true); 
     return foos.Where(foo=>foo != null && foo.SomeDouble.HasValue); //if we don't use C#6
}

और इस तरह की स्थिति में मैं हमेशा छोटे के लिए जाने की सलाह देता हूं

Comments

हां, foo?.SomeDouble.HasValueउस संदर्भ में एक संकलन-समय की त्रुटि है (मेरी शब्दावली में "फेंक" नहीं) क्योंकि इसका प्रकार है bool?, न कि सिर्फ bool। ( .Whereविधि एक चाहता है Func<Foo, bool>।) यह (foo?.SomeDouble).HasValueनिश्चित रूप से करने की अनुमति है , क्योंकि इसके प्रकार हैं bool। यह वह है जो आपकी पहली पंक्ति आंतरिक रूप से C # संकलक द्वारा (कम से कम औपचारिक रूप से) "अनुवादित" है।

— जेपी स्टिग नील्सन

Answer 6

अंगूठे का सामान्य उत्तर और नियम: यदि आपके पास विकल्प है (जैसे कि कस्टम धारावाहिक लिखना) अशक्त को अलग-अलग पाइपलाइन में संसाधित करने के लिए object- और उनके विशिष्ट गुणों का उपयोग करें - इसे करें और अशक्त विशिष्ट गुणों का उपयोग करें। तो लगातार सोचने के दृष्टिकोण HasValueसे पसंद किया जाना चाहिए। सुसंगत सोच आपको बेहतर कोड लिखने में मदद कर सकती है जो विवरणों में बहुत अधिक समय खर्च नहीं करती है। उदाहरण के लिए दूसरा तरीका कई गुना अधिक प्रभावी होगा (ज्यादातर कंपाइलर इनलाइनिंग और बॉक्सिंग के कारण लेकिन फिर भी संख्या बहुत स्पष्ट है):

public static bool CheckObjectImpl(object o)
{
    return o != null;
}

public static bool CheckNullableImpl<T>(T? o) where T: struct
{
    return o.HasValue;
}

बेंचमार्क परीक्षण:

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT


        Method |  Job | Runtime |       Mean |     Error |    StdDev |        Min |        Max |     Median | Rank |  Gen 0 | Allocated |
-------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:|
   CheckObject |  Clr |     Clr | 80.6416 ns | 1.1983 ns | 1.0622 ns | 79.5528 ns | 83.0417 ns | 80.1797 ns |    3 | 0.0060 |      24 B |
 CheckNullable |  Clr |     Clr |  0.0029 ns | 0.0088 ns | 0.0082 ns |  0.0000 ns |  0.0315 ns |  0.0000 ns |    1 |      - |       0 B |
   CheckObject | Core |    Core | 77.2614 ns | 0.5703 ns | 0.4763 ns | 76.4205 ns | 77.9400 ns | 77.3586 ns |    2 | 0.0060 |      24 B |
 CheckNullable | Core |    Core |  0.0007 ns | 0.0021 ns | 0.0016 ns |  0.0000 ns |  0.0054 ns |  0.0000 ns |    1 |      - |       0 B |

बेंचमार्क कोड:

public class BenchmarkNullableCheck
{
    static int? x = (new Random()).Next();

    public static bool CheckObjectImpl(object o)
    {
        return o != null;
    }

    public static bool CheckNullableImpl<T>(T? o) where T: struct
    {
        return o.HasValue;
    }

    [Benchmark]
    public bool CheckObject()
    {
        return CheckObjectImpl(x);
    }

    [Benchmark]
    public bool CheckNullable()
    {
        return CheckNullableImpl(x);
    }
}

https://github.com/dotnet/BenchmarkDotNet का उपयोग किया गया था

पुनश्च । लोगों का कहना है कि सलाह "सुसंगत सोच के कारण हैसवाल्यू पसंद करते हैं" संबंधित और बेकार नहीं है। क्या आप इसके प्रदर्शन की भविष्यवाणी कर सकते हैं?

public static bool CheckNullableGenericImpl<T>(T? t) where T: struct
{
    return t != null; // or t.HasValue?
}

पीपीएस लोग माइनस जारी रखते हैं लेकिन कोई भी प्रदर्शन की भविष्यवाणी करने की कोशिश नहीं करता है CheckNullableGenericImpl। और वहाँ संकलक आप जगह में मदद नहीं करेगा !=nullसाथ HasValue। HasValueयदि आप प्रदर्शन में रुचि रखते हैं तो इसका सीधा उपयोग किया जाना चाहिए।

Comments

आपके CheckObjectImpl बॉक्स अशक्त हैं object, जबकि CheckNullableImplबॉक्सिंग का उपयोग नहीं करता है। इस प्रकार तुलना बहुत ही निराधार है। न केवल यह किराया नहीं है, यह भी बेकार है, क्योंकि जैसा कि स्वीकार किए गए उत्तर में उल्लेख किया गया है , कंपाइलर वैसे भी फिर से लिखता !=है HasValue।

— जीएसर्ज

पाठक इसकी संरचना की उपेक्षा नहीं करते Nullable<T>, आप इसे (बॉक्सिंग करके object) करते हैं। जब आप != nullबाईं ओर एक अशक्त के साथ आवेदन करते हैं, तो कोई बॉक्सिंग नहीं होता है क्योंकि !=नल के लिए समर्थन संकलक स्तर पर काम करता है। यह अलग है जब आप संकलक से अशक्त को पहले बॉक्सिंग में छिपाते हैं object। CheckObjectImpl(object o)सिद्धांत रूप में न तो आपके बेंचमार्क का कोई मतलब है।

— GSerg

मेरी समस्या यह है कि मुझे इस वेबसाइट पर सामग्री की गुणवत्ता की परवाह है। आपने जो पोस्ट किया है वह या तो भ्रामक है या गलत है। आप ओपी के सवाल का जवाब देने का प्रयास कर रहे हैं, तो आपका जवाब फ्लैट बाहर गलत है, जो की जगह साबित करने के लिए आसान है कॉल करने के लिए CheckObjectImplअपने साथ शरीर के अंदर CheckObject। हालाँकि आपकी नवीनतम टिप्पणियों से पता चलता है कि वास्तव में आपके मन में एक बिल्कुल अलग प्रश्न था जब आपने इस 8 साल पुराने प्रश्न का उत्तर देने का निर्णय लिया, जो मूल प्रश्न के संदर्भ में आपके उत्तर को भ्रामक बनाता है। यह ओपी के बारे में नहीं पूछ रहा था।

— जीसर्ज

अपने आप को अगले आदमी के जूते में रखो जो गुगली करता है what is faster != or HasValue। वह इस सवाल पर आता है, आपके उत्तर के माध्यम से भौंकता है, आपके बेंचमार्क की सराहना करता है और कहता है, "जी, मैं कभी भी उपयोग नहीं करूंगा !=क्योंकि यह स्पष्ट रूप से इतना धीमा है!" यह एक बहुत ही गलत निष्कर्ष है जिसे वह बाद में चारों ओर फैलते हुए आगे बढ़ेगा। इसीलिए मेरा मानना ​​है कि आपका उत्तर हानिकारक है - यह एक गलत प्रश्न का उत्तर देता है और इस तरह अनसुने पाठक में गलत निष्कर्ष निकालता है। विचार करें कि क्या होता है जब आप अपने को बदलने CheckNullableImplके लिए भी हो सकता है return o != null;आप एक ही बेंचमार्क परिणाम मिल जाएगा।

— गॉर्ज

मैं आपके जवाब के साथ बहस कर रहा हूं। आपका उत्तर भ्रामक रूप से ऐसा लगता है जैसे यह बीच का अंतर दिखाता है !=और HasValueजब वास्तव में यह object oऔर के बीच का अंतर दिखाता है T? o। आप मैं क्या सुझाव दिया करते हैं, यह है कि, फिर से लिखने CheckNullableImplके रूप में public static bool CheckNullableImpl<T>(T? o) where T: struct { return o != null; }, आप एक बेंचमार्क के साथ खत्म हो जाएगा कि है कि स्पष्ट रूप से पता चलता है !=है बहुत धीमी गति से !=। जिससे आपको यह निष्कर्ष निकालना चाहिए कि आपके उत्तर का वर्णन करने वाली समस्या !=बनाम के बारे HasValueमें बिल्कुल भी नहीं है।

— GSerg