มี“ ตรงข้าม” กับตัวดำเนินการการรวมกันเป็นโมฆะหรือไม่? (…เป็นภาษาอะไร?)

การรวมกันเป็นโมฆะแปลได้คร่าวๆว่า return x, unless it is null, in which case return y

ฉันมักจะต้องการ return null if x is null, otherwise return x.y

ฉันสามารถใช้ return x == null ? null : x.y;

ไม่เลว แต่nullตรงกลางมักรบกวนฉัน - ดูเหมือนฟุ่มเฟือย ฉันไม่ต้องการสิ่งที่ต้องการreturn x :: x.y;ซึ่งสิ่งที่ตามมาคือการประเมินเฉพาะในกรณีที่สิ่งที่นำหน้ามันไม่ได้เป็น::null

ฉันเห็นว่านี่เกือบจะตรงข้ามกับการรวมกันเป็นโมฆะซึ่งผสมกับ terse, อินไลน์เช็คโมฆะ แต่ฉัน [ เกือบ ] แน่ใจว่าไม่มีตัวดำเนินการดังกล่าวใน C #

มีภาษาอื่นที่มีตัวดำเนินการดังกล่าวหรือไม่? ถ้าเป็นเช่นนั้นเรียกว่าอะไร?

(ฉันรู้ว่าฉันสามารถเขียนวิธีการได้ใน C # ฉันใช้return NullOrValue.of(x, () => x.y);แต่ถ้าคุณมีอะไรที่ดีกว่าฉันก็อยากเห็นเช่นกัน)

มีตัวดำเนินการ dereferencing ที่ปลอดภัยเป็นโมฆะ (?) ใน Groovy ... ฉันคิดว่านั่นคือสิ่งที่คุณต้องการ

(เรียกอีกอย่างว่าตัวดำเนินการนำทางที่ปลอดภัย )

ตัวอย่างเช่น:

homePostcode = person?.homeAddress?.postcode

นี้จะให้ null ถ้าperson, person.homeAddressหรือperson.homeAddress.postcodeเป็นโมฆะ

(ตอนนี้มีให้บริการใน C # 6.0แต่ไม่มีในเวอร์ชันก่อนหน้านี้)

เราถือว่าเพิ่ม?. ถึง C # 4 มันไม่ได้ตัด; เป็นคุณลักษณะที่ "น่ามี" ไม่ใช่คุณลักษณะ "ต้องมี" เราจะพิจารณาอีกครั้งสำหรับภาษาในอนาคตที่สมมุติขึ้น แต่ฉันจะไม่กลั้นหายใจรอถ้าฉันเป็นคุณ ไม่น่าจะมีความสำคัญอีกต่อไปเมื่อเวลาผ่านไป :-)

หากคุณมีตรรกะบูลีนลัดวงจรชนิดพิเศษคุณสามารถทำได้ (ตัวอย่าง javascript):

return x && x.y;

ถ้าเป็นโมฆะแล้วมันจะไม่ได้ประเมินxx.y

มันรู้สึกดีที่จะเพิ่มสิ่งนี้เป็นคำตอบ

ฉันเดาว่าสาเหตุที่ไม่มีสิ่งนี้ใน C # เป็นเพราะไม่เหมือนกับตัวดำเนินการรวมตัวกัน (ซึ่งใช้ได้เฉพาะกับประเภทการอ้างอิงเท่านั้น) การดำเนินการย้อนกลับอาจให้ผลการอ้างอิงหรือประเภทค่า (เช่นclass xกับสมาชิกint y- ดังนั้นจึงน่าเสียดายที่ ใช้ไม่ได้ในหลาย ๆ สถานการณ์

ฉันไม่ได้บอกว่าฉันไม่อยากเห็นมัน!

วิธีแก้ปัญหาที่เป็นไปได้สำหรับตัวดำเนินการจะยกนิพจน์ประเภทค่าทางด้านขวามือให้เป็นค่าว่างโดยอัตโนมัติ แต่คุณมีปัญหาว่าx.yโดยที่ y เป็น int จะส่งกลับ an int?ซึ่งจะเป็นความเจ็บปวด

วิธีแก้ปัญหาอื่นที่น่าจะดีกว่าคือให้ตัวดำเนินการส่งคืนค่าเริ่มต้น (เช่นค่าว่างหรือศูนย์) สำหรับประเภททางด้านขวามือหากนิพจน์ทางด้านซ้ายเป็นโมฆะ แต่คุณมีปัญหาในการแยกแยะสถานการณ์ที่อ่านค่าศูนย์ / ว่างจริงx.yหรือไม่ว่าจะมาจากตัวดำเนินการเข้าถึงปลอดภัยหรือไม่

Delphi มีตัวดำเนินการ: (แทน.) ซึ่งเป็นโมฆะ

พวกเขากำลังคิดที่จะเพิ่ม?. ตัวดำเนินการถึง C # 4.0 เพื่อทำเช่นเดียวกัน แต่มีเขียง

ในระหว่างนี้มี IfNotNull ()ซึ่งเป็นรอยขีดข่วนที่ทำให้คัน มีขนาดใหญ่กว่า?. หรือ: แต่จะช่วยให้คุณสามารถสร้างห่วงโซ่ของการดำเนินการที่จะไม่ทำให้ NullReferenceException มาที่คุณหากสมาชิกคนใดคนหนึ่งเป็นโมฆะ

ใน Haskell คุณสามารถใช้ตัว>>ดำเนินการ:

• Nothing >> Nothing คือ Nothing
• Nothing >> Just 1 คือ Nothing
• Just 2 >> Nothing คือ Nothing
• Just 2 >> Just 1 คือ Just 1

Haskell มีfmapซึ่งในกรณีนี้ฉันคิดว่าเทียบเท่ากับData.Maybe.map. Haskell นั้นใช้งานได้จริงดังนั้นสิ่งที่คุณกำลังมองหาก็คือ

fmap select_y x

หากxเป็นผลตอบแทนนี้Nothing Nothingหากxเป็นผลตอบแทนนี้Just object Just (select_y object)ไม่สวยเท่าสัญกรณ์จุด แต่เนื่องจากเป็นภาษาที่ใช้งานได้สไตล์จึงแตกต่างกัน

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

$x = $null
$result = $x.y  # $result is null

$x = New-Object PSObject
$x | Add-Member NoteProperty y 'test'
$result = $x.y  # $result is 'test'

มันไม่สวย แต่คุณสามารถเพิ่มวิธีการขยายที่จะทำงานตามที่คุณอธิบาย

public static TResult SafeGet<T, TResult>(this T obj, Func<T, TResult> selector) {
    if (obj == null) { return default(TResult); }
    else { return selector(obj); }
}

var myClass = new MyClass();
var result = myClass.SafeGet(x=>x.SomeProp);

public class ok<T> {
    T s;
    public static implicit operator ok<T>(T s) { return new ok<T> { s = s }; }
    public static implicit operator T(ok<T> _) { return _.s; }

    public static bool operator true(ok<T> _) { return _.s != null; }
    public static bool operator false(ok<T> _) { return _.s == null; }
    public static ok<T> operator &(ok<T> x, ok<T> y) { return y; }
}

ฉันมักต้องการตรรกะนี้สำหรับสตริง:

using ok = ok<string>;

...

string bob = null;
string joe = "joe";

string name = (ok)bob && bob.ToUpper();   // name == null, no error thrown
string boss = (ok)joe && joe.ToUpper();   // boss == "JOE"

สร้างอินสแตนซ์แบบคงที่ของชั้นเรียนของคุณที่ใดที่หนึ่งโดยมีค่าเริ่มต้นที่ถูกต้องสำหรับสมาชิก

ตัวอย่างเช่น:

z = new Thingy { y=null };

แล้วแทนที่จะเป็นไฟล์

return x != null ? x.y : null;

คุณสามารถเขียน

return (x ?? z).y;

สิ่งนี้จะถูกเพิ่มใน C # vNext (Roslyn ขับเคลื่อน C # เผยแพร่ด้วย Visual Studio 2014)

เรียกว่าการขยายพันธุ์ Null และแสดงไว้ที่นี่ว่าสมบูรณ์ https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

นอกจากนี้ยังระบุไว้ที่นี่ว่าสมบูรณ์: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

สิ่งที่เรียกว่า "ตัวดำเนินการเงื่อนไขว่าง" ถูกนำมาใช้ใน C # 6.0 และใน Visual Basic 14
ในหลาย ๆ สถานการณ์สามารถใช้เป็นสิ่งที่ตรงกันข้ามกับตัวดำเนินการที่รวมกันเป็นโมฆะ:

int? length = customers?.Length; // null if customers is null   
Customer first = customers?[0];  // null if customers is null  
int? count = customers?[0]?.Orders?.Count();  // null if customers, the first customer, or Orders is null

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators