Parametreleri C # /. NET'te DEĞİL olarak işaretle?

nullC # /. NET'te geçirilmesini engelleyen bir işlev parametresine atayabileceğim basit bir öznitelik veya veri sözleşmesi var mı? İdeal olarak bu, gerçek değerin nullkendisi için herhangi bir yerde ve çalışma zamanı atışında kullanılmadığından emin olmak için derleme zamanında da kontrol eder ArgumentNullException.

Şu anda şöyle bir şey yazıyorum ...

if (null == arg)
  throw new ArgumentNullException("arg");

... olmamasını beklediğim her argüman için null.

Aynı notta, Nullable<>aşağıdakilerin başarısız olacağı bir tersi var mı :

NonNullable<string> s = null; // throw some kind of exception

Maalesef derleme zamanında hiçbir şey mevcut değil.

Son zamanlarda blogumda yayınladığım, yeni bir yapı ve dönüşüm kullanan biraz hacky çözümüm var.

Kod Sözleşmeleri ile .NET 4.0'da hayat çok daha güzel olacak. Gerçek dil sözdizimine sahip olmak ve sıfırlanamazlık konusunda destek almak yine de oldukça güzel olurdu, ancak kod sözleşmeleri çok yardımcı olacaktır.

Ayrıca MiscUtil'de ThrowIfNull adında bir genişletme yöntemim var, bu da onu biraz daha basit hale getiriyor.

Son bir nokta - " if (null == arg)" yerine " " kullanmanızın herhangi bir nedeni var if (arg == null)mı? İkincisini okumayı daha kolay buluyorum ve ilkinin C'de çözdüğü problem C # için geçerli değil.

Bu soruya inanılmaz derecede geç kaldığımı biliyorum, ancak C #'ın en son büyük yinelemesinin piyasaya sürülmeye yaklaşması ve ardından yayınlanmasıyla cevabın alakalı hale geleceğini hissediyorum. C # 8.0'da büyük bir değişiklik olacak, C # tüm türlerin boş olmadığını varsayacaktır .

Mads Torgersen'e göre:

Sorun, boş referansların çok kullanışlı olmasıdır. C # 'da, her başvuru türünün varsayılan değeridirler. Varsayılan değer başka ne olabilir? Siz ona başka ne atayacağınıza karar verene kadar bir değişkenin başka hangi değeri olurdu? Siz onu doldurana kadar, yeni tahsis edilmiş bir referans dizisini başka hangi değeri ortaya koyabiliriz?

Ayrıca bazen boş, kendi başına mantıklı bir değerdir. Bazen, diyelim ki bir alanın bir değeri olmadığı gerçeğini temsil etmek istersiniz. Bir parametre için "hiçbir şey" geçmenin sorun olmadığını. Vurgu bazen üzerindedir. Ve burada sorunun başka bir kısmı yatıyor: C # gibi diller, tam burada bir boşluğun iyi bir fikir olup olmadığını ifade etmenize izin vermez.

Mads tarafından özetlenen çözüm şudur:

1. Bir referansın boş kalmamasını istemenin daha yaygın olduğuna inanıyoruz. Null atanabilir başvuru türleri daha nadir tür olacaktır (ancak bize ne kadar olduğunu söyleyecek iyi verilerimiz olmasa da), bu nedenle yeni bir açıklama gerektirenler bunlar.

2. Dil, null yapılabilir değer türleri için bir nosyon ve sözdizimine zaten sahiptir. İkisi arasındaki benzerlik, dil eklemeyi kavramsal olarak daha kolay ve dilbilimsel olarak daha basit hale getirecektir.

3. İstediğinize aktif olarak karar vermedikçe, kendinize veya tüketicinize hantal boş değerlerle yük olmamanız doğru görünüyor. Null'lar, yokluğu değil, açıkça seçmeniz gereken şey olmalıdır.

İstenen özelliğe bir örnek:

public class Person
{
     public string Name { get; set; } // Not Null
     public string? Address { get; set; } // May be Null
}

Önizleme, Visual Studio 2017, 15.5.4+ önizleme için kullanılabilir.

Bunun ÇOK eski bir soru olduğunu biliyorum, ama bu soru burada eksikti:

ReSharper / Rider kullanıyorsanız, Annotated Framework'ü kullanabilirsiniz .

Düzenleme : Bu cevap için az önce rastgele bir -1 aldım. Bu iyi. Sadece o farkında hala o # 8.0 + projeleri artık C için tavsiye edilen yaklaşım olmadığı halde, geçerli (bkz anlamak için Greg'in cevabı ).

Kurumsal kitaplıktaki doğrulayıcılara göz atın. Şunun gibi bir şey yapabilirsiniz:

private MyType _someVariable = TenantType.None;
[NotNullValidator(MessageTemplate = "Some Variable can not be empty")]
public MyType SomeVariable {
    get {
        return _someVariable;
    }
    set {
        _someVariable = value;
    }
}

Ardından, doğrulamak istediğinizde kodunuzda:

Microsoft.Practices.EnterpriseLibrary.Validation.Validator myValidator = ValidationFactory.CreateValidator<MyClass>();

ValidationResults vrInfo = InternalValidator.Validate(myObject);

en güzeli değil ama:

public static bool ContainsNullParameters(object[] methodParams)
{
     return (from o in methodParams where o == null).Count() > 0;
}

ContainsNullParameters yönteminde de daha yaratıcı olabilirsiniz:

public static bool ContainsNullParameters(Dictionary<string, object> methodParams, out ArgumentNullException containsNullParameters)
       {
            var nullParams = from o in methodParams
                             where o.Value == null
                             select o;

            bool paramsNull = nullParams.Count() > 0;


            if (paramsNull)
            {
                StringBuilder sb = new StringBuilder();
                foreach (var param in nullParams)
                    sb.Append(param.Key + " is null. ");

                containsNullParameters = new ArgumentNullException(sb.ToString());
            }
            else
                containsNullParameters = null;

            return paramsNull;
        }

Tabii ki bir engelleyici veya yansıtma kullanabilirsiniz, ancak bunları takip etmek / kullanmak çok az ek yük ile kolaydır

Tamam bu cevap biraz geç, ama işte bunu nasıl çözüyorum:

public static string Default(this string x)
{
    return x ?? "";
}

Bu uzatma yöntemini kullanın, sonra boş ve boş dizgeyi aynı şey olarak değerlendirebilirsiniz.

Örneğin

if (model.Day.Default() == "")
{
    //.. Do something to handle no Day ..
}

İdeal değil biliyorum, çünkü her yerde varsayılanı aramayı hatırlamanız gerekiyor ama bu bir çözüm.