Add known pitfalls to the article of nullable warnings and include 'Constructors` section in it. (#44985)

* Include a note about known pitfalls article in nullable warnings page

* Add 'Constructors' to the known pitfalls

* Correct the link to the known pitfalls to include file type

Co-authored-by: Bill Wagner <[email protected]>

* Emphasize the call won't throw if constructor completes successfully

Co-authored-by: Bill Wagner <[email protected]>

* Rename Foo and Bar classes

* Combine the example description paragraphs

* Use four spaces for indentatios

---------

Co-authored-by: Bill Wagner <[email protected]>

Author: BartoszKlonowski

docs/csharp/language-reference/compiler-messages/nullable-warnings.md

@@ -192,6 +192,9 @@ This article covers the following compiler warnings:
 
 The purpose of nullable warnings is to minimize the chance that your application throws a <xref:System.NullReferenceException?displayProperty=nameWithType> when run. To achieve this goal, the compiler uses static analysis and issues warnings when your code has constructs that might 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 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](/ef/core/miscellaneous/nullable-reference-types).
 
+> [!NOTE]
+> The static analysis can't always deduce in what order, in a specific scenario, methods are accessed, and whether the method completes successfully without throwing an exception. Those known pitfalls are well described in [Known pitfalls](../../nullable-references.md#known-pitfalls) section.
+
 You address almost all warnings using one of five techniques:
 
 - Configuring the nullable context.

docs/csharp/nullable-references.md

@@ -380,6 +380,49 @@ public static class Program
 
 In the preceding example, the declaration of the array shows it holds non-nullable strings, while its elements are all initialized to `null`. Then, the variable `s` is assigned a `null` value (the first element of the array). Finally, the variable `s` is dereferenced causing a runtime exception.
 
+### Constructors
+
+Constructor of a class will still call the finalizer, even when there was an exception thrown by that constructor.
+<br/>The following example demonstrates that behavior:
+
+```csharp
+public class A
+{
+    private string _name;
+    private B _b;
+
+    public A(string name)
+    {
+        ArgumentNullException.ThrowIfNullOrEmpty(name);
+        _name = name;
+        _b = new B();
+    }
+
+  ~A()
+  {
+      Dispose();
+  }
+
+  public void Dispose()
+  {
+      _b.Dispose();
+      GC.SuppressFinalize(this);
+  }
+}
+
+public class B: IDisposable
+{
+    public void Dispose() { }
+}
+
+public void Main()
+{
+    var a = new A(string.Empty);
+}
+```
+
+In the preceding example, the <xref:System.NullReferenceException?displayProperty=nameWithType> will be thrown when `_b.Dispose();` runs, if the `name` parameter was `null`. The call to `_b.Dispose();` won't ever throw when the constructor completes successfully. However, there's no warning issued by the compiler, because static analysis can't determine if a method (like a constructor) completes without a runtime exception being thrown.
+
 ## See also
 
 - [Nullable reference types specification](~/_csharpstandard/standard/types.md#893-nullable-reference-types)