Manière optimale d'utiliser des opérateurs conditionnels nuls dans les expressions booléennes

Vous écrivez une expression booléenne qui pourrait ressembler à ceci:

team.Category == "A Team" && team?.Manager?.IsVietnamVet

public class Manager
{
    public bool IsVietnamVet { get; set; }
}

public class Team
{
    public string Category { get; set; }

    public Manager Manager { get; set; }
}

... et vous obtenez une erreur:

L'opérateur '&&' ne peut pas être appliqué aux opérandes de type 'bool' et 'bool?'

Quelle est la manière optimale / la plus propre de le gérer?

1. team.Category == "A Team" && (team?.Manager?.IsVietnamVet ?? false)

   Est-ce vraiment lisible?

2. team.Category == "A Team" && (team?.Manager?.IsVietnamVet).GetValueOrDefault()

   Cela peut ne pas fonctionner dans LINQ-to-Entities ...

3. team.Category == "A Team" && team?.Manager?.IsVietnamVet == true

   Souhaitez-vous vraiment écrire if (condition == true)sans aucune hésitation?

Il y a-t-il des alternatives? Est-il finalement préférable d'écrire:

4. team.Category == "A Team" && team.Manager != null && team.Manager.IsVietnamVet

Dans ce cas particulier, il pourrait être judicieux de suivre la loi de Déméter, c'est-à-dire

public class Team
{
    public bool IsManagerVietnamVet => Manager?.IsVietnamVet ?? false;
}    

Plus généralement, si une expression booléenne est complexe ou moche, il n'y a rien à dire que vous ne pouvez pas la diviser (ou une partie) en une instruction distincte:

bool isVietnamVet = Manager?.IsVietnamVet ?? false;

if (team.Category == "A Team" && isVietnamVet)

Lorsque vous parcourez le code dans le débogueur, il est souvent plus agréable d'avoir des conditions élaborées empaquetées en une seule booljuste pour économiser un peu de survol de la souris; en fait, il serait peut-être plus agréable de mettre le tout dans une boolvariable.

bool isVietnamVetAndCategoryA = (team.Category == "A Team"
    && Manager?.IsVietnamVet ?? false);

if (isVietnamVetAndCategoryA)

ou avec LINQ:

var wibble = from flight in airport
             from passenger in flight.manifest
             let isOnPlane = 
                 (flight.FinishedBoarding && passenger.Flight == flight.FlightNumber)
             where !isOnPlane
             select passenger;

Je pense que l' option 3 (c. -à- == true) est la plus propre moyen de test un bool?est true, parce qu'il est très clair sur ce qu'il fait.

Dans la plupart des codes, cela x == truen'a pas de sens, car c'est la même chose que x, mais cela ne s'applique pas ici, donc je pense que == truece ne serait pas très déroutant.

S'étendant sur la réponse de Ben Cottrell, le motif "Null Object" peut vous aider davantage.

Au lieu de renvoyer une nulléquipe / un gestionnaire, extrayez ITeamet IManagerinterfacez et renvoyez des implémentations alternatives significatives:

public class NoManager : IManager
{
    public bool IsVietnamVet => false;
}

public class NoTeam : ITeam
{
    public bool ManagedByVietnamVet => false;

    public IManager Manager => new NoManager();
}

Ensuite, tout d'un coup, vous pouvez le faire en team.ManagedByVietnamVettoute sécurité.

Bien sûr, cela dépend du fournisseur en amont de teampour être null-safe - mais cela peut être assuré avec des tests appropriés.

J'ai écrit une classe simple que vous pourriez utiliser:

 public class MyBool 
    {
        public bool? Value { get; set; }

        public MyBool(bool b)
        {
            Value = b;
        }

        public MyBool(bool? b)
        {
            Value = b;
        }

        public static implicit operator bool(MyBool m)
        {
            return m?.Value ?? false;
        }

        public static implicit operator bool?(MyBool m)
        {
            return m?.Value;
        }

        public static implicit operator MyBool(bool m)
        {
            return new MyBool(m);
        }

        public static implicit operator MyBool(bool? m)
        {
            return new MyBool(m);
        }

        public override string ToString()
        {
            return Value.ToString();
        }
    }

S'il est fiable d'utiliser un type personnalisé, bien sûr. Vous pouvez comparer MyBoolavec les deux boolet Nullable<bool>.