ตัวดำเนินการรวมคุณสมบัติสำหรับ C #

ตัวดำเนินการรวมค่า null ใน c # อนุญาตให้คุณย่อรหัสได้

  if (_mywidget == null)
     return new Widget();
  else
     return _mywidget;

ลงไป:

  return _mywidget ?? new Widget();

ฉันพบว่าตัวดำเนินการที่มีประโยชน์ที่ฉันต้องการใน C # จะเป็นอันที่อนุญาตให้คุณส่งคืนคุณสมบัติของวัตถุหรือค่าอื่น ๆ ถ้าวัตถุนั้นเป็นโมฆะ ดังนั้นฉันต้องการแทนที่

  if (_mywidget == null)
     return 5;
  else
     return _mywidget.Length;

ด้วย:

  return _mywidget.Length ??! 5;

ฉันอดไม่ได้ที่จะคิดว่าต้องมีเหตุผลบางอย่างที่ผู้ดำเนินการรายนี้จะไม่มีอยู่จริง มันเป็นกลิ่นรหัสหรือไม่? มีวิธีที่ดีกว่าในการเขียนนี้หรือไม่? (ฉันรู้ถึงรูปแบบวัตถุ null แต่ดูเหมือนว่าจะใช้เกินขีดเพื่อแทนที่รหัสสี่บรรทัดนี้)

ฉันต้องการคุณลักษณะภาษา C # ที่ช่วยให้ฉันทำอย่างปลอดภัย x.Prop.SomeOtherProp.ThirdProp โดยไม่ต้องตรวจสอบแต่ละรายการสำหรับ null ใน codebase เดียวที่ฉันต้องทำ "traversals คุณสมบัติลึก" เหล่านั้นมากมายฉันเขียนวิธีการขยายที่เรียกว่า Navigate ที่กลืนกิน NullReferenceExceptions และกลับเป็นค่าเริ่มต้นแทน ดังนั้นฉันสามารถทำสิ่งนี้:

var propVal = myThing.Navigate(x => x.PropOne.PropTwo.PropThree.PropFour, defaultValue);

ข้อเสียของเรื่องนี้คือมันมีกลิ่นรหัสที่แตกต่าง: ข้อยกเว้นกลืน หากคุณต้องการทำสิ่งนี้ "ถูกต้อง" คุณสามารถใช้ lamdba เป็นนิพจน์และแก้ไขนิพจน์ได้ทันทีเพื่อเพิ่มการตรวจสอบ null รอบ ๆ ตัวเข้าถึงคุณสมบัติแต่ละรายการ ฉันไปเพื่อ "รวดเร็วและสกปรก" และไม่ได้ใช้วิธีนี้ "ดีกว่า" แต่บางทีเมื่อฉันมีความคิดบางอย่างรอบฉันจะกลับมาอีกครั้งและโพสต์ไว้ที่ใดที่หนึ่ง

หากต้องการตอบคำถามของคุณเพิ่มเติมโดยตรงฉันคาดเดาว่านี่ไม่ใช่คุณสมบัติเนื่องจากค่าใช้จ่ายในการใช้คุณลักษณะนั้นเกินประโยชน์จากการมีคุณลักษณะ ทีม C # ต้องเลือกและเลือกคุณสมบัติที่จะมุ่งเน้นและสิ่งนี้ยังไม่ได้ลอยไปด้านบน แค่เดาว่าฉันจะไม่มีข้อมูลวงใน

ฉันเชื่อว่าคุณสามารถทำได้ด้วย C # 6 ในตอนนี้:

return _mywidget?.Length ?? 5;

สังเกตผู้ประกอบการที่มีเงื่อนไข?.ด้านซ้าย _mywidget?.Lengthผลตอบแทนที่เป็นโมฆะถ้า_mywidgetเป็นโมฆะ

ผู้ประกอบการที่ง่าย ๆ อาจจะอ่านง่ายกว่า แต่อย่างที่คนอื่น ๆ แนะนำ

เป็นเพียงการคาดเดาว่าทำไมพวกเขาไม่ทำ ท้ายที่สุดฉันไม่เชื่อ ?? อยู่ในรุ่น C # แรก

ต่อไปฉันจะใช้โอเปอเรเตอร์ที่มีเงื่อนไขและเรียกมันต่อวัน:

return (_mywidget != null) ? _mywidget.Length : 5;

?? เป็นเพียงทางลัดไปยังผู้ดำเนินการตามเงื่อนไข

ดูเหมือนว่าผู้ประกอบการที่สาม:

return (_mywidget != NULL) ? _mywidget : new Widget();

โดยส่วนตัวฉันคิดว่ามันอ่านไม่ออก ในตัวอย่างแรกการ??แปลค่อนข้างดีว่า "คุณอยู่ที่นั่นหรือไม่ไม่ลองทำสิ่งนี้"

ในตัวอย่างที่สอง??!เห็นได้ชัดว่าเป็น WTF และไม่มีความหมายต่อโปรแกรมเมอร์ ... ไม่มีวัตถุดังนั้นฉันจึงไม่สามารถรับทรัพย์สินได้ดังนั้นฉันจะส่งคืน 5. สิ่งนี้หมายความว่าอย่างไร 5 คืออะไร เราจะสรุปได้อย่างไรว่า 5 เป็นคุณค่าที่ดี?

ในระยะสั้นตัวอย่างแรกทำให้รู้สึก ... ไม่ได้มีใหม่มัน ในวินาทีมันเปิดให้อภิปราย

ฉันคิดว่าผู้คนกำลังติดอยู่ใน "5" ที่คุณกลับมา ... บางที 0 น่าจะดีกว่า :)

อย่างไรก็ตามฉันคิดว่าปัญหาคือว่า??!มันไม่ได้เป็นผู้ประกอบการแบบสแตนด์อโลน พิจารณาสิ่งนี้หมายความว่า:

var s = myString ??! "";

ในกรณีนั้นมันไม่มีเหตุผล: มันสมเหตุสมผลถ้าตัวถูกดำเนินการทางด้านซ้ายเป็นตัวเข้าถึงคุณสมบัติ หรือเกี่ยวกับสิ่งนี้:

var s = Foo(myWidget.Length) ??! 0;

มีคุณสมบัติในการเข้าถึงมี แต่ฉันยังคงไม่คิดว่ามันจะทำให้ความรู้สึก (ถ้าmyWidgetเป็นnullหมายความว่าเราไม่ได้โทรFoo()เลย?) หรือนี้เป็นเพียงข้อผิดพลาด?

ฉันคิดว่าปัญหาคือมันไม่เหมาะกับภาษาตาม??ปกติ

มีคนสร้างคลาสยูทิลิตี้ที่จะทำเพื่อคุณ แต่ฉันหามันไม่เจอ สิ่งที่ฉันพบคือสิ่งที่คล้ายกันในฟอรัม MSDN (ดูคำตอบที่สอง)

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

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

ตัวอย่างเช่นคุณมีวัตถุที่ผูกไว้กับแผนที่และคุณต้องการให้วัตถุอยู่ในระดับความสูงที่เหมาะสม แผนที่ DTED สามารถมีช่องว่างในข้อมูลได้ดังนั้นจึงเป็นไปได้ที่จะมีค่า Null รวมถึงค่าในช่วงของบางอย่างเช่น -100 ถึง ~ 8900 เมตร คุณอาจต้องการบางสิ่งบางอย่างตาม:

mapObject.Altitude = mapObject.Coordinates.DtedAltitude ?? DEFAULT_ALTITUDE;

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

ฉันเห็นว่ามันมีค่ามาก แต่การคาดเดาของฉันว่าทำไมมันไม่ได้ทำนั้น จำกัด อยู่ที่ความซับซ้อนของคอมไพเลอร์ อาจมีบางกรณีที่พฤติกรรมจะไม่สามารถคาดเดาได้

เมื่อไม่ได้จัดการกับที่ซ้อนกันอย่างลึกล้ำฉันได้ใช้สิ่งนี้ (ก่อนโอเปอเรเตอร์การรวมตัวเป็นโมฆะที่แนะนำใน C # 6) สำหรับฉันมันค่อนข้างชัดเจน แต่อาจเป็นเพราะฉันชินกับมันคนอื่นอาจรู้สึกสับสน

return ( _mywidget ?? new MyWidget() {length = defaultLength}).Length;

แน่นอนว่าสิ่งนี้ไม่สามารถใช้ได้เสมอไปเนื่องจากบางครั้งคุณสมบัติที่คุณต้องใช้ในการเข้าถึงไม่สามารถตั้งค่าได้โดยตรงหรือเมื่อการก่อสร้างวัตถุมีราคาแพงด้วยเหตุผลอื่น

อีกทางเลือกหนึ่งคือการใช้รูปแบบ NullObject คุณกำหนดอินสแตนซ์แบบคงที่เดียวของคลาสด้วยค่าเริ่มต้นที่สมเหตุสมผลและใช้แทน

return ( _mywidget ?? myWidget.NullInstance).Length;

หมายเลขเวทย์มนตร์มักมีกลิ่นเหม็น หาก 5 คือหมายเลขโดยพลการมันจะเป็นการดีกว่าที่จะสะกดเพื่อให้เอกสารชัดเจนยิ่งขึ้น ข้อยกเว้นในความเห็นของฉันคือถ้าคุณมีการรวบรวมค่าซึ่งทำหน้าที่เป็นค่าเริ่มต้นในบริบทเฉพาะ

หากคุณมีชุดค่าเริ่มต้นสำหรับวัตถุคุณสามารถ subclass เพื่อสร้างอินสแตนซ์ซิงเกิลเริ่มต้น

สิ่งที่ต้องการ: return (myobj ?? default_obj) ความยาว

โดยปกติคุณสมบัติความยาวเป็นประเภทค่าจึงไม่สามารถเป็นค่าว่างได้ดังนั้นตัวดำเนินการรวมค่าว่างจึงไม่สมเหตุสมผล

แต่คุณสามารถทำได้ด้วยคุณสมบัติที่เป็นประเภทการอ้างอิงตัวอย่างเช่น: var window = App.Current.MainWindow ?? new Window();

ฉันเคยเห็นใครบางคนที่มีแนวคิดคล้ายกันมาก่อน แต่ส่วนใหญ่คุณจะต้องการกำหนดค่าใหม่ให้กับเขตข้อมูล null เช่น:

return _obj ?? (_obj = new Class());

ดังนั้นแนวคิดก็คือการรวม??และการ=มอบหมายเข้ากับ:

return _obj ??= new Class();

ฉันคิดว่านี่เหมาะสมกว่าใช้เครื่องหมายอัศเจรีย์

ความคิดนี้ไม่ใช่ของฉัน แต่ฉันชอบมันมาก :)