From: 011netservice@gmail.com Date: 2023-07-08 Subject: null-coalecing.txt 章節 #### 快速摘要 #### Resolve nullable warnings, 解除 null 警告. #### Nullable reference types #### 20200707 摘要: #### 其餘慢慢看下面: #### 20191227 ?? 還有？= 運算子（C#參考） #### null #### null class 歡迎來信交流, 訂購軟體需求. 以下 #### 標記段落, **** 標記常用(流程、設定、備忘) #### 快速摘要 本段落以(ZObject.cs 之快速摘要)內容為準, 並存放於 null-coalecing.txt 20230708 □ null null 關鍵字是表示不參考任何物件之 Null 參考的常值。 null 是參考型別變數的預設值。 一般實值型別 (Value Type) 不可以為 null。 □ Null-conditional operators (條件運算子) 語法: condition ? consequent : alternative; // CodeHelper ? Null-conditional operators, 若(condition)為 True, 則回傳(consequent), 否則回傳(alternative) 例: bool bResult = (iInput == 1) ? true : false; int iResult = bResult ? 1 : 0; string sResult = bResult ? "Yes" : "No"; □ Null-conditional operators member access (使用於成員的條件運算子) 語法: o1?.action; // CodeHelper ? Null-conditional operators member access, 若(o1 為 null), 則沒影響, 否則執行 o1.action. 語法: o2 = o1?.member; // CodeHelper ? Null-conditional operators member access, 若(o1 為 null), 則沒影響, 否則 o2 = o1.member. 常用1: object?.Dispose() OnDisconnect?.Invoke(State1); 可取代 if (object != null) object.Dispose(); if (OnDisconnect != null) OnDisconnect(State); 常用2: public string MFileName { get { return MConnectionString?.Filename; } } // CodeHelper ? Null-conditional operators member access, 若(MConnectionString 為 null), 則回傳原值 MFileName, 否則回傳 MConnectionString.Filename. public XmlElement MRoot => MDocument?.ZGetRootElement(); // CodeHelper ? Null-conditional operators member access. // 取代 public XmlElement MRoot { get { return MDocument?.ZGetRootElement(); } } public static XmlElement ZGetRootElement(this XmlDocument PXmlDocument) { return PXmlDocument?.DocumentElement; // CodeHelper ? Null-conditional operators member access, 若(PXmlDocument 為 null), 則回傳 null, 否則回傳 PXmlDocument.Name. } public static string ZGetRootName(this XmlDocument PXmlDocument) { return PXmlDocument.ZGetRootElement()?.Name; // CodeHelper ? Null-conditional operators member access, 若(ZGetRootElement() 為 null), 則回傳 null, 否則回傳 ZGetRootElement().Name. } □ null-coalescing operator ?? (null 合併運算子) 語法: ReturnRightIfLeftIsNull = Left ?? Right; // CodeHelper ?? null-coalescing operator, 若(Left)為 null, 則回傳(Right), 否則回傳(Left). 例: int? a = null; int b = a ?? -1; 常用: 若a為null, 則設定為-1, 否則為設定為 b. Console.WriteLine(b); // output: -1 可取代 if (a is null) b = -1; else b = a; 或 Me = new HttpClient(handler1 ?? CreateHttpClientHandler(), bDisposeHandler); 或 object o1 = ... oValue = o1 ?? throw ZException.Empty($"HttpContext.Current.Session[{sName}]"); arg1?.Foo(); myField = arg2 ?? throw new ArgumentNullException(nameof(arg2)); 常用: 若參數為 null, 則拋出 ArgumentNullException arg3 = arg3 ?? throw new ArgumentNullException(nameof(arg3)); 常用: 若參數為 null, 則拋出 ArgumentNullException 可取代 if (o1 == null) throw ZException.Empty($"HttpContext.Current.Session[{sName}]"); else oValue = o1; 常用 coalescing expression 可簡化以下語法: return Left == null ? Right : Left; // 若(Left == null), 則為Right, 否則為Left. 簡化如下: return Left ?? Right; // 若(Left有值), 則為Left, 否則為Right. □ null-coalescing assignment operator (Null 聯合指派運算子) 語法: variable ??= expression; // CodeHelper ??= null-coalescing assignment operator, 若 variable 為 null, 則 variable=expression, 否則沒影響. 可取代 if (variable is null) variable = expression; □ (int?) 是 Nullable型別, 可允許存放 null 到(原本無法存放 null 的型別)中. int? a = null; // CodeHelper ? Nullable data type. □ (?? operator) and (??= null-coalescing assignment operator) ?? and ??= operators - the null-coalescing operators ref: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-coalescing-operator?f1url=%3FappId%3DDev16IDEF1%26l%3DEN-US%26k%3Dk(%253F%253F%253D_CSharpKeyword)%3Bk(DevLang-csharp)%26rd%3Dtrue ?? operator left ?? right; // 若 left 為 null, 則取 right, 否則取 left 值. int b = a ?? -1; // 若 a 為 null, 則取 -1, 否則取 a 值. 可簡化 property 設定: public string Name { get => name; set => name = value ?? throw new ArgumentNullException(nameof(value), "Name cannot be null"); } ??= null-coalescing assignment operator variable ??= expression; // 若 variable 為 null 則設定為 expression, 否則為原 variable 值 int b = a ??= -1; // 若 a 為 null 則設定為 -1, 否則為原a值 可取代以下語法: if (variable is null) { variable = expression; } 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. 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. List numbers = null; int? a = null; Console.WriteLine((numbers is null)); // expected: true // if numbers is null, initialize it. Then, add 5 to numbers (numbers ??= new List()).Add(5); Console.WriteLine(string.Join(" ", numbers)); // output: 5 Console.WriteLine((numbers is null)); // expected: false Console.WriteLine((a is null)); // expected: true Console.WriteLine((a ?? 3)); // expected: 3 since a is still null // if a is null then assign 0 to a and add a to the list numbers.Add(a ??= 0); Console.WriteLine((a is null)); // expected: false Console.WriteLine(string.Join(" ", numbers)); // output: 5 0 Console.WriteLine(a); // output: 0 The left-hand operand of the ??= operator must be a variable, a property, or an indexer element. The type of the left-hand operand of the ?? and ??= operators can't be a non-nullable value type. In particular, you can use the null-coalescing operators with unconstrained type parameters: private static void Display(T a, T backup) { Console.WriteLine(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 ?? operator to provide an alternative expression to evaluate in case the result of the expression with null-conditional operations is null: double SumNumbers(List 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 ?? 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.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. You can use a throw expression as the right-hand operand of the ?? 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"); } The preceding example also demonstrates how to use expression-bodied members to define a property. You can use the ??= operator to replace the code of the form if (variable is null) { variable = expression; } with the following code: variable ??= expression; □ Nullable reference types: 若碰到 Warning CS8632 The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. 這是因為 預設 Nullable References 語法和編譯警告都是關閉的（disabled）, 但是從 .NET 6 開始, 預設已改為 enabled. By default, nullable annotation and warning contexts are disabled. That means that your existing code compiles without changes and without generating any new warnings. Beginning with .NET 6, new projects include the element in all project templates. enable 開啟 enable: 1. 整個專案開啟: 例如: netstandard2.0;net6.0 enable 2. 個別區塊中開啟 #nullable enable #nullable disable #### Resolve nullable warnings, 解除 null 警告. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/nullable-warnings?f1url=%3FappId%3Droslyn%26k%3Dk(CS8601) The purpose of nullable warnings is to minimize the chance that your application throws a System.NullReferenceException when run. To achieve this goal, the compiler uses static analysis and issues warnings when your code has constructs that may lead to null reference exceptions. You provide the compiler with information for its static analysis by applying type annotations and attributes. These annotations and attributes describe the nullability of arguments, parameters, and members of your types. In this article, you'll learn different techniques to address the nullable warnings the compiler generates from its static analysis. The techniques described here are for general C# code. Learn to work with nullable reference types and Entity Framework core in Working with nullable reference types. 常用方法解除 nullable warnings: You'll address almost all warnings using one of four techniques: □ Adding necessary null checks. □ Adding ? or ! nullable annotations. ? = nullable variable. 變數可存 null. 例如: public List? States { get; set; } ! = null forgiving operator. 忽略警告 null. 例如: Console.WriteLine(message!.Length); 例如: public static string? ZToString(this object? PValue, string? PDefault = null) { if (PValue.ZIsNullOrDBNull()) return PDefault; return PValue!.ToString(); // 忽略警告 null. } □ Adding attributes that describe null semantics. □ Initializing variables correctly. Possible dereference of null This set of warnings alerts you that you're dereferencing a variable whose null-state is maybe-null. These warnings are: CS8602 - Dereference of a possibly null reference. CS8670 - Object or collection initializer implicitly dereferences possibly null member. The following code demonstrates one example of each of the preceding warnings: class Container { public List? States { get; set; } // 可存 null. } internal void PossibleDereferenceNullExamples(string? message) // 可傳 null. { Console.WriteLine(message.Length); // CS8602 var c = new Container { States = { "Red", "Yellow", "Green" } }; // CS8670 } In the example above, the warning is because the Container, c, may have a null value for the States property. Assigning new states to a collection that might be null causes the warning. To remove these warnings, you need to add code to change that variable's null-state to not-null before dereferencing it. The collection initializer warning may be harder to spot. The compiler detects that the collection maybe-null when the initializer adds elements to it. In many instances, you can fix these warnings by checking that a variable isn't null before dereferencing it. For example, the above example could be rewritten as: void WriteMessageLength(string? message) { if (message is not null) // 明確檢查是否為 null 可解除警告. { Console.WriteLine(message.Length); } } Other instances when you get these warnings may be false positive. You may have a private utility method that tests for null. The compiler doesn't know that the method provides a null check. Consider the following example that uses a private utility method, IsNotNull: public void WriteMessage(string? message) { if (IsNotNull(message)) // 自訂檢查null的函數, 無法解除 null 警告. Console.WriteLine(message.Length); } The compiler warns that you may be dereferencing null when you write the property message.Length because its static analysis determines that message may be null. You may know that IsNotNull provides a null check, and when it returns true, the null-state of message should be not-null. You must tell the compiler those facts. One way is to use the null forgiving operator, !. You can change the WriteLine statement to match the following code: Console.WriteLine(message!.Length); // 忽略警告 null. The null forgiving operator makes the expression not-null even if it was maybe-null without the ! applied. In this example, a better solution is to add an attribute to the signature of IsNotNull: // private static bool IsNotNull([NotNullWhen(true)] object? obj) => obj != null; // 自訂函數必須加上NotNullWhen 通知編譯器, 若函數回傳值為 true, 則不需要 Null 檢查的任何程式碼. [NotNullWhen(true)] : 若函數回傳值為 true, 則不需要 Null 檢查的任何程式碼. [NotNullWhen(true)] 參考這裡: https://learn.microsoft.com/zh-tw/dotnet/csharp/language-reference/attributes/nullable-analysis 如下摘要: 您可能熟悉 string 方法 String.IsNullOrEmpty(String) 。 這個方法會在 true 引數為 null 或空字串時傳回。 它是 null 檢查的形式：如果方法傳回 false ，呼叫端就不需要 null 檢查引數。 若要讓類似這個可為 Null 的感測方式，您可以將 引數設定為可為 Null 的參考型別，並新增 NotNullWhen 屬性： // bool IsNullOrEmpty([NotNullWhen(false)] string? value) // 自訂函數必須加上NotNullWhen 通知編譯器, 若函數回傳值為 false, 則不需要 Null 檢查的任何程式碼. 這樣會通知編譯器，傳回值 false 不需要 Null 檢查的任何程式碼。 新增 屬性會通知編譯器的靜態分析 IsNullOrEmpty ，以執行必要的 Null 檢查：當它傳回 false 時，引數不是 null 。 string? userInput = GetUserInput(); if (!string.IsNullOrEmpty(userInput)) { int messageLength = userInput.Length; // no null check needed. } // null check needed on userInput here. The System.Diagnostics.CodeAnalysis.NotNullWhenAttribute informs the compiler that the argument used for the obj parameter is not-null when the method returns true. When the method returns false, the argument has the same null-state it had before the method was called. Tip There's a rich set of attributes you can use to describe how your methods and properties affect null-state. You can learn about them in the language reference article on Nullable static analysis attributes. 解除 maybe-null variable 警告常用方法: Fixing a warning for dereferencing a maybe-null variable involves one of three techniques: □ Add a missing null check. □ Add null analysis attributes on APIs to affect the compiler's null-state static analysis. These attributes inform the compiler when a return value or argument should be maybe-null or not-null after calling the method. □ Apply the null forgiving operator ! to the expression to force the state to not-null. Possible null assigned to a nonnullable reference This set of warnings alerts you that you're assigning a variable whose type is nonnullable to an expression whose null-state is maybe-null. These warnings are: CS8597 - Thrown value may be null. CS8600 - Converting null literal or possible null value to non-nullable type. CS8601 - Possible null reference assignment. CS8603 - Possible null reference return. CS8604 - Possible null reference argument for parameter. CS8605 - Unboxing a possibly null value. CS8625 - Cannot convert null literal to non-nullable reference type. CS8629 - Nullable value type may be null. The compiler emits these warnings when you attempt to assign an expression that is maybe-null to a variable that is nonnullable. For example: string? TryGetMessage(int id) => ""; string msg = TryGetMessage(42); // Possible null assignment. The different warnings indicate provide details about the code, such as assignment, unboxing assignment, return statements, arguments to methods, and throw expressions. You can take one of three actions to address these warnings. One is to add the ? annotation to make the variable a nullable reference type. That change may cause other warnings. Changing a variable from a non-nullable reference to a nullable reference changes its default null-state from not-null to maybe-null. The compiler's static analysis may find instances where you dereference a variable that is maybe-null. The other actions instruct the compiler that the right-hand-side of the assignment is not-null. The expression on the right-hand-side could be null-checked before assignment, as shown in the following example: string notNullMsg = TryGetMessage(42) ?? "Unknown message id: 42"; // ??: 若 TryGetMessage(42) 結果為 null, 則回傳 right-hand-side, 即 "Unknown message id: 42" The previous examples demonstrate assignment of the return value of a method. You may annotate the method (or property) to indicate when a method returns a not-null value. The System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute often specifies that a return value is not-null when an input argument is not-null. Another alternative is to add the null forgiving operator, ! to the right-hand side: string msg = TryGetMessage(42)!; // ! = null forgiving operator, 忽略警告 null. 解除 maybe-null expression 警告常用方法: Fixing a warning for assigning a maybe-null expression to a not-null variable involves one of four techniques: □ Change the left side of the assignment to a nullable type. This action may introduce new warnings when you dereference that variable. □ Provide a null-check before the assignment. □ Annotate the API that produces the right-hand side of the assignment. □ Add the null forgiving operator to the right-hand side of the assignment. Nonnullable reference not initialized This set of warnings alerts you that you're assigning a variable whose type is non-nullable to an expression whose null-state is maybe-null. These warnings are: CS8618 - Non-nullable variable must contain a non-null value when exiting constructor. Consider declaring it as nullable. CS8762 - Parameter must have a non-null value when exiting. Consider the following class as an example: public class Person { public string FirstName { get; set; } public string LastName { get; set; } } Neither FirstName nor LastName are guaranteed initialized. If this code is new, consider changing the public interface. The above example could be updated as follows: public class Person { public Person(string first, string last) { FirstName = first; LastName = last; } public string FirstName { get; set; } public string LastName { get; set; } } If you require creating a Person object before setting the name, you can initialize the properties using a default non-null value: public class Person { public string FirstName { get; set; } = string.Empty; // constructor 中指定值, 可避開null警告. public string LastName { get; set; } = string.Empty; // constructor 中指定值, 可避開null警告. } Another alternative may be to change those members to nullable reference types. The Person class could be defined as follows if null should be allowed for the name: public class Person { public string? FirstName { get; set; } // constructor 中指定為nullable reference types, 可避開null警告. public string? LastName { get; set; } // constructor 中指定為nullable reference types, 可避開null警告. } 以下2個 attribute 也可解除 null 警告: System.Diagnostics.CodeAnalysis.MemberNotNullAttribute and System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute attributes. Existing code may require other changes to inform the compiler about the null semantics for those members. You may have created multiple constructors, and your class may have a private helper method that initializes one or more members. You can move the initialization code into a single constructor and ensure all constructors call the one with the common initialization code. Or, you can use the System.Diagnostics.CodeAnalysis.MemberNotNullAttribute and System.Diagnostics.CodeAnalysis.MemberNotNullWhenAttribute attributes. These attributes inform the compiler that a member is not-null after the method has been called. The following code shows an example of each. The Person class uses a common constructor called by all other constructors. The Student class has a helper method annotated with the System.Diagnostics.CodeAnalysis.MemberNotNullAttribute attribute: using System.Diagnostics.CodeAnalysis; public class Person { public string FirstName { get; set; } public string LastName { get; set; } public Person(string firstName, string lastName) { FirstName = firstName; LastName = lastName; } public Person() : this("John", "Doe") { } } public class Student : Person { public string Major { get; set; } public Student(string firstName, string lastName, string major) : base(firstName, lastName) { SetMajor(major); } public Student(string firstName, string lastName) : base(firstName, lastName) { SetMajor(); } public Student() { SetMajor(); } [MemberNotNull(nameof(Major))] // 避開 null 警告. private void SetMajor(string? major = default) { Major = major ?? "Undeclared"; } } Finally, you can use the null forgiving operator to indicate that a member is initialized in other code. For another example, consider the following classes representing an Entity Framework Core model: public class TodoItem { public long Id { get; set; } public string? Name { get; set; } public bool IsComplete { get; set; } } public class TodoContext : DbContext { public TodoContext(DbContextOptions options) : base(options) { } public DbSet TodoItems { get; set; } = null!; // 忽略警告 null. tells the compiler that the property is set to a not-null value } The DbSet property is initialized to null!. That tells the compiler that the property is set to a not-null value. In fact, the base DbContext performs the initialization of the set. The compiler's static analysis doesn't pick that up. For more information on working with nullable reference types and Entity Framework Core, see the article on Working with Nullable Reference Types in EF Core. 解除 not initializing a nonnullable member 警告常用方法: Fixing a warning for not initializing a nonnullable member involves one of four techniques: □ Change the constructors or field initializers to ensure all nonnullable members are initialized. □ Change one or more members to be nullable types. □ Annotate any helper methods to indicate which members are assigned. □ Add an initializer to null! to indicate that the member is initialized in other code. Mismatch in nullability declaration Many warnings indicate nullability mismatches between signatures for methods, delegates, or type parameters. CS8608 - Nullability of reference types in type doesn't match overridden member. CS8609 - Nullability of reference types in return type doesn't match overridden member. CS8610 - Nullability of reference types in type parameter doesn't match overridden member. CS8611 - Nullability of reference types in type parameter doesn't match partial method declaration. CS8612 - Nullability of reference types in type doesn't match implicitly implemented member. CS8613 - Nullability of reference types in return type doesn't match implicitly implemented member. CS8614 - Nullability of reference types in type of parameter doesn't match implicitly implemented member. CS8615 - Nullability of reference types in type doesn't match implemented member. CS8616 - Nullability of reference types in return type doesn't match implemented member. CS8617 - Nullability of reference types in type of parameter doesn't match implemented member. CS8619 - Nullability of reference types in value doesn't match target type. CS8620 - Argument cannot be used for parameter due to differences in the nullability of reference types. CS8621 - Nullability of reference types in return type doesn't match the target delegate (possibly because of nullability attributes). CS8622 - Nullability of reference types in type of parameter doesn't match the target delegate (possibly because of nullability attributes). CS8624 - Argument cannot be used as an output due to differences in the nullability of reference types. CS8631 - The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. CS8633 - Nullability in constraints for type parameter of method doesn't match the constraints for type parameter of interface method. Consider using an explicit interface implementation instead. CS8634 - The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. CS8643 - Nullability of reference types in explicit interface specifier doesn't match interface implemented by the type. CS8644 - Type does not implement interface member. Nullability of reference types in interface implemented by the base type doesn't match. CS8645 - Member is already listed in the interface list on type with different nullability of reference types. CS8667 - Partial method declarations have inconsistent nullability in constraints for type parameter. CS8714 - The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'notnull' constraint. CS8764 - Nullability of return type doesn't match overridden member (possibly because of nullability attributes). CS8765 - Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes). CS8766 - Nullability of reference types in return type of doesn't match implicitly implemented member (possibly because of nullability attributes). CS8767 - Nullability of reference types in type of parameter of doesn't match implicitly implemented member (possibly because of nullability attributes). CS8768 - Nullability of reference types in return type doesn't match implemented member (possibly because of nullability attributes). CS8769 - Nullability of reference types in type of parameter doesn't match implemented member (possibly because of nullability attributes). CS8819 - Nullability of reference types in return type doesn't match partial method declaration. The following code demonstrates CS8764: public class B { public virtual string GetMessage(string id) => string.Empty; // 底層回傳 non-nullable string. } public class D : B { public override string? GetMessage(string? id) => default; // 繼承卻回傳 nullable string. } The preceding example shows a virtual method in a base class and an override with different nullability. The base class returns a non-nullable string, but the derived class returns a nullable string. If the string and string? are reversed, it would be allowed because the derived class is more restrictive. Similarly, parameter declarations should match. Parameters in the override method can allow null even when the base class doesn't. Other situations can generate these warnings. You may have a mismatch in an interface method declaration and the implementation of that method. Or a delegate type and the expression for that delegate may differ. A type parameter and the type argument may differ in nullability. To fix these warnings, update the appropriate declaration. Code doesn't match attribute declaration The preceding sections have discussed how you can use Attributes for nullable static analysis to inform the compiler about the null semantics of your code. The compiler warns you if the code doesn't adhere to the promises of that attribute: CS8607 - A possible null value may not be used for a type marked with [NotNull] or [DisallowNull] CS8763 - A method marked [DoesNotReturn] should not return. CS8770 - Method lacks [DoesNotReturn] annotation to match implemented or overridden member. CS8774 - Member must have a non-null value when exiting. CS8775 - Member must have a non-null value when exiting. CS8776 - Member cannot be used in this attribute. CS8777 - Parameter must have a non-null value when exiting. CS8824 - Parameter must have a non-null value when exiting because parameter is non-null. CS8825 - Return value must be non-null because parameter is non-null. Consider the following method: public bool TryGetMessage(int id, [NotNullWhen(true)] out string? message) { message = null; return true; } The compiler produces a warning because the message parameter is assigned null and the method returns true. The NotNullWhen attribute indicates that shouldn't happen. To address these warnings, update your code so it matches the expectations of the attributes you've applied. You may change the attributes, or the algorithm. Exhaustive switch expression Switch expressions must be exhaustive, meaning that all input values must be handled. Even for non-nullable reference types, the null value must be accounted for. The compiler issues warnings when the null value isn't handled: CS8655 - The switch expression does not handle some null inputs (it is not exhaustive). CS8847 - The switch expression does not handle some null inputs (it is not exhaustive). However, a pattern with a 'when' clause might successfully match this value. The following example code demonstrates this condition: int AsScale(string status) => status switch { "Red" => 0, "Yellow" => 5, "Green" => 10, { } => -1 }; The input expression is a string, not a string?. The compiler still generates this warning. The { } pattern handles all non-null values, but doesn't match null. To address these errors, you can either add an explicit null case, or replace the { } with the _ (discard) pattern. The discard pattern matches null as well as any other value. #### Nullable reference types □ Nullable reference types: 若碰到 Warning CS8632 The annotation for nullable reference types should only be used in code within a '#nullable' annotations context. 這是因為 By default, nullable annotation and warning contexts are disabled. That means that your existing code compiles without changes and without generating any new warnings. Beginning with .NET 6, new projects include the element in all project templates. enable 開啟 enable: 1. 整個專案開啟: 例如: netstandard2.0;net6.0 enable 2. 個別區塊中開啟 #nullable enable #nullable disable ref: https://learn.microsoft.com/en-us/dotnet/csharp/nullable-references#nullable-contexts #### 20200707 摘要: 1. Null-conditional operators ?. Null 條件運算子 ?. 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; otherwise, it returns null. That is, If a evaluates to null, the result of a?.x or a?[x] is null. If a evaluates to non-null, the result of a?.x or a?[x] is the same as the result of a.x or a[x], respectively. 若 a 為 null, 則 a?.x 為 null 或 a?.[x] 為 null. 若 a 不為 null, 則 a?.x 為 a.x 或 a?.[x] 為 a.[x]. 簡稱: 若(?.)前有值(非null), 則執行(?.)後的運算. 例如: object?.Dispose() 若 object 有值(非null), 則執行 Dispose(). 可取代 if (object != null) object.Dispose(); 2. null-coalescing operator ?? Null 聯合運算子 ?? 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, 則回傳右參數的執行結果, 否則回傳左參數. 例如: int? a = null; int b = a ?? -1; Console.WriteLine(b); // output: -1 可取代 if (a is null) b = -1; else b = a; Me = new HttpClient(handler1 ?? CreateHttpClientHandler(), bDisposeHandler); 3. null-coalescing assignment operator ??= 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. 簡稱: 若 ?? 的左參數為 null, 則指派為右參數, 否則指派為左參數. 例如: variable ??= expression; 可取代 if (variable is null) variable = expression; List numbers = null; int? a = null; (numbers ??= new List()).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 4. (int?) 是Nullable 變數, 不要跟 (Null 條件運算子 ?.) 搞混了. 5. Conditional operator ?: 條件運算元 ?: The conditional operator ?:, also known as the ternary conditional operator, evaluates a Boolean expression and returns the result of one of the two expressions, depending on whether the Boolean expression evaluates to true or false. Beginning with C# 7.2, the conditional ref expression returns the reference to the result of one of the two expressions. 例如: condition ? consequent: alternative 若條件 condition 成立, 則取結果 consequent, 否則取 替代 alternative #### 其餘慢慢看下面: Null 條件運算子 ?. 和 ?[] 適用於 C# 6 和更新版本，Null 條件運算子只有在其運算元評估為非 Null 時，才會將成員存取 ?. 或項目存取 ?[] 作業套用至該運算元。 如果運算元評估為 null，則套用運算子的結果會是 null。 Null 條件成員存取運算子 ?. 也被稱為 Elvis 運算子。 Null 條件運算子會執行最少運算。 換句話說，如果條件式成員或項目存取作業鏈結中的一個作業傳回 null，則鏈結的其餘部分不會執行。 在下列範例中，如果 A 評估為 null，則不會評估 B；如果 A 或 B 評估為 null，則不會評估 C： A?.B?.Do(C); A?.B?[C]; double SumNumbers(List setsOfNumbers, int indexOfSetToSum) { return setsOfNumbers?[indexOfSetToSum]?.Sum() ?? double.NaN; } var sum1 = SumNumbers(null, 0); Console.WriteLine(sum1); // output: NaN var numberSets = new List { 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 #### 20191227 ?? 還有？= 運算子（C#參考） 如果 Null 聯合運算子 ?? 不是 null，會傳回其左方運算元的值；否則它會評估右方運算元，並傳回其結果。 如果左方運算元評估為非 Null，?? 運算子不會評估其右方運算元。 可在C# 8.0 和更新版本中使用，如果左運算元評估為null，則 null 聯合指派運算子??=會將其右運算元的值指派給其左邊的運算元。 如果左方運算元評估為非 Null，??= 運算子不會評估其右方運算元。 List numbers = null; int? a = null; (numbers ??= new List()).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 ??= 運算子的左邊運算元必須是變數、屬性或索引子元素。 在C# 7.3 和更早版本中，?? 運算子的左邊運算元類型必須是參考型別或可為 null 的實數值型別。 從C# 8.0 開始，這項需求會以下列內容取代：??和??=運算子的左邊運算元類型不能是不可為 null 的實數值型別。 特別是從C# 8.0 開始，您可以使用 null 聯合運算子搭配不受限制的類型參數： private static void Display(T a, T backup) { Console.WriteLine(a ?? backup); } Null 聯合運算子是右向關聯。 也就是表單的運算式 a ?? b ?? c d ??= e ??= f 評估為 a ?? (b ?? c) d ??= (e ??= f) 範例 在下列案例中，?? 和 ??= 運算子可能會很有用： 在具有null 條件運算子？. 和？ []的運算式中，您可以使用 ?? 運算子來提供另一個運算式，以便在具有 null 條件運算的運算式結果為 null時進行評估： double SumNumbers(List setsOfNumbers, int indexOfSetToSum) { return setsOfNumbers?[indexOfSetToSum]?.Sum() ?? double.NaN; } var sum = SumNumbers(null, 0); Console.WriteLine(sum); // output: NaN 當您使用可為 null 的實數值型別，而且需要提供基礎實數值型別的值時，請使用 ?? 運算子來指定要提供的值，以防可為 null 的型別值為 null： int? a = null; int b = a ?? -1; Console.WriteLine(b); // output: -1 如果可為 Null 型別的值為 null 時要使用的值為基礎實值型別的預設值，請使用 Nullable.GetValueOrDefault() 方法。 從C# 7.0 開始，您可以使用throw 運算式做為??運算子的右運算元，讓引數檢查程式碼變得更簡潔： public string Name { get => name; set => name = value ?? throw new ArgumentNullException(nameof(value), "Name cannot be null"); } 上述範例中也會示範如何使用運算式主體成員定義屬性。 從C# 8.0 開始，您可以使用??=運算子來取代表單的程式碼 if (variable is null) { variable = expression; } 使用下列程式碼： variable ??= expression; 運算子是否可多載 ?? 和 ??= 的運算子無法多載。 #### null null 關鍵字是表示不參考任何物件之 Null 參考的常值。 null 是參考型別變數的預設值。 一般實值型別 (Value Type) 不可以為 null。 string s1 = null; object o1 = null; int? i1 = null; // 這樣寫會exception. //Trace.WriteLine(string.Format("string Null={0}.", s1.ToString())); //Trace.WriteLine(string.Format("object Null={0}.", o1.ToString())); // 這樣寫沒問題. Trace.WriteLine(string.Format("string Null={0}.", s1)); Trace.WriteLine(string.Format("object Null={0}.", o1)); Trace.WriteLine(string.Format("int? Null.ToString()={0}.", i1.ToString())); Trace.WriteLine(string.Format("int? Null={0}.", i1)); output: string Null=. object Null=. int? Null.ToString()=. int? Null=. #### null class class Program { class MyClass { public void MyMethod() { } } static void Main(string[] args) { // Set a breakpoint here to see that mc = null. // However, the compiler considers it "unassigned." // and generates a compiler error if you try to // use the variable. MyClass mc; // Now the variable can be used, but... mc = null; // ... a method call on a null object raises // a run-time NullReferenceException. // Uncomment the following line to see for yourself. // mc.MyMethod(); // Now mc has a value. mc = new MyClass(); // You can call its method. mc.MyMethod(); // Set mc to null again. The object it referenced // is no longer accsessible and can now be garbage-collected. mc = null; // A null string is not the same as an empty string. string s = null; string t = String.Empty; // Logically the same as "" // Equals applied to any null object returns false. bool b = (t.Equals(s)); Console.WriteLine(b); // Equality operator also returns false when one // operand is null. Console.WriteLine("Empty string {0} null string", s == t ? "equals": "does not equal"); // Returns true. Console.WriteLine("null == null is {0}", null == null); // A value type cannot be null // int i = null; // Compiler error! // Use a nullable value type instead: int? i = null; // Keep the console window open in debug mode. System.Console.WriteLine("Press any key to exit."); System.Console.ReadKey(); } }