Quale è ?[]? sintassi in C #?

Mentre studiavo il delegato che in realtà è una classe astratta Delegate.cs, ho visto il seguente metodo in cui non capisco

• Perché il valore restituito utilizza ?sebbene sia già un tipo di riferimento ( classe )
• ?[]? significato sul parametro

Potresti spiegare?

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

Spiegazione dettagliata:

params Delegate?[] delegates - È una matrice di nullable Delegate

params Delegate?[]? delegates - L'intero array può essere nullable

Poiché ogni parametro è del tipo Delegate?e si restituisce un indice Delegate?[]?dell'array, è logico che il tipo restituito sia Delegate?altrimenti il ​​compilatore restituirebbe un errore come se si stesse effettuando la ritrasmissione e intda un metodo che restituisce una stringa.

Ad esempio, è possibile modificare il codice per restituire un Delegatetipo come questo:

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

I tipi di riferimento Nullable sono nuovi in ​​C # 8.0, non esistevano prima.

È una questione di documentazione e di come vengono prodotti gli avvisi in fase di compilazione.

L'eccezione "oggetto non impostato su un'istanza di un oggetto" è un'eccezione comune. Ma questa è un'eccezione di runtime, che può essere parzialmente rilevata al momento della compilazione.

Per un regolamento Delegate dpuoi sempre chiamare

 d.Invoke();

vale a dire, puoi codificarlo, al momento della compilazione non accadrà nulla. Potrebbe sollevare eccezioni in fase di esecuzione.

Mentre per un nuovo Delegate? pquesto codice

 p.Invoke();

produrrà un avviso del compilatore. CS8602: Dereference of a possibly null reference a meno che tu non scriva:

 p?.Invoke();

cosa significa, chiamare solo se non nullo.

Quindi documentate che una variabile può contenere null o no. Genera avvisi in precedenza e può evitare più test per null. Lo stesso che hai per int e int ?. Sai per certo, l'uno non è nullo e sai come convertirlo l'uno nell'altro.

In C # 8 si dovrebbero esplicitamente contrassegnare i tipi di riferimento come nullable.

Per impostazione predefinita, questi tipi non sono in grado di contenere null, un po 'simili ai tipi di valore. Anche se questo non cambia il modo in cui le cose funzionano sotto il cofano, il controllo del tipo ti richiederà di farlo manualmente.

Il codice specificato viene refactored per funzionare con C # 8, ma non beneficia di questa nuova funzionalità.

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

Ecco un esempio di un codice aggiornato (non funzionante, solo un'idea) che sfrutta questa funzionalità. Ci ha salvato da un controllo nullo e ha semplificato un po 'questo metodo.

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