Nedir ?[]? C # sözdizimi?

Ben ders çalışırken temsilci olan soyut bir sınıf aslında Delegate.cs, ben şu yöntemi hangi anlamıyorum gördü

• Dönüş değeri neden ?zaten bir başvuru ( sınıf ) türü olsa da kullanılıyor?
• ?[]? parametredeki anlam

Açıklayabilir misiniz?

public static Delegate? Combine(params Delegate?[]? delegates)
{
    if (delegates == null || delegates.Length == 0)
        return null;

    Delegate? d = delegates[0];
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

Adım adım açıklama:

params Delegate?[] delegates - Null olabilecek bir dizi Delegate

params Delegate?[]? delegates - Dizinin tamamı boş bırakılabilir

Her parametre türünde olduğundan Delegate?ve Delegate?[]?dizinin bir dizinini döndürdüğünüzden, dönüş türünün başka Delegate?türlü olması mantıklıdır, aksi takdirde derleyici, sanki geri çekiliyormuş gibi ve intbir dize döndüren bir yöntemden bir hata döndürür.

Örneğin, kodunuzu aşağıdaki Delegategibi bir tür döndürecek şekilde değiştirebilirsiniz :

public static Delegate Combine(params Delegate?[]? delegates)
{
    Delegate defaulDelegate = // someDelegate here
    if (delegates == null || delegates.Length == 0)
        return defaulDelegate;

    Delegate d = delegates[0] ?? defaulDelegate;
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

Nullable Reference Türleri C # 8.0'da yenidir, daha önce yoktur.

Bu bir dokümantasyon meselesi ve derleme zamanında uyarıların nasıl üretildiği.

"Nesne bir nesnenin örneğine ayarlanmadı" özel durumu istisnadır. Ancak bu bir çalışma zamanı istisnasıdır, derleme zamanında kısmen keşfedilebilir.

Bir düzenleme Delegate diçin her zaman arayabilirsiniz

 d.Invoke();

yani, kodlayabilirsiniz, derleme zamanında hiçbir şey olmayacak. Çalışma zamanında istisnalar oluşturabilir.

Yeni bir Delegate? pKod için

 p.Invoke();

derleyici uyarısı verir. CS8602: Dereference of a possibly null reference sen yazmadıkça:

 p?.Invoke();

ne demek, sadece boş değilse arayın.

Yani bir değişkenin null içerebileceğini veya içermeyebileceğini belgelersiniz. Uyarıları daha erken artırır ve null için birden fazla testten kaçınabilir. Aynı int ve int için ne var ?. Kesinlikle biliyorsunuz, biri boş değil - ve diğerini nasıl dönüştüreceğinizi biliyorsunuz.

C # 8'de referans türlerini açıkça boş değer olarak işaretlemelisiniz.

Varsayılan olarak, bu türler null türlerini içeremez, bu da değer türlerine benzer. Bu, başlık altında işlerin nasıl çalıştığını değiştirmese de, tip denetleyicisi bunu manuel olarak yapmanızı gerektirir.

Verilen kod C # 8 ile çalışmak için yeniden düzenlenmiştir, ancak bu yeni özellikten faydalanmamaktadır.

public static Delegate? Combine(params Delegate?[]? delegates)
{
    // ...[]? delegates - is not null-safe, so check for null and emptiness
    if (delegates == null || delegates.Length == 0)
        return null;

    // Delegate? d - is not null-safe too
    Delegate? d = delegates[0];
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

İşte bu özellikten yararlanan güncellenmiş bir kod örneği (çalışmıyor, sadece bir fikir). Bizi bir sıfır denetiminden kurtardı ve bu yöntemi biraz basitleştirdi.

public static Delegate? Combine(params Delegate[] delegates)
{
    // `...[] delegates` - is null-safe, so just check if array is empty
    if (delegates.Length == 0) return null;

    // `d` - is null-safe too, since we know for sure `delegates` is both not null and not empty
    Delegate d = delegates[0];

    for (int i = 1; i < delegates.Length; i++)
        // then here is a problem if `Combine` returns nullable
        // probably, we can add some null-checks here OR mark `d` as nullable
        d = Combine(d, delegates[i]);

    return d;
}