Optimale Möglichkeit, bedingte Nulloperatoren in booleschen Ausdrücken zu verwenden

Sie schreiben einen booleschen Ausdruck, der folgendermaßen aussehen könnte:

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

... und Sie erhalten eine Fehlermeldung:

Der Operator '&&' kann nicht auf Operanden vom Typ 'bool' und 'bool?'

Was ist der optimale / sauberste Weg, damit umzugehen?

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

   Ist das wirklich lesbar?

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

   In LINQ-to-Entities funktioniert dies möglicherweise nicht ...

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

   Würden Sie wirklich if (condition == true)ohne zu zögern schreiben ?

Gibt es noch andere Möglichkeiten? Ist es letztendlich besser zu schreiben:

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

In diesem speziellen Fall kann es ratsam sein, das Gesetz von Demeter zu befolgen, d. H.

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

Wenn ein boolescher Ausdruck komplex oder hässlich ist, gibt es nichts zu sagen, dass Sie ihn (oder einen Teil davon) nicht in eine separate Anweisung aufteilen können:

bool isVietnamVet = Manager?.IsVietnamVet ?? false;

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

Wenn Sie den Code im Debugger durchgehen, ist es oft besser, ausgefeilte Bedingungen in einer einzigen boolzu packen, um ein wenig Mouseover-Hovering zu vermeiden. In der Tat könnte es einfacher sein, das Ganze in eine boolVariable zu setzen.

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

if (isVietnamVetAndCategoryA)

oder mit LINQ:

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

Ich denke, Option 3 (dh == true) ist der sauberste Weg, um zu testen, ob a bool?ist true, weil es sehr klar ist , was es tut.

In den meisten Fällen x == truemacht Code keinen Sinn, weil es das gleiche ist wie x, aber das gilt hier nicht, also denke ich, == truewäre nicht sehr verwirrend.

Wenn Sie die Antwort von Ben Cottrell erweitern, kann Ihnen das Muster "Null Object" weiterhelfen.

Anstatt ein nullTeam / einen Manager zurückzugeben, extrahieren ITeamund IManagerverbinden Sie und geben Sie sinnvolle alternative Implementierungen zurück:

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

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

    public IManager Manager => new NoManager();
}

Dann können Sie plötzlich team.ManagedByVietnamVetsicher tun .

Dies setzt natürlich voraus, dass der Upstream-Anbieter teamnull-sicher ist - dies kann jedoch durch entsprechende Tests sichergestellt werden.

Ich habe eine einfache Klasse geschrieben, die Sie verwenden können:

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

Wenn es zuverlässig ist, einen benutzerdefinierten Typ zu verwenden, natürlich. Sie können MyBoolmit beiden boolund vergleichen Nullable<bool>.