ต้องการอะไร: Nullable <T> .HasValue หรือ Nullable <T>! = null?

ฉันมักจะใช้Nullable<>.HasValueเพราะฉันชอบความหมาย อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันกำลังทำงานกับ codebase ที่มีอยู่ของคนอื่นซึ่งพวกเขาใช้เป็นNullable<> != nullพิเศษแทน

มีเหตุผลที่จะใช้อย่างใดอย่างหนึ่งมากกว่าอื่น ๆ หรือมันคือการตั้งค่าอย่างหมดจด?

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

เมื่อเทียบกับ

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

คอมไพเลอร์แทนที่การเปรียบเทียบค่า null ด้วยการเรียกHasValueดังนั้นจึงไม่มีความแตกต่างที่แท้จริง เพียงแค่ทำสิ่งใดก็ตามที่สามารถอ่านได้มากขึ้น / ทำให้คุณและเพื่อนร่วมงานของคุณเข้าใจได้ง่ายขึ้น

ฉันชอบ(a != null)เพื่อให้ไวยากรณ์ตรงกับประเภทอ้างอิง

ฉันได้ทำการวิจัยเกี่ยวกับเรื่องนี้โดยใช้วิธีการที่แตกต่างกันเพื่อกำหนดค่าให้กับ int ไม่สามารถ นี่คือสิ่งที่เกิดขึ้นเมื่อฉันทำสิ่งต่าง ๆ ควรชี้แจงสิ่งที่เกิดขึ้น โปรดทราบ: Nullable<something>หรือชวเลขsomething?เป็นโครงสร้างที่คอมไพเลอร์ดูเหมือนว่าจะทำงานมากมายเพื่อให้เราใช้เป็นโมฆะราวกับว่าเป็นคลาส
ดังที่คุณเห็นด้านล่างSomeNullable == nullและSomeNullable.HasValueจะส่งกลับค่าที่คาดหวังจริงหรือเท็จเสมอ แม้ว่าจะไม่ได้แสดงไว้ด้านล่าง แต่SomeNullable == 3ก็ใช้ได้เช่นกัน (สมมติว่า SomeNullable คือ an int?)
ในขณะที่SomeNullable.Valueเราได้รับข้อผิดพลาด runtime ถ้าเราได้รับมอบหมายไปnull SomeNullableในความเป็นจริงในกรณีเดียวที่ nullables อาจทำให้เรามีปัญหาด้วยการรวมกันของผู้ประกอบการมากเกินไป, มากไป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);ด้วย null ที่ส่งผ่านไปยังตัวสร้างจะทำให้เกิดข้อผิดพลาดในการคอมไพล์เนื่องจากค่า VALUE ของวัตถุที่เป็นโมฆะนั้นไม่เป็นโมฆะ มันเป็นเพียงวัตถุห่อหุ้มตัวเองที่สามารถเป็นโมฆะ

ในทำนองเดียวกันเราจะได้รับข้อผิดพลาดในการรวบรวมเวลาจาก:

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

ไม่ต้องพูดถึงว่าval.Valueเป็นคุณสมบัติแบบอ่านอย่างเดียวหมายความว่าเราไม่สามารถใช้สิ่งที่ชอบได้:

val.Value = 3;

แต่อีกครั้งตัวดำเนินการแปลงโดยนัยที่มีมากเกินไปทำให้เรา:

val = 3;

ไม่จำเป็นต้องกังวลเกี่ยวกับ polysomthing whatchamacallits ตราบใดที่มันใช้งานได้ :)

ใน VB.Net อย่าใช้ "IsNot Nothing" เมื่อคุณสามารถใช้ ".HasValue" ฉันเพิ่งแก้ไข "การดำเนินการสามารถเสถียร runtime" ข้อผิดพลาดความน่าเชื่อถือปานกลางโดยแทนที่ "IsNot Nothing" ด้วย ".HasValue" ในที่เดียว ฉันไม่เข้าใจว่าทำไม แต่มีบางสิ่งเกิดขึ้นแตกต่างกันในคอมไพเลอร์ ฉันจะสมมติว่า "! = null" ใน C # อาจมีปัญหาเดียวกัน

หากคุณใช้ linq และต้องการทำให้รหัสของคุณสั้นฉันขอแนะนำให้ใช้เสมอ !=null

และนี่คือเหตุผล:

ลองจินตนาการว่าเรามีคลาสที่Fooมีตัวแปรสองตัวที่ไม่มีค่าได้SomeDouble

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

หากบางแห่งในรหัสของเราเราต้องการให้ Foo ทั้งหมดมีค่าไม่เป็นโมฆะค่า DoubleDouble จากคอลเล็กชันของ Foo (สมมติว่า foos บางอย่างในคอลเลกชันสามารถเป็นโมฆะได้) เราจะจบด้วยวิธีการเขียนฟังก์ชันของเราอย่างน้อยสามวิธี ใช้ 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
}

และในสถานการณ์เช่นนี้ฉันแนะนำให้ไปที่สั้นกว่าเสมอ

คำตอบทั่วไปและกฎง่ายๆ: ถ้าคุณมีตัวเลือก (เช่นเขียน serializers กำหนดเอง) เพื่อประมวลผล Nullable ในไปป์ไลน์ต่าง ๆ กว่า object- และใช้คุณสมบัติเฉพาะ - ทำและใช้คุณสมบัติเฉพาะ Nullable ดังนั้นจากมุมมองการคิดที่สอดคล้องกัน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ถูกนำมาใช้

ปล . ผู้คนพูดว่าคำแนะนำ "ชอบ HasValue เพราะการคิดอย่างต่อเนื่อง" ไม่เกี่ยวข้องและไร้ประโยชน์ คุณสามารถทำนายประสิทธิภาพของสิ่งนี้ได้หรือไม่?

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

PPSคนยังคงลบ CheckNullableGenericImplแต่ไม่มีใครพยายามที่จะคาดการณ์ผลการดำเนินงานของ และมีคอมไพเลอร์จะไม่ได้ช่วยให้คุณเปลี่ยนด้วย!=null ควรใช้โดยตรงหากคุณสนใจในประสิทธิภาพHasValueHasValue