----------
20201123

摘要:
1. ?,  條件運算子 condition ? consequent : alternative
若 (條件 condition) 成立, 則為 (結果 consequent), 否則為 (替代 alternative)
double sinc(double x) => x != 0.0 ? Math.Sin(x) / x : 1; // 若 (x != 0.0), 則回傳(Math.Sin(x) / x), 否則回傳1.

2. ??, Null合併運算子 null-coalescing operator
    a ?? backup; // 若(a非null), 則回傳a, 否則回傳 backup, 
	常用:
            // use coalesce expression
            //return Int32.Parse(value == null ? string.Empty : value, CultureInfo.CurrentCulture);
            return Int32.Parse(value ?? string.Empty, CultureInfo.CurrentCulture);
	或:
            _reader = reader ?? throw new ArgumentNullException("reader");


3. ??=, Null合併設定運算子 null-coalescing assignment operator
Available in C# 8.0 and later, the null-coalescing assignment operator ??= assigns the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null. The ??= operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.
從C# 8.0 開始提供, 若(??=)左邊運算結果為null, 則以右邊的運算結果回傳.
List<int> numbers = null;
int? a = null;

(numbers ??= new List<int>()).Add(5); // 若 numbers 為 null, 則設定為 new List<int>()).Add(5)


條件運算子
condition ? consequent : alternative
The conditional operator ?:, commonly known as the ternary conditional operator, evaluates a Boolean expression, and returns the result of evaluating one of two expressions, depending on whether the Boolean expression evaluates to true or false.
The condition expression must evaluate to true or false. If condition evaluates to true, the consequent expression is evaluated, and its result becomes the result of the operation. If condition evaluates to false, the alternative expression is evaluated, and its result becomes the result of the operation. Only consequent or alternative is evaluated.
若 (條件 condition) 成立, 則為 (結果 consequent), 否則為 (替代 alternative)

The conditional operator is right-associative, that is, an expression of the form
a ? b : c ? d : e
is evaluated as
a ? b : (c ? d : e)
條件運算式以右邊優先運算.

The following example demonstrates the usage of the conditional operator:
double sinc(double x) => x != 0.0 ? Math.Sin(x) / x : 1;

Console.WriteLine(sinc(0.1));
Console.WriteLine(sinc(0.0));
// Output:
// 0.998334166468282
// 1


Conditional ref expression
condition ? ref consequent : ref alternative
Beginning with C# 7.2, you can use the conditional ref expression to return the reference to the result of one of the two expressions. You can assign that reference to a ref local or ref readonly local variable, or use it as a reference return value or as a ref method parameter.
C# 7.2 (.net 4.7.1 或 visual studio 2017) 開始提供 (條件參考運算)

Like the original conditional operator, the conditional ref expression evaluates only one of the two expressions: either consequent or alternative.
In the case of the conditional ref expression, the type of consequent and alternative must be the same.
The following example demonstrates the usage of the conditional ref expression:
var smallArray = new int[] { 1, 2, 3, 4, 5 };
var largeArray = new int[] { 10, 20, 30, 40, 50 };

int index = 7;
ref int refValue = ref ((index < 5) ? ref smallArray[index] : ref largeArray[index - 5]);
refValue = 0;

index = 2;
((index < 5) ? ref smallArray[index] : ref largeArray[index - 5]) = 100;

Console.WriteLine(string.Join(" ", smallArray));
Console.WriteLine(string.Join(" ", largeArray));
// Output:
// 1 2 100 4 5
// 10 20 0 40 50

Null 運算子
?. and ?[], Elvis operator, Null-conditional operators ?. and ?[]
Available in C# 6 and later, a null-conditional operator applies a member access, ?., or element access, ?[], operation to its operand only if that operand evaluates to non-null. If the operand evaluates to null, the result of applying the operator is null. The null-conditional member access operator ?. is also known as the Elvis operator.
The null-conditional operators are short-circuiting. That is, if one operation in a chain of conditional member or element access operations returns null, the rest of the chain doesn't execute. In the following example, B is not evaluated if A evaluates to null and C is not evaluated if A or B evaluates to null:
A?.B?.Do(C);
A?.B?[C];
C# 6 (.net 4.5.2 或 Visual studio 2015) 開始提供 Null 運算子 (?. and ?[] 成員運算子)
Null 運算子 為 短路 方式: 若前面的運算結果為null, 則不會執行後面的運算.

The following example demonstrates the usage of the ?. and ?[] operators:

double SumNumbers(List<double[]> setsOfNumbers, int indexOfSetToSum)
{
    return setsOfNumbers?[indexOfSetToSum]?.Sum() ?? double.NaN;
}

var sum1 = SumNumbers(null, 0);
Console.WriteLine(sum1);  // output: NaN

var numberSets = new List<double[]>
{
    new[] { 1.0, 2.0, 3.0 },
    null
};

var sum2 = SumNumbers(numberSets, 0);
Console.WriteLine(sum2);  // output: 6

var sum3 = SumNumbers(numberSets, 1);
Console.WriteLine(sum3);  // output: NaN

The preceding example also shows the usage of the null-coalescing operator. You might use the null-coalescing operator to provide an alternative expression to evaluate in case the result of the null-conditional operation is null.



Null合併運算子
?? null-coalescing operator ??

The null-coalescing operator ?? returns the value of its left-hand operand if it isn't null; otherwise, it evaluates the right-hand operand and returns its result. The ?? operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.
若 (??) 運算子左邊運算結果非null有值, 則回傳, 否則以右邊的運算結果回傳, 不論右邊運算結果是否為null.


Available in C# 8.0 and later, the null-coalescing assignment operator ??= assigns the value of its right-hand operand to its left-hand operand only if the left-hand operand evaluates to null. The ??= operator doesn't evaluate its right-hand operand if the left-hand operand evaluates to non-null.
從C# 8.0 開始提供, 若(??=)左邊運算結果為null, 則以右邊的運算結果回傳.
List<int> numbers = null;
int? a = null;

(numbers ??= new List<int>()).Add(5); // 若 numbers 為 null, 則設定為 new List<int>()).Add(5)
Console.WriteLine(string.Join(" ", numbers));  // output: 5

numbers.Add(a ??= 0);
Console.WriteLine(string.Join(" ", numbers));  // output: 5 0
Console.WriteLine(a);  // output: 0

In C# 7.3 and earlier, the type of the left-hand operand of the ?? operator must be either a reference type or a nullable value type. Beginning with C# 8.0, that requirement is replaced with the following: the type of the left-hand operand of the ?? and ??= operators cannot be a non-nullable value type. In particular, you can use the null-coalescing operators with unconstrained type parameters in C# 8.0 and later:
private static void Display<T>(T a, T backup)
{
    Console.WriteLine(a ?? backup); // 若 a非null, 則回傳a, 否則回傳 backup.
}

The null-coalescing operators are right-associative. That is, expressions of the form

a ?? b ?? c
d ??= e ??= f

are evaluated as
a ?? (b ?? c)
d ??= (e ??= f)



The ?? and ??= operators can be useful in the following scenarios:

In expressions with the null-conditional operators ?. and ?[], you can use the null-coalescing operator to provide an alternative expression to evaluate in case the result of the expression with null-conditional operations is null:

double SumNumbers(List<double[]> setsOfNumbers, int indexOfSetToSum)
{
    return setsOfNumbers?[indexOfSetToSum]?.Sum() ?? double.NaN;
}

var sum = SumNumbers(null, 0);
Console.WriteLine(sum);  // output: NaN


When you work with nullable value types and need to provide a value of an underlying value type, use the null-coalescing operator to specify the value to provide in case a nullable type value is null:

int? a = null;
int b = a ?? -1;
Console.WriteLine(b);  // output: -1


Use the Nullable<T>.GetValueOrDefault() method if the value to be used when a nullable type value is null should be the default value of the underlying value type.


Starting with C# 7.0, you can use a throw expression as the right-hand operand of the null-coalescing operator to make the argument-checking code more concise:


public string Name
{
    get => name;
    set => name = value ?? throw new ArgumentNullException(nameof(value), "Name cannot be null");
}


Starting with C# 8.0, you can use the ??= operator to replace the code of the form
if (variable is null)
{
    variable = expression;
}

with the following code:
variable ??= expression;



----------
Sample1:
if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;
s = x != 0.0 ? Math.Sin(x)/x : 1.0;

----------------------------------------------------------------------------
The conditional operator is right-associative, so an expression of the form
a ? b : c ? d : e

is evaluated as
a ? b : (c ? d : e)

not
(a ? b : c) ? d : e

----------------------------------------------------------------------------
// cs_operator_conditional.cs
using System;
class MainClass
{
    static double sinc(double x) 
    {
        return x != 0.0 ? Math.Sin(x)/x : 1.0;
    }

    static void Main() 
    {
        Console.WriteLine(sinc(0.2));
        Console.WriteLine(sinc(0.1));
        Console.WriteLine(sinc(0.0));
    }
}

output:
0.993346653975306
0.998334166468282
1