दृश्यों के पीछे एक काम करने योग्य <T> कैसे काम करता है?

Question

मुझे यह जानकर उत्सुकता है कि दृश्यों के पीछे नलबल प्रकार कैसे काम करता है। क्या यह एक नया ऑब्जेक्ट बना रहा है (वस्तुओं को शून्य के असाइन किए जा सकते हैं) शून्य के संभावित मूल्य के साथ?

उदाहरण में हम एक नालीबल <int> का उपयोग करते हैं, क्या किसी ऑब्जेक्ट से किसी इंटरेक्ट में एक अंतर्निहित रूपांतरण होता है और इसके विपरीत जब आप इसे शून्य मान देते हैं?

यह भी मुझे पता है कि इसे मैन्युअल रूप से कैसे बनाया जा सकता है, क्या यह नलटेबल प्रकार का उपयोग करने से एक बेनिफिट है जो इसे स्वयं बनाने के विरोध में है?

Answer 1

नालीबल प्रकार एक संरचना है जिसमें दो फ़ील्ड शामिल हैं: bool और T। जब मान शून्य होता है, तो बूल गलत होता है और टी का डिफ़ॉल्ट मान होता है। जब मान शून्य नहीं होता है, तो बूल सत्य होता है।

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

Answer 2

Nullable<T> को ऐसी संरचना के रूप में कार्यान्वित किया गया है जो Equals() को null के रूप में व्यवहार करने के लिए ओवरराइड करता है यदि HasValuefalse है। T से T? तक एक निहित रूपांतरण है, और !HasValue पर फेंकने वाली दूसरी दिशा में एक स्पष्ट रूपांतरण है।

Answer 3

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

// this 
int? x = null; 
// Transformed to this 
int? x = new Nullable<int>() 

// this 
if (x == null) return; 
// Transformed to this 
if (!x.HasValue) return; 

// this 
if (x == 2) return; 
// Transformed to this 
if (x.GetValueOrDefault() == 2 && x.HasValue) return; 

Answer 4

यहाँ ... (ऊपर tidied) Nullable के खिलाफ नेट परावर्तक चलने से कोड है

[Serializable, StructLayout(LayoutKind.Sequential), TypeDependency("System.Collections.Generic.NullableComparer`1"), TypeDependency("System.Collections.Generic.NullableEqualityComparer`1")] 
public struct Nullable<T> where T: struct 
{ 

private bool hasValue; 
internal T value; 

public Nullable(T value) 
{ 
    this.value = value; 
    this.hasValue = true; 
} 

public bool HasValue 
{ 
    get 
    { 
     return this.hasValue; 
    } 
} 

public T Value 
{ 
    get 
    { 
     if (!this.HasValue) 
     { 
      ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NoValue); 
     } 
     return this.value; 
    } 
} 

public T GetValueOrDefault() 
{ 
    return this.value; 
} 

public T GetValueOrDefault(T defaultValue) 
{ 
    if (!this.HasValue) 
    { 
     return defaultValue; 
    } 
    return this.value; 
} 

public override bool Equals(object other) 
{ 
    if (!this.HasValue) 
    { 
     return (other == null); 
    } 
    if (other == null) 
    { 
     return false; 
    } 
    return this.value.Equals(other); 
} 

public override int GetHashCode() 
{ 
    if (!this.HasValue) 
    { 
     return 0; 
    } 
    return this.value.GetHashCode(); 
} 

public override string ToString() 
{ 
    if (!this.HasValue) 
    { 
     return ""; 
    } 
    return this.value.ToString(); 
} 

public static implicit operator Nullable<T>(T value) 
{ 
    return new Nullable<T>(value); 
} 

public static explicit operator T(Nullable<T> value) 
{ 
    return value.Value; 
} 
}