正确区分布尔？ 和C＃中的bool

Question

I am trying to find out if a variable is either a simple bool or a Nullable<bool> .

It seems that

if(val is Nullable<bool>)

returns true for both bool and Nullable<bool> variables and

if(val is bool)

also returns true for both bool and Nullable<bool> .

Basically, I am interesting in finding out if a simple bool variable is true OR if a Nullable<bool> variable is not null .

What's the way to do this?

Here is the full code:

List<string> values = typeof(InstViewModel).GetProperties()
                          .Where(prop => prop != "SubCollection" && prop != "ID" && prop != "Name" && prop != "Level")
                          .Select(prop => prop.GetValue(ivm, null))
                          .Where(val => val != null && (val.GetType() != typeof(bool) || (bool)val == true))      //here I'm trying to check if val is bool and true or if bool? and not null
                          .Select(val => val.ToString())
                          .Where(str => str.Length > 0)
                          .ToList();

The InstViewModel object:

 public class InstViewModel
    {
        public string SubCollection { get; set; }
        public string ID { get; set; }
        public string Name { get; set; }
        public string Level { get; set; }
        public bool Uk { get; set; }
        public bool Eu { get; set; }
        public bool Os { get; set; }
        public Nullable<bool> Mobiles { get; set; }
        public Nullable<bool> Landlines { get; set; }
        public Nullable<bool> UkNrs { get; set; }
        public Nullable<bool> IntNrs { get; set; }
}

The point of my code here is to find out if all of the object's values are null (more specifically, to find out any values that are not null and save them in a List<string> ). This presents a complication in the lambda expression, however, when trying to distinguish between bool and bool? types in my object (second Where statement).

Additionally, since the object contains some string types as well, I am trying to exclude those in my first .Where statement (which I am probably not doing right at present as it doesn't seem to be working). But my main goal is to distinguish between bool and bool? types.

Answer 1

There is a simple way to check whether a variable is declared as T or T? :

private static bool IsNullable<T>(T val)
{
    return false;
}

private static bool IsNullable<T>(T? val)
    where T : struct
{
    return true;
}

Usage:

bool? val = false;

if (IsNullable(val))
{
    ...
}

EDIT
Try the following code for edited question:

var boolProps = typeof (InstViewModel).GetProperties()
    .Where(prop => prop.PropertyType == typeof(bool))
    .Select(prop => (bool)prop.GetValue(ivm, null))
    .Select(v => v ? v.ToString() : String.Empty);

var nullableBoolProps = typeof(InstViewModel).GetProperties()
    .Where(prop => prop.PropertyType == typeof(bool?))
    .Select(prop => (bool?)prop.GetValue(ivm, null))
    .Select(v => v.HasValue ? v.ToString() : String.Empty);

List<string> values = boolProps.Concat(nullableBoolProps)
              .Where(str => str.Length != 0)
              .ToList();

Answer 2

Code for getting class instance values:

// create class instance
InstViewModel model = new InstViewModel()
{
    Uk = true,
    UkNrs = false,
};

// check all boolean fields are false or null
bool isAllNullOrFalse = (from property in typeof(InstViewModel).GetProperties()
                         let type = property.PropertyType
                         let isBool = type == typeof(bool)
                         where isBool || type == typeof(bool?)
                         let value = property.GetValue(model)
                         select value == null || (isBool && bool.Equals(value, false))).All(e => e);

Console.WriteLine("All values are null or false = {0}", isAllNullOrFalse);

Answer 3

typeof(InstViewModel).GetProperties()
  .Select(prop => prop.GetValue(ivm, null))

At this point, you have a sequence of type object . Each element of that sequence will be an object that can be one of:

1. An instance of a reference type.
2. A boxed instance of a value type.
3. null .

The null case can happen either because you had a null value for a property which was of reference type, or a null value for a property that was a nullable value type; there's no way to tell the difference at here. Likewise there's no way to tell the difference between a boxed bool that came from a bool value or a boxed bool that came from a bool? value.

You need to examine the type of the property, not the property's value:

isNullableProperty = property.PropertyType.IsGenericType
  && property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>);

But to just filter to only bool and bool? then:

typeof(InstViewModel).GetProperties()
  .Where(
     prop => prop.PropertyType == typeof(bool)
     || prop.PropertyType == typeof(bool?))

Answer 4

You can distinguish the boolean and nullable boolean properties before you evaluate them. Then there is no need to worry about whether they evaluate to a bool or a Nullable<bool> :

var nullableBooleanProperties = typeof(InstViewModel).Where(prop => prop.PropertyType == typeof(bool?));

Then you can simply write these out to a list of strings:

var values = nullableBooleanProperties.Select(prop => prop.GetValue(ivm)).Where(val => val != null).Select(val => val.ToString());

Putting these together gives:

var values = typeof(InstViewModel).Where(prop => prop.PropertyType == typeof(bool?))
    .Select(prop => prop.GetValue(ivm)).Where(val => val != null)
    .Select(val => val.ToString())
    .ToList();

which gives you the list you are looking for.

Answer 5

This is a response to the initial question - ignore this.

When you "box" a nullable value (so you put it in an object ), it is transformed in its underlying type ( bool in your case) or in null ... So if you have

bool? value = true;
object value2 = value; 

now value2.GetType() == typeof(bool)

Answer 6

According to your question

Basically, I am interest ed in finding out if a simple bool variable is true OR if a Nullable variable is not null.

• to tell if a simple boolVariable is true

    if(boolVariable){ //bool variable, not nullable } 

• to tell if your nullableVariable is not null

    if(nullableVariable.HasValue){ //a nullable variable is not null } 

• to tell if nullable bool variable is true or/and not null, use the ?? operator

   if(variable??false){ //then I'm sure that this is not null and has value=true } 

So in definitive you can use the following code for both nullable bool and bool variables

     if(variables!=null &&variables!=false){/*This may give a warning message but it works*/}

or

   if(((bool?)variable)??false){
      /*variable is not null and is true*/
    }

Answer 7

Try this:

((bool?)val).HasValue

This will return true , if val is a bool or if val is a bool? which value is not null .

On the other hand,

!((bool?)val).HasValue

will only return true if val is bool? and its value is null .

Will not that test suffice in your case?

Answer 8

Try this

List<string> values = typeof(InstViewModel).GetProperties()
    .Select(prop => new { N = prop.Name, T = prop.PropertyType, V = prop.GetValue(ivm, null) })
    .Where(prop => prop.N != "SubCollection" && prop.N != "ID" && prop.N != "Name" && prop.N != "Level")
    .Where(val => (val.V != null && val.T.IsAssignableFrom(typeof(Nullable<bool>))) || Convert.ToBoolean(val.V))                    
    .Select(val => val.V.ToString())
    .Where(str => str.Length > 0)
    .ToList();