Quel est le ?[]? syntaxe en C #?

Pendant que j'étudiais le délégué qui est en fait une classe abstraite Delegate.cs, j'ai vu la méthode suivante dans laquelle je ne comprends pas

• Pourquoi la valeur de retour utilise-t- ?elle bien qu'elle soit déjà un type de référence ( classe )
• ?[]? signification sur le paramètre

Pourriez-vous expliquer?

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

Explication étape par étape:

params Delegate?[] delegates - C'est un tableau de nullable Delegate

params Delegate?[]? delegates - L'ensemble du tableau peut être nullable

Étant donné que chaque paramètre est du type Delegate?et que vous retournez un index du Delegate?[]?tableau, il est logique que le type de retour soit Delegate?sinon le compilateur retournerait une erreur comme si vous returiez et à intpartir d'une méthode qui renvoie une chaîne.

Vous pouvez par exemple changer votre code pour retourner un Delegatetype comme celui-ci:

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

Les types de référence nullables sont nouveaux dans C # 8.0, ils n'existaient pas auparavant.

C'est une question de documentation et de la façon dont les avertissements sont générés au moment de la compilation.

L'exception «objet non défini sur une instance d'un objet» est une exception courante. Mais il s'agit d'une exception d'exécution, elle peut déjà être partiellement découverte au moment de la compilation.

Pour un réglement, Delegate dvous pouvez toujours appeler

 d.Invoke();

ce qui signifie, vous pouvez le coder, au moment de la compilation, rien ne se passera. Il peut soulever des exceptions lors de l'exécution.

Alors que pour un nouveau Delegate? pcode

 p.Invoke();

produira un avertissement du compilateur. CS8602: Dereference of a possibly null reference sauf si vous écrivez:

 p?.Invoke();

ce qui signifie, appelez uniquement s'il n'est pas nul.

Donc, vous documentez une variable peut contenir null ou non. Il déclenche des avertissements plus tôt et peut éviter plusieurs tests pour null. La même chose que vous avez pour int et int?. Vous savez avec certitude, l'un n'est pas nul - et vous savez comment convertir l'un en l'autre.

En C # 8, il faut explicitement marquer les types de référence comme nullables.

Par défaut, ces types ne peuvent pas contenir null, un peu comme les types de valeur. Bien que cela ne change pas la façon dont les choses fonctionnent sous le capot, le vérificateur de type vous demandera de le faire manuellement.

Le code donné est refactorisé pour fonctionner avec C # 8, mais il ne bénéficie pas de cette nouvelle fonctionnalité.

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

Voici un exemple de code mis à jour (ne fonctionnant pas, juste une idée) exploitant cette fonctionnalité. Cela nous a sauvé d'un contrôle nul et a un peu simplifié cette méthode.

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