Boş birleştirme operatörünün "zıttı" var mı? (… Herhangi bir dilde?)

boş birleştirme kabaca çevirir return x, unless it is null, in which case return y

Sık sık ihtiyacım var return null if x is null, otherwise return x.y

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

Fena değil, ama nullortadaki her zaman beni rahatsız ediyor - gereksiz görünüyor. Şunun gibi bir şeyi tercih ederim return x :: x.y;, takip eden ::şeyin ancak öncekinin değilse değerlendirildiği null.

Bunu boş birleşmenin neredeyse zıttı olarak görüyorum , kısa, satır içi sıfır kontrolüyle karışık bir şekilde, ama C # 'da böyle bir operatör olmadığından [ neredeyse ] eminim.

Böyle bir operatörü olan başka diller var mı? Varsa ne denir?

(Bunun için C # ile bir yöntem yazabileceğimi biliyorum; kullanıyorum return NullOrValue.of(x, () => x.y);, ancak daha iyi bir şeyiniz varsa, onu da görmek isterim.)

Groovy'de boş güvenlikli dereferencing operatörü (?.) Var ... Sanırım peşinde olduğun şey bu.

(Aynı zamanda güvenli navigasyon operatörü olarak da adlandırılır .)

Örneğin:

homePostcode = person?.homeAddress?.postcode

Bu null adlı eğer verecektir person, person.homeAddressya da person.homeAddress.postcodeboş.

(Bu artık C # 6.0'da mevcuttur, ancak önceki sürümlerde yoktur)

Eklemeyi düşündük? C # 4'e. Kesimi yapmadı; bu "sahip olmak güzel" bir özellik, "sahip olunması gereken" bir özellik değil. Bunu dilin gelecekteki varsayımsal versiyonları için tekrar ele alacağız, ama senin yerinde olsam nefesimi beklemem. Zaman geçtikçe daha da önemli hale gelme ihtimali yok. :-)

Özel bir tür kısa devre mantıksal mantığınız varsa, bunu yapabilirsiniz (javascript örneği):

return x && x.y;

Eğer xnull, o zaman değerlendirmek olmaz x.y.

Bunu bir cevap olarak eklemek doğru geldi.

Sanırım C # 'da böyle bir şeyin olmamasının nedeni, birleştirme operatöründen farklı olarak (sadece referans türleri için geçerlidir), ters işlemin bir referans veya değer türü (yani class xüye ile int y- dolayısıyla maalesef birçok durumda kullanılamaz.

Ancak bunu görmek istemediğimi söylemiyorum!

Bu soruna olası bir çözüm, operatörün sağ taraftaki bir değer türü ifadesini otomatik olarak boş değer atanabilir hale getirmesini sağlar. Ama sonra, x.yy'nin int olduğu yerde aslında int?bir acı veren bir döndürme sorunu yaşarsınız.

Başka, muhtemelen daha iyi bir çözüm, operatörün, soldaki ifade boş ise sağ taraftaki tür için varsayılan değeri (yani null veya sıfır) döndürmesidir. Ancak, sıfır / boş değerin gerçekten okunduğu x.yveya güvenli erişim operatörü tarafından sağlanıp sağlanmadığı senaryoları ayırt etme sorunları yaşarsınız .

Delphi, null güvenli olan: (. Yerine) operatörüne sahiptir.

Bir? Eklemeyi düşünüyorlardı. aynı şeyi yapmak için operatör C # 4.0'a, ancak bu kesme bloğunu aldı.

Bu arada, kaşıntı yapan IfNotNull () var. Kesinlikle daha büyük? veya:, ancak üyelerden biri boşsa size bir NullReferenceException oluşturmayacak bir işlem zinciri oluşturmanıza izin verir.

Haskell'de >>operatörü kullanabilirsiniz :

• Nothing >> Nothing dır-dir Nothing
• Nothing >> Just 1 dır-dir Nothing
• Just 2 >> Nothing dır-dir Nothing
• Just 2 >> Just 1 dır-dir Just 1

Haskell var fmap, bence bu durumda eşdeğerdir Data.Maybe.map. Haskell tamamen işlevseldir, yani aradığınız şey

fmap select_y x

Eğer xöyleyse Nothing, bu geri döner Nothing. Eğer xöyleyse Just object, bu geri döner Just (select_y object). Nokta notasyonu kadar güzel değil, ancak işlevsel bir dil olduğu düşünüldüğünde, stiller farklıdır.

PowerShell, null bir başvuruda özelliklere (ancak yöntemleri çağırmayın) başvurmanıza izin verir ve örnek null ise null döndürür. Bunu herhangi bir derinlikte yapabilirsiniz. C # 4'ün dinamik özelliğinin bunu destekleyeceğini ummuştum ama desteklemiyor.

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

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

Güzel değil ama tarif ettiğiniz şekilde işleyecek bir uzatma yöntemi ekleyebilirsiniz.

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; }
}

Dizeler için genellikle bu mantığa ihtiyacım var:

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"

Üyeler için tüm doğru varsayılan değerlere sahip bir yerde sınıfınızın statik bir örneğini oluşturun.

Örneğin:

z = new Thingy { y=null };

o zaman senin yerine

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

Yazabilirsin

return (x ?? z).y;

Bu, C # vNext'te eklenmektedir (Roslyn destekli C #, Visual Studio 2014 sürümleri).

Null yayılımı olarak adlandırılır ve burada tam olarak listelenir. https://roslyn.codeplex.com/wikipage?title=Language%20Feature%20Status

Ayrıca burada eksiksiz olarak listelenmiştir: https://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c

Sözde "boş koşullu işleç", C # 6.0 ve Visual Basic 14'te tanıtılmıştır.
Çoğu durumda, boş birleştirme operatörünün tam tersi olarak kullanılabilir:

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