Rewrite HasValue to the ?? Operators

Is it safe to rewrite the following code:

bool b = foo.bar.HasValue ? foo.bar.Value : false;

to

bool b = foo.bar.Value ?? false;开发者_运维知识库

where bar is the nullable type bool?

---

The easiest fix there is

bool b = foo.bar.GetValueOrDefault();

which is also actually cheaper than .Value as it omits the has-value check. It will default to default(T) , which is indeed false here (it just returns the value of the underlying T field, without any checks at all).

If you need a different default to default(T), then:

var value = yourNullable.GetValueOrDefault(yourPreferredValue);

---

What you want is:

bool b = foo.bar ?? false;

This is (surprisingly) safe and an intended use for the null-coalescing operator.

The ?? operator is called the null-coalescing operator and is used to define a default value for a nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand.

Source: http://msdn.microsoft.com/en-us/library/ms173224.aspx

In the case of Nullable<T>, it is functionally equivalent to Nullable<T>.GetValueOrDefault(T defaultValue).

The code:

bool b = foo.bar.Value ?? false;

Will cause a compiler-error, because you cannot apply the operator to value types, and Nullable<T>.Value always returns a value-type (or throws an exception when there is no value).

---

No - this is not safe.

The line:

bool b = foo.bar.Value ?? false;

will throw an InvalidOperationException if foo.bar has no value.

Instead use

var b = foo.bar ?? false;

---

Update - I just learned about .GetValueOrDefault(); from the other answers - that looks like a very good suggestion to use!

---

Update 2 - @ProgrammingHero's answer is also correct (+1 added!) - the line:

bool b = foo.bar.Value ?? false

actually won't compile - because of Error 50 Operator '??' cannot be applied to operands of type 'bool' and 'bool'

---

Nope.

The Value property returns a value if one is assigned, otherwise a System.InvalidOperationException is thrown.

From: http://msdn.microsoft.com/en-us/library/1t3y8s4s%28v=vs.80%29.aspx

So if hasValue is false then you will get an exception thrown in your second one when you try to run it.

---

ffoo.bar ?? false would be more safer to use

---

bar.Value ?? false

has compilation error, because left operand of ?? operator should be of reference or nullable type.

---

Maybe you have a look at this article in Stackoverflow too - it is an elegant null checking in the style obj.IfNotNull(lambdaExpression) - returning the object you want if obj is not null otherwise just null (but without throwing an exception).

I used it with the Entity Framework if you're accessing a referenced entity, e.g.

var str=Entity1.Entity2.IfNotNull(x=>x.EntityDescription) ?? string.Empty 

which returns EntityDescription contained in Entity2 which is referenced by Entity1 - or an empty string if any object Entity1 or Entity2 is null. Without IfNotNull you would get a long and ugly expression.

The extension method IfNotNull is defined there as follows:

public static TOut IfNotNull<TIn, TOut>(this TIn v, Func<TIn, TOut> f)
    where TIn : class 
    where TOut: class
{
    if (v == null) return null; else return f(v);
}

---

Update: If you update the code to C# version 6.0 (.NET Framework 4.6 - but seems to support older frameworks 4.x too), there is a new operator available which makes this task easy: The "elvis" operator ?..

It works as follows:

var str=(Entity1.Entity2?.EntityDescription) ?? string.Empty 

In this case, if Entity2 is null, evaluation stops and (...) becomes null - after which the ?? string.empty part replaces null by string.Empty. In other words, it works the same way as .IfNotNull(...) would.

---

foo.bar.Value represents the non-nullable value when there is one, and throws an InvalidOperationException if there’s no real value.