Ran across this line of code:
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
What do the two question marks mean, is it some kind of ternary operator? It's hard to look up in Google.
This question is related to
c#
null-coalescing-operator
The answer is
?? is there to provide a value for a nullable type when the value is null. So, if formsAuth is null, it will return new FormsAuthenticationWrapper().
Others have described the Null Coalescing Operator quite well. In cases where a single test for null is required, the shortened syntax ??= can add readability.
Legacy null test:
if (myvariable == null)
{
myvariable = new MyConstructor();
}
Using the Null Coalescing Operator this can be written:
myvariable = myvariable ?? new MyConstructor();
which can also be written with the shortened syntax:
myvariable ??= new MyConstructor();
Some find it more readable and succinct.
coalescing operator
it's equivalent to
FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth
Thanks everybody, here is the most succinct explanation I found on the MSDN site:
// y = x, unless x is null, in which case y = -1.
int y = x ?? -1;
The two question marks (??) indicate that its a Coalescing operator.
Coalescing operator returns the first NON-NULL value from a chain. You can see this youtube video which demonstrates the whole thing practically.
But let me add more to what the video says.
If you see the English meaning of coalescing it says “consolidate together”. For example below is a simple coalescing code which chains four strings.
So if str1 is null it will try str2, if str2 is null it will try str3 and so on until it finds a string with a non-null value.
string final = str1 ?? str2 ?? str3 ?? str4;
In simple words Coalescing operator returns the first NON-NULL value from a chain.
Nothing dangerous about this. In fact, it is beautiful. You can add default value if that is desirable, for example:
CODE
int x = x1 ?? x2 ?? x3 ?? x4 ?? 0;
It's the null coalescing operator.
http://msdn.microsoft.com/en-us/library/ms173224.aspx
Yes, nearly impossible to search for unless you know what it's called! :-)
EDIT: And this is a cool feature from another question. You can chain them.
Just because no-one else has said the magic words yet: it's the null coalescing operator. It's defined in section 7.12 of the C# 3.0 language specification.
It's very handy, particularly because of the way it works when it's used multiple times in an expression. An expression of the form:
a ?? b ?? c ?? d
will give the result of expression a if it's non-null, otherwise try b, otherwise try c, otherwise try d. It short-circuits at every point.
Also, if the type of d is non-nullable, the type of the whole expression is non-nullable too.
It's the null coalescing operator.
http://msdn.microsoft.com/en-us/library/ms173224.aspx
Yes, nearly impossible to search for unless you know what it's called! :-)
EDIT: And this is a cool feature from another question. You can chain them.
Some of the examples here of getting values using coalescing are inefficient.
What you really want is:
return _formsAuthWrapper = _formsAuthWrapper ?? new FormsAuthenticationWrapper();
or
return _formsAuthWrapper ?? (_formsAuthWrapper = new FormsAuthenticationWrapper());
This prevents the object from being recreated every time. Instead of the private variable remaining null and a new object getting created on every request, this ensures the private variable is assigned if the new object is created.
For your amusement only (knowing you are all C# guys ;-).
I think it originated in Smalltalk, where it has been around for many years. It is defined there as:
in Object:
? anArgument
^ self
in UndefinedObject (aka nil's class):
? anArgument
^ anArgument
There are both evaluating (?) and non-evaluating versions (??) of this.
It is often found in getter-methods for lazy-initialized private (instance) variables, which are left nil until really needed.
Just because no-one else has said the magic words yet: it's the null coalescing operator. It's defined in section 7.12 of the C# 3.0 language specification.
It's very handy, particularly because of the way it works when it's used multiple times in an expression. An expression of the form:
a ?? b ?? c ?? d
will give the result of expression a if it's non-null, otherwise try b, otherwise try c, otherwise try d. It short-circuits at every point.
Also, if the type of d is non-nullable, the type of the whole expression is non-nullable too.
For your amusement only (knowing you are all C# guys ;-).
I think it originated in Smalltalk, where it has been around for many years. It is defined there as:
in Object:
? anArgument
^ self
in UndefinedObject (aka nil's class):
? anArgument
^ anArgument
There are both evaluating (?) and non-evaluating versions (??) of this.
It is often found in getter-methods for lazy-initialized private (instance) variables, which are left nil until really needed.
Just because no-one else has said the magic words yet: it's the null coalescing operator. It's defined in section 7.12 of the C# 3.0 language specification.
It's very handy, particularly because of the way it works when it's used multiple times in an expression. An expression of the form:
a ?? b ?? c ?? d
will give the result of expression a if it's non-null, otherwise try b, otherwise try c, otherwise try d. It short-circuits at every point.
Also, if the type of d is non-nullable, the type of the whole expression is non-nullable too.
Just because no-one else has said the magic words yet: it's the null coalescing operator. It's defined in section 7.12 of the C# 3.0 language specification.
It's very handy, particularly because of the way it works when it's used multiple times in an expression. An expression of the form:
a ?? b ?? c ?? d
will give the result of expression a if it's non-null, otherwise try b, otherwise try c, otherwise try d. It short-circuits at every point.
Also, if the type of d is non-nullable, the type of the whole expression is non-nullable too.
?? is there to provide a value for a nullable type when the value is null. So, if formsAuth is null, it will return new FormsAuthenticationWrapper().
Thanks everybody, here is the most succinct explanation I found on the MSDN site:
// y = x, unless x is null, in which case y = -1.
int y = x ?? -1;
The two question marks (??) indicate that its a Coalescing operator.
Coalescing operator returns the first NON-NULL value from a chain. You can see this youtube video which demonstrates the whole thing practically.
But let me add more to what the video says.
If you see the English meaning of coalescing it says “consolidate together”. For example below is a simple coalescing code which chains four strings.
So if str1 is null it will try str2, if str2 is null it will try str3 and so on until it finds a string with a non-null value.
string final = str1 ?? str2 ?? str3 ?? str4;
In simple words Coalescing operator returns the first NON-NULL value from a chain.
coalescing operator
it's equivalent to
FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth
Some of the examples here of getting values using coalescing are inefficient.
What you really want is:
return _formsAuthWrapper = _formsAuthWrapper ?? new FormsAuthenticationWrapper();
or
return _formsAuthWrapper ?? (_formsAuthWrapper = new FormsAuthenticationWrapper());
This prevents the object from being recreated every time. Instead of the private variable remaining null and a new object getting created on every request, this ensures the private variable is assigned if the new object is created.
If you're familiar with Ruby, its ||= seems akin to C#'s ?? to me. Here's some Ruby:
irb(main):001:0> str1 = nil
=> nil
irb(main):002:0> str1 ||= "new value"
=> "new value"
irb(main):003:0> str2 = "old value"
=> "old value"
irb(main):004:0> str2 ||= "another new value"
=> "old value"
irb(main):005:0> str1
=> "new value"
irb(main):006:0> str2
=> "old value"
And in C#:
string str1 = null;
str1 = str1 ?? "new value";
string str2 = "old value";
str2 = str2 ?? "another new value";
The ?? operator is called the null-coalescing operator. It returns the left-hand operand if the operand is not null; otherwise it returns the right hand operand.
int? variable1 = null;
int variable2 = variable1 ?? 100;
Set variable2 to the value of variable1, if variable1 is NOT null;
otherwise, if variable1 == null, set variable2 to 100.
As correctly pointed in numerous answers that is the "null coalescing operator" (??), speaking of which you might also want to check out its cousin the "Null-conditional Operator" (?. or ?[) that is an operator that many times it is used in conjunction with ??
Used to test for null before performing a member access (?.) or index (?[) operation. These operators help you write less code to handle null checks, especially for descending into data structures.
For example:
// if 'customers' or 'Order' property or 'Price' property is null,
// dollarAmount will be 0
// otherwise dollarAmount will be equal to 'customers.Order.Price'
int dollarAmount = customers?.Order?.Price ?? 0;
the old way without ?. and ?? of doing this is
int dollarAmount = customers != null
&& customers.Order!=null
&& customers.Order.Price!=null
? customers.Order.Price : 0;
which is more verbose and cumbersome.
coalescing operator
it's equivalent to
FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth
It's short hand for the ternary operator.
FormsAuth = (formsAuth != null) ? formsAuth : new FormsAuthenticationWrapper();
Or for those who don't do ternary:
if (formsAuth != null)
{
FormsAuth = formsAuth;
}
else
{
FormsAuth = new FormsAuthenticationWrapper();
}
For your amusement only (knowing you are all C# guys ;-).
I think it originated in Smalltalk, where it has been around for many years. It is defined there as:
in Object:
? anArgument
^ self
in UndefinedObject (aka nil's class):
? anArgument
^ anArgument
There are both evaluating (?) and non-evaluating versions (??) of this.
It is often found in getter-methods for lazy-initialized private (instance) variables, which are left nil until really needed.
?? is there to provide a value for a nullable type when the value is null. So, if formsAuth is null, it will return new FormsAuthenticationWrapper().
It's short hand for the ternary operator.
FormsAuth = (formsAuth != null) ? formsAuth : new FormsAuthenticationWrapper();
Or for those who don't do ternary:
if (formsAuth != null)
{
FormsAuth = formsAuth;
}
else
{
FormsAuth = new FormsAuthenticationWrapper();
}
Thanks everybody, here is the most succinct explanation I found on the MSDN site:
// y = x, unless x is null, in which case y = -1.
int y = x ?? -1;
If you're familiar with Ruby, its ||= seems akin to C#'s ?? to me. Here's some Ruby:
irb(main):001:0> str1 = nil
=> nil
irb(main):002:0> str1 ||= "new value"
=> "new value"
irb(main):003:0> str2 = "old value"
=> "old value"
irb(main):004:0> str2 ||= "another new value"
=> "old value"
irb(main):005:0> str1
=> "new value"
irb(main):006:0> str2
=> "old value"
And in C#:
string str1 = null;
str1 = str1 ?? "new value";
string str2 = "old value";
str2 = str2 ?? "another new value";
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
is equivalent to
FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();
But the cool thing about it is you can chain them, like other people said. The one thin not touched upon is that you can actually use it to throw an exception.
A = A ?? B ?? throw new Exception("A and B are both NULL");
It's the null coalescing operator.
http://msdn.microsoft.com/en-us/library/ms173224.aspx
Yes, nearly impossible to search for unless you know what it's called! :-)
EDIT: And this is a cool feature from another question. You can chain them.
Others have described the Null Coalescing Operator quite well. In cases where a single test for null is required, the shortened syntax ??= can add readability.
Legacy null test:
if (myvariable == null)
{
myvariable = new MyConstructor();
}
Using the Null Coalescing Operator this can be written:
myvariable = myvariable ?? new MyConstructor();
which can also be written with the shortened syntax:
myvariable ??= new MyConstructor();
Some find it more readable and succinct.
?? is there to provide a value for a nullable type when the value is null. So, if formsAuth is null, it will return new FormsAuthenticationWrapper().
It's a null coalescing operator that works similarly to a ternary operator.
a ?? b => a !=null ? a : b
Another interesting point for this is, "A nullable type can contain a value, or it can be undefined". So if you try to assign a nullable value type to a non-nullable value type you will get a compile-time error.
int? x = null; // x is nullable value type
int z = 0; // z is non-nullable value type
z = x; // compile error will be there.
So to do that using ?? operator:
z = x ?? 1; // with ?? operator there are no issues
coalescing operator
it's equivalent to
FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth
For your amusement only (knowing you are all C# guys ;-).
I think it originated in Smalltalk, where it has been around for many years. It is defined there as:
in Object:
? anArgument
^ self
in UndefinedObject (aka nil's class):
? anArgument
^ anArgument
There are both evaluating (?) and non-evaluating versions (??) of this.
It is often found in getter-methods for lazy-initialized private (instance) variables, which are left nil until really needed.
It's the null coalescing operator.
http://msdn.microsoft.com/en-us/library/ms173224.aspx
Yes, nearly impossible to search for unless you know what it's called! :-)
EDIT: And this is a cool feature from another question. You can chain them.
Note:
I have read whole this thread and many others but I can't find as thorough answer as this is.
By which I completely understood the "why to use ?? and when to use ?? and how to use ??."
Source:
Windows communication foundation unleashed By Craig McMurtry ISBN 0-672-32948-4
Nullable Value Types
There are two common circumstances in which one would like to know whether a value has been assigned to an instance of a value type. The first is when the instance represents a value in a database. In such a case, one would like to be able to examine the instance to ascertain whether a value is indeed present in the database. The other circumstance, which is more pertinent to the subject matter of this book, is when the instance represents a data item received from some remote source. Again, one would like to determine from the instance whether a value for that data item was received.
The .NET Framework 2.0 incorporates a generic type definition that provides for cases like these in which one wants to assign null to an instance of a value type, and test whether the value of the instance is null. That generic type definition is System.Nullable<T>, which constrains the generic type arguments that may be substituted for T to value types.
Instances of types constructed from System.Nullable<T> can be assigned a value of null; indeed, their values are null by default. Thus, types constructed from
System.Nullable<T> may be referred to as nullable value types.
System.Nullable<T> has a property, Value, by which the value assigned to an instance of
a type constructed from it can be obtained if the value of the instance is not null.
Therefore, one can write:
System.Nullable<int> myNullableInteger = null;
myNullableInteger = 1;
if (myNullableInteger != null)
{
Console.WriteLine(myNullableInteger.Value);
}
The C# programming language provides an abbreviated syntax for declaring types
constructed from System.Nullable<T>. That syntax allows one to abbreviate:
System.Nullable<int> myNullableInteger;
to
int? myNullableInteger;
The compiler will prevent one from attempting to assign the value of a nullable value type to an ordinary value type in this way:
int? myNullableInteger = null;
int myInteger = myNullableInteger;
It prevents one from doing so because the nullable value type could have the value null, which it actually would have in this case, and that value cannot be assigned to an ordinary value type. Although the compiler would permit this code,
int? myNullableInteger = null;
int myInteger = myNullableInteger.Value;
The second statement would cause an exception to be thrown because any attempt to
access the System.Nullable<T>.Value property is an invalid operation if the type
constructed from System.Nullable<T> has not been assigned a valid value of T, which has not happened in this case.
Conclusion:
One proper way to assign the value of a nullable value type to an ordinary value type is to use the System.Nullable<T>.HasValue property to ascertain whether a valid value of T has been assigned to the nullable value type:
int? myNullableInteger = null;
if (myNullableInteger.HasValue)
{
int myInteger = myNullableInteger.Value;
}
Another option is to use this syntax:
int? myNullableInteger = null;
int myInteger = myNullableInteger ?? -1;
By which the ordinary integer myInteger is assigned the value of the nullable integer "myNullableInteger" if the latter has been assigned a valid integer value; otherwise, myInteger is assigned the value of -1.
As correctly pointed in numerous answers that is the "null coalescing operator" (??), speaking of which you might also want to check out its cousin the "Null-conditional Operator" (?. or ?[) that is an operator that many times it is used in conjunction with ??
Used to test for null before performing a member access (?.) or index (?[) operation. These operators help you write less code to handle null checks, especially for descending into data structures.
For example:
// if 'customers' or 'Order' property or 'Price' property is null,
// dollarAmount will be 0
// otherwise dollarAmount will be equal to 'customers.Order.Price'
int dollarAmount = customers?.Order?.Price ?? 0;
the old way without ?. and ?? of doing this is
int dollarAmount = customers != null
&& customers.Order!=null
&& customers.Order.Price!=null
? customers.Order.Price : 0;
which is more verbose and cumbersome.
Note:
I have read whole this thread and many others but I can't find as thorough answer as this is.
By which I completely understood the "why to use ?? and when to use ?? and how to use ??."
Source:
Windows communication foundation unleashed By Craig McMurtry ISBN 0-672-32948-4
Nullable Value Types
There are two common circumstances in which one would like to know whether a value has been assigned to an instance of a value type. The first is when the instance represents a value in a database. In such a case, one would like to be able to examine the instance to ascertain whether a value is indeed present in the database. The other circumstance, which is more pertinent to the subject matter of this book, is when the instance represents a data item received from some remote source. Again, one would like to determine from the instance whether a value for that data item was received.
The .NET Framework 2.0 incorporates a generic type definition that provides for cases like these in which one wants to assign null to an instance of a value type, and test whether the value of the instance is null. That generic type definition is System.Nullable<T>, which constrains the generic type arguments that may be substituted for T to value types.
Instances of types constructed from System.Nullable<T> can be assigned a value of null; indeed, their values are null by default. Thus, types constructed from
System.Nullable<T> may be referred to as nullable value types.
System.Nullable<T> has a property, Value, by which the value assigned to an instance of
a type constructed from it can be obtained if the value of the instance is not null.
Therefore, one can write:
System.Nullable<int> myNullableInteger = null;
myNullableInteger = 1;
if (myNullableInteger != null)
{
Console.WriteLine(myNullableInteger.Value);
}
The C# programming language provides an abbreviated syntax for declaring types
constructed from System.Nullable<T>. That syntax allows one to abbreviate:
System.Nullable<int> myNullableInteger;
to
int? myNullableInteger;
The compiler will prevent one from attempting to assign the value of a nullable value type to an ordinary value type in this way:
int? myNullableInteger = null;
int myInteger = myNullableInteger;
It prevents one from doing so because the nullable value type could have the value null, which it actually would have in this case, and that value cannot be assigned to an ordinary value type. Although the compiler would permit this code,
int? myNullableInteger = null;
int myInteger = myNullableInteger.Value;
The second statement would cause an exception to be thrown because any attempt to
access the System.Nullable<T>.Value property is an invalid operation if the type
constructed from System.Nullable<T> has not been assigned a valid value of T, which has not happened in this case.
Conclusion:
One proper way to assign the value of a nullable value type to an ordinary value type is to use the System.Nullable<T>.HasValue property to ascertain whether a valid value of T has been assigned to the nullable value type:
int? myNullableInteger = null;
if (myNullableInteger.HasValue)
{
int myInteger = myNullableInteger.Value;
}
Another option is to use this syntax:
int? myNullableInteger = null;
int myInteger = myNullableInteger ?? -1;
By which the ordinary integer myInteger is assigned the value of the nullable integer "myNullableInteger" if the latter has been assigned a valid integer value; otherwise, myInteger is assigned the value of -1.
The ?? operator is called the null-coalescing operator. It returns the left-hand operand if the operand is not null; otherwise it returns the right hand operand.
int? variable1 = null;
int variable2 = variable1 ?? 100;
Set variable2 to the value of variable1, if variable1 is NOT null;
otherwise, if variable1 == null, set variable2 to 100.
It's a null coalescing operator that works similarly to a ternary operator.
a ?? b => a !=null ? a : b
Another interesting point for this is, "A nullable type can contain a value, or it can be undefined". So if you try to assign a nullable value type to a non-nullable value type you will get a compile-time error.
int? x = null; // x is nullable value type
int z = 0; // z is non-nullable value type
z = x; // compile error will be there.
So to do that using ?? operator:
z = x ?? 1; // with ?? operator there are no issues
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
is equivalent to
FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();
But the cool thing about it is you can chain them, like other people said. The one thin not touched upon is that you can actually use it to throw an exception.
A = A ?? B ?? throw new Exception("A and B are both NULL");
It's short hand for the ternary operator.
FormsAuth = (formsAuth != null) ? formsAuth : new FormsAuthenticationWrapper();
Or for those who don't do ternary:
if (formsAuth != null)
{
FormsAuth = formsAuth;
}
else
{
FormsAuth = new FormsAuthenticationWrapper();
}
Nothing dangerous about this. In fact, it is beautiful. You can add default value if that is desirable, for example:
CODE
int x = x1 ?? x2 ?? x3 ?? x4 ?? 0;
Source: Stackoverflow.com