Optymalny sposób użycia zerowych operatorów warunkowych w wyrażeniach boolowskich

Piszesz wyrażenie logiczne, które może wyglądać następująco:

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

... i pojawia się błąd:

Operatora „&&” nie można stosować do operandów typu „bool” i „bool?”

Jaki jest optymalny / najczystszy sposób, aby sobie z tym poradzić?

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

   Czy to naprawdę czytelne?

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

   Może nie działać w LINQ-to-Entities ...

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

   Czy naprawdę napisałbyś if (condition == true)bez wahania?

Czy są jakieś inne opcje? Czy ostatecznie lepiej jest napisać:

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

W tym konkretnym przypadku rozsądne może być przestrzeganie Prawa Demetera, tj

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

Mówiąc bardziej ogólnie, jeśli wyrażenie boolowskie jest złożone lub brzydkie, nie ma nic do powiedzenia, że ​​nie można go podzielić (lub jego części) na osobne stwierdzenie:

bool isVietnamVet = Manager?.IsVietnamVet ?? false;

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

Podczas przechodzenia przez kod w debuggerze często fajniej jest mieć rozbudowane warunki spakowane w jeden, boolaby zaoszczędzić trochę najechania kursorem myszy; w rzeczywistości lepiej byłoby umieścić całość w boolzmiennej.

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

if (isVietnamVetAndCategoryA)

lub z LINQ:

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

Myślę, że opcja 3 (tj. == true) Jest najczystszym sposobem sprawdzenia, czy bool?jest true, ponieważ jest bardzo jasne, co robi.

W większości kod x == truenie ma sensu, ponieważ jest taki sam jak x, ale nie dotyczy to tutaj, więc myślę, == trueże nie byłoby to bardzo mylące.

Rozwijając odpowiedź Bena Cottrella, wzór „Null Object” może ci pomóc.

Zamiast zwracać nullzespół / menedżera, wyodrębnij ITeami IManagerinterfejsy oraz zwróć sensowne alternatywne implementacje:

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

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

    public IManager Manager => new NoManager();
}

Nagle możesz to zrobić team.ManagedByVietnamVetbezpiecznie.

To oczywiście zależy od dostawcy, teamktóry ma być zerowo bezpieczny - ale można to zapewnić za pomocą odpowiednich testów.

Napisałem prostą klasę, której możesz użyć:

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

Oczywiście niezawodne jest użycie niestandardowego typu. Możesz porównać MyBoolz obu booli Nullable<bool>.