Convertir un bool nullable? booléen

Comment convertir un annulable bool?à boolen C #?

J'ai essayé x.Valueou x.HasValue...

Vous devez en fin de compte décider de ce que représentera la valeur booléenne nulle. Si cela nulldevrait être false, vous pouvez le faire:

bool newBool = x.HasValue ? x.Value : false;

Ou:

bool newBool = x.HasValue && x.Value;

Ou:

bool newBool = x ?? false;

Vous pouvez utiliser l' opérateur null coalescent : x ?? somethingoù somethingest une valeur booléenne que vous souhaitez utiliser si xest null.

Exemple:

bool? myBool = null;
bool newBool = myBool ?? false;

newBool sera faux.

Vous pouvez utiliser la Nullable{T} GetValueOrDefault()méthode. Cela renverra false si nul.

 bool? nullableBool = null;

 bool actualBool = nullableBool.GetValueOrDefault();

Si vous allez utiliser le bool?dans une ifdéclaration, je trouve que la chose la plus simple à faire est de comparer avec l'un trueou l' autre false.

bool? b = ...;

if (b == true) { Debug.WriteLine("true"; }
if (b == false) { Debug.WriteLine("false"; }
if (b != true) { Debug.WriteLine("false or null"; }
if (b != false) { Debug.WriteLine("true or null"; }

Bien sûr, vous pouvez également comparer avec null.

bool? b = ...;

if (b == null) { Debug.WriteLine("null"; }
if (b != null) { Debug.WriteLine("true or false"; }
if (b.HasValue) { Debug.WriteLine("true or false"; }
//HasValue and != null will ALWAYS return the same value, so use whatever you like.

Si vous allez le convertir en booléen pour le transmettre à d'autres parties de l'application, alors l'opérateur Null Coalesce est ce que vous voulez.

bool? b = ...;
bool b2 = b ?? true; // null becomes true
b2 = b ?? false; // null becomes false

Si vous avez déjà vérifié la valeur null et que vous voulez simplement la valeur, accédez à la propriété Value.

bool? b = ...;
if(b == null)
    throw new ArgumentNullException();
else
    SomeFunc(b.Value);

Le moyen le plus simple consiste à utiliser l'opérateur de fusion nul: ??

bool? x = ...;
if (x ?? true) { 

}

Le ??with nullable values ​​fonctionne en examinant l'expression nullable fournie. Si l'expression Nullable a une valeur, sa valeur sera utilisée sinon elle utilisera l'expression à droite de??

bool? a = null;
bool b = Convert.toBoolean(a); 

Le moyen complet serait:

bool b1;
bool? b2 = ???;
if (b2.HasValue)
   b1 = b2.Value;

Ou vous pouvez tester des valeurs spécifiques en utilisant

bool b3 = (b2 == true); // b2 is true, not false or null

Quelque chose comme:

if (bn.HasValue)
{
  b = bn.Value
}

Cette réponse est pour le cas d'utilisation où vous souhaitez simplement tester le bool?dans une condition. Il peut également être utilisé pour obtenir un résultat normal bool. C'est une alternative que je trouve personnellement plus facile à lire que le coalescing operator ??.

Si vous souhaitez tester une condition, vous pouvez utiliser ceci

bool? nullableBool = someFunction();
if(nullableBool == true)
{
    //Do stuff
}

Ce qui précède ne sera vrai que si le bool?est vrai.

Vous pouvez également l'utiliser pour attribuer un régulier à boolpartir d'unbool?

bool? nullableBool = someFunction();
bool regularBool = nullableBool == true;

la sorcière est la même que

bool? nullableBool = someFunction();
bool regularBool = nullableBool ?? false;

Ceci est une variation intéressante sur le thème. Au premier et au deuxième regard, vous supposeriez que la vraie branche est prise. Pas si!

bool? flag = null;
if (!flag ?? true)
{
    // false branch
}
else
{
    // true branch
}

La façon d'obtenir ce que vous voulez est de faire ceci:

if (!(flag ?? true))
{
    // false branch
}
else
{
    // true branch
}

System.Convert fonctionne très bien par moi.

using System; ... Bool fixed = Convert.ToBoolean(NullableBool);