Оптимальный способ использования нулевых условных операторов в булевых выражениях

Вы пишете логическое выражение, которое может выглядеть так:

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

... и вы получите ошибку:

Оператор '&&' нельзя применять к операндам типа 'bool' и 'bool?'

Какой оптимальный / самый чистый способ справиться с этим?

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

   Это действительно читабельно?

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

   Это может не работать в LINQ-to-Entities ...

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

   Вы действительно пишете if (condition == true)без каких-либо колебаний?

Есть ли другие варианты? В конечном итоге лучше написать:

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

В данном конкретном случае было бы целесообразно следовать закону Деметры, т.е.

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

В более общем смысле, если логическое выражение является сложным или уродливым, тогда нечего сказать, что вы не могли бы разделить его (или его часть) на отдельный оператор:

bool isVietnamVet = Manager?.IsVietnamVet ?? false;

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

При пошаговом прохождении кода в отладчике часто бывает лучше, чтобы сложные условия были объединены в один, boolчтобы сэкономить немного при наведении курсора мыши; на самом деле, может быть, лучше поместить все это в boolпеременную.

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

if (isVietnamVetAndCategoryA)

или с LINQ:

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

Я думаю, что вариант 3 (т. Е. == true) Является самым чистым способом проверки того, что bool?есть true, потому что он очень четко понимает, что он делает.

В большинстве случаев код x == trueне имеет смысла, потому что он такой же, как и здесь x, но это не применимо, так что я думаю, что == trueэто не будет очень запутанным.

Продолжая ответ Бена Коттрелла, шаблон «Нулевой объект» может помочь вам в дальнейшем.

Вместо того, чтобы возвращать nullкоманду / менеджера, извлекать ITeamи IManagerвзаимодействовать и возвращать значимые альтернативные реализации:

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

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

    public IManager Manager => new NoManager();
}

Тогда вдруг вы можете сделать это team.ManagedByVietnamVetбезопасно.

Это, конечно, полагается на то, что вышестоящий провайдер teamдолжен быть нулевым, но это может быть обеспечено с помощью соответствующего тестирования.

Я написал простой класс, который вы могли бы использовать:

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

Если надежно использовать пользовательский тип, конечно. Вы можете сравнить MyBoolс обоими boolи Nullable<bool>.