C # neden 'boş atmanıza' izin veriyor?

Özellikle karmaşık bir istisna işleme kodu yazarken, birisi sordu, istisna nesnenizin boş olmadığından emin olmanıza gerek yok mu? Ve tabii ki hayır dedim, ama sonra denemeye karar verdim. Görünüşe göre boş atabilirsiniz, ancak yine de bir yerlerde bir istisnaya dönüşüyor.

Buna neden izin veriliyor?

throw null;

Bu pasajda, neyse ki 'eski' boş değil, ama olabilir mi?

try
{
  throw null;
}
catch (Exception ex)
{
  //can ex ever be null?

  //thankfully, it isn't null, but is
  //ex is System.NullReferenceException
}

Çünkü dil belirtimi System.Exceptionorada bir tür ifadesi beklediği için (bu nedenle, nullbu bağlamda geçerlidir) ve bu ifadeyi boş olmayacak şekilde kısıtlamaz. Genel olarak, bu ifadenin değerinin olup olmadığını tespit etmenin bir yolu yoktur null. Durma problemini çözmesi gerekecekti. Çalışma zamanı nullyine de vakayla ilgilenmek zorunda kalacak . Görmek:

Exception ex = null;
if (conditionThatDependsOnSomeInput) 
    ex = new Exception();
throw ex; 

Elbette, nullkelimenin tam anlamıyla geçersiz hale getirme durumlarını geçersiz kılabilirler, ancak bu pek yardımcı olmaz, öyleyse neden spesifikasyon alanını boşa harcayıp tutarlılığı az bir fayda için azaltsın?

_{Feragatname (Eric Lippert tarafından tokatlanmadan önce): Bu, bu tasarım kararının arkasındaki mantıkla ilgili kendi spekülasyonum. Tabii ki tasarım toplantısına katılmadım;)}

İkinci sorunuzun yanıtı, bir catch cümlesinde yakalanan bir ifade değişkeninin boş olup olamayacağı: C # belirtimi, diğer dillerin bir nullistisnanın yayılmasına neden olup olamayacağı konusunda sessiz olsa da, istisnaların yayılma şeklini tanımlar:

Varsa, yakalama cümleleri, istisna için uygun bir işleyiciyi bulmak için görünüm sırasına göre incelenir. İstisna türünü veya istisna türünün temel türünü belirten ilk catch yan tümcesi eşleşme olarak kabul edilir. Genel bir yakalama cümlesi, herhangi bir istisna türü için eşleşme olarak kabul edilir. [...]

Çünkü nullcesur ifade yanlıştır. Bu nedenle, tamamen C # spesifikasyonunun söylediğine bağlı olsa da, temeldeki çalışma zamanının hiçbir zaman boş değer atmayacağını söyleyemeyiz, bu durumda bile, yalnızca genel catch {}cümle tarafından ele alınacağından emin olabiliriz .

CLI üzerindeki C # uygulamaları için ECMA 335 spesifikasyonuna başvurabiliriz. Bu belge, CLI'nin dahili olarak oluşturduğu (hiçbiri olmayan null) tüm istisnaları tanımlar ve kullanıcı tanımlı istisna nesnelerinin throwtalimat tarafından atıldığından bahseder . Bu talimatın açıklaması C # throwifadesiyle hemen hemen aynıdır (nesnenin türünü aşağıdakilerle sınırlamaması dışında System.Exception):

Açıklama:

throwKullanıcı durum nesnesi (tip atar Oyığında) ve yığın boşaltır. İstisna mekanizmasının ayrıntıları için, Bölüm I'e bakın.
[Not: CLI herhangi bir nesnenin atılmasına izin verirken, CLS, dilin birlikte çalışabilirliği için kullanılacak belirli bir istisna sınıfını tanımlar. son not]

İstisnalar:

System.NullReferenceExceptioneğer atılır objolduğunu null.

Doğruluk:

Doğru CIL, nesnenin her zaman ya nullbir nesne referansı (yani tür O) olmasını sağlar.

Bunların yakalanan istisnaların asla olmadığı sonucuna varmak için yeterli olduğuna inanıyorum null.

Görünüşe göre boş atabilirsiniz, ancak yine de bir yerlerde bir istisnaya dönüşüyor.

Bir nullnesneyi atmaya çalışmak (tamamen ilgisiz) bir Boş Referans İstisnası ile sonuçlanır.

Neden fırlatmanıza izin verildiğini nullsormak, neden bunu yapmanıza izin verildiğini sormak gibidir:

object o = null;
o.ToString();

Alındığı burada :

Bu ifadeyi C # kodunuzda kullanırsanız, bir NullReferenceException oluşturur. Bunun nedeni, throw-ifadesinin tek parametresi olarak Exception türünde bir nesneye ihtiyaç duymasıdır. Ama bu çok nesne benim örneğimde boş.

C # 'da null atmak mümkün olmasa da, atış bunu tespit edip bir NullReferenceException'a dönüştüreceğinden, boş almak mümkündür ... Şu anda bunu alıyorum, bu da benim yakalamama neden oluyor 'eski' nin boş olmasını bekliyorum) boş bir referans istisnası yaşaması ve bu da uygulamamın ölmesine neden oluyor (bu son yakalama olduğundan).

Bu nedenle, C # 'dan boş atamasak da, netherworld boş atabilir, bu yüzden en dıştaki yakalama (Exception ex) onu almaya hazırlıklı olun. Sadece bilginize.

Sanırım yapamazsınız - boş atmaya çalıştığınızda bunu yapamazsınız, bu yüzden bir hata durumunda olması gerekeni yapar, bu da boş bir referans istisnası atmaktır. Yani aslında boşluğu atmıyorsunuz, boşu atmıyorsunuz, bu da bir atışla sonuçlanıyor.

"..Neyse ki 'eski', boş değil, ama olabilir mi?" Yanıtını vermeye çalışmak:

Muhtemelen boş olan istisnaları atamayacağımız için, bir catch cümlesinin hiçbir zaman boş olan bir istisnayı yakalamak zorunda kalmayacaktır. Bu nedenle, eski asla boş olamaz.

Şimdi görüyorum ki bu soru aslında zaten sorulmuş .

Bir istisnanın, istisnanın nereye atıldığına dair ayrıntıları içerdiğini unutmayın. Yapıcının nereye fırlatılacağı hakkında hiçbir fikri olmadığı için, bu durumda, yalnızca, atma yönteminin bu ayrıntıları nesneye atma noktasında enjekte etmesi anlamlıdır. Başka bir deyişle, CLR, NullReferenceException'ı tetikleyen null'a veri enjekte etmeye çalışıyor.

Bunun tam olarak olup olmadığından emin değilim, ama olguyu açıklıyor.

Bunun doğru olduğunu varsayarsak (ve ex'i null olarak atmaktan daha iyi bir yol düşünemiyorum;), bu ex'in muhtemelen boş olamayacağı anlamına gelir.

Daha eski c #:

Şu sözdizimini düşünün:

public void Add<T> ( T item ) => throw (hashSet.Add ( item ) ? null : new Exception ( "The item already exists" ));

Sanırım bundan çok daha kısa:

public void Add<T> ( T item )
{
    if (!hashSet.Add ( item ))
        throw new Exception ( "The item already exists" );
}