"Simplifier l'expression ternaire conditionnelle"

Tout d'abord, un exemple complet:

class Foo
{
    public bool SomeBool { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var foo = MaybeFoo();

        var bar = foo != null && foo.SomeBool;

    }

    static Foo MaybeFoo()
    {
        return new Random().Next() < 10 ? null : new Foo();
    }
}

Ici MaybeFoo est une méthode qui retourne parfois null et retourne parfois un Foo. J'ai utilisé Random de sorte que R# n'est pas automatiquement que c'est toujours la valeur null ou not null.

Maintenant, comme vous le dites sur cette ligne:

        var bar = foo != null ? foo.SomeBool : false;

R# offre l'inspection Simplifier l'opérateur conditionnel. Que faut-il dire par là? Eh bien, comme d'habitude, on peut Alt+Entrée et accepter la suggestion et de voir ce qu'il veut et de le remplacer avec de l', qui dans ce cas est:

        var bar = foo != null && foo.SomeBool;

Maintenant, à votre préoccupation:

Mais je me sens comme un null est nécessaire de vérifier ici, depuis FirstOrDefault() peut retourner null.

Donc, qui a tort, moi ou Resharper?

Bien, pour le dire en peu de temps, vous l'êtes. Il y a encore une valeur null vérifier qui a lieu ici, et la && de l'opérateur est de court-circuitde sorte que le deuxième opérande (foo.SomeBool) sera évaluée uniquement si le premier est true. Donc il n'y aura pas un NullReferenceException dans le cas où foo est null; la première vérification échoue et bar sera attribué false.

De sorte que les deux lignes

        var bar = foo != null ? foo.SomeBool : false;

et

        var bar = foo != null && foo.SomeBool;

sont sémantiquement équivalentet R# comme d'habitude préfère la version la plus concise (en particulier, explicite trues et falses dans des conditions sont souvent une marque de code redondant). Vous ne pouvez pas, auquel cas, vous pouvez désactiver cette inspection.