Merge pull request #1 from MicrosoftDocs/master

Merge upstream changes

Author: madskristensen

docs/code-quality/automatic-feature-suspension.md

@@ -10,8 +10,8 @@ helpviewer_keywords:
   - "performance"
   - "low-memory"
 ms.assetid: 572c15aa-1fd0-468c-b6be-9fa50e170914
-author: TerryGLee
-ms.author: tglee
+author: Mikejo5000
+ms.author: mikejo
 manager: jillfra
 ms.workload:
 - multiple

docs/code-quality/ca1052.md

@@ -48,7 +48,10 @@ To fix a violation of this rule, mark the type as `static` and remove the defaul
 
 ## When to suppress warnings
 
-Suppress a warning from this rule only if the type is designed to be inherited. The absence of the `static` modifier suggests that the type is useful as a base type.
+You can suppress violations in the following cases:
+
+- The type is designed to be inherited. The absence of the `static` modifier suggests that the type is useful as a base type.
+- The type is used as a type argument. Static types can't be used as type arguments.
 
 ## Configurability
 

docs/code-quality/ca1805.md

@@ -0,0 +1,67 @@
+---
+title: "CA1805: Do not initialize unnecessarily"
+ms.date: 06/29/2020
+ms.topic: reference
+f1_keywords:
+  - "DoNotInitializeUnnecessarily"
+  - "CA1805"
+helpviewer_keywords:
+  - "DoNotInitializeUnnecessarily"
+  - "CA1805"
+author: stephentoub
+ms.author: stoub
+manager: jeffhand
+ms.workload:
+  - "multiple"
+---
+# CA1805: Do not initialize unnecessarily.
+
+|||
+|-|-|
+|CheckId|CA1805|
+|Category|Microsoft.Performance|
+|Breaking change|Non-breaking|
+
+## Cause
+
+A field of a class is explicitly initialized to the default value of that field's type.
+
+## Rule description
+
+The .NET runtime initializes all fields of reference types to their default values before running the constructor. In most cases, explicitly initializing a field to its default value in a constructor is redundant, adding maintenance costs and potentially degrading performance (such as with increased assembly size), and the explicit initialization can be removed.
+
+## How to fix violations
+
+In most cases, the proper fix is to delete the unnecessary initialization.
+
+```csharp
+class C
+{
+    // Violation
+    int _value1 = 0;
+
+    // Fixed
+    int _value1;
+}
+```
+
+In some cases, deleting the initialization may result in subsequent [CS0649](/dotnet/csharp/misc/cs0649) warnings being issued due to the field retaining its default value forever.  In such cases, a better fix may be to delete the field entirely or replace it with a property:
+
+```csharp
+class C
+{
+    // Violation
+    private static readonly int s_value = 0;
+
+    // Fixed
+    private static int Value => 0;
+}
+```
+
+## When to suppress warnings
+
+It is always safe to suppress the warning, as the warning simply highlights potentially unnecessary code and work that may be avoided.
+
+## See also
+
+- [Performance warnings](../code-quality/performance-warnings.md)

docs/code-quality/ca2016.md

@@ -0,0 +1,305 @@
+---
+title: "CA2016: Forward the CancellationToken parameter to methods that take one"
+ms.date: 06/18/2020
+ms.topic: reference
+f1_keywords:
+  - "ForwardCancellationTokenToInvocations"
+  - "CA2016"
+helpviewer_keywords:
+  - "ForwardCancellationTokenToInvocations"
+  - "CA2016"
+author: carlossanlop
+ms.author: calope
+manager: jeffhand
+dev_langs:
+ - CSharp
+ - VB
+ms.workload:
+  - "multiple"
+---
+# CA2016: Forward the CancellationToken parameter to methods that take one
+
+|||
+|-|-|
+|TypeName|ForwardCancellationTokenToInvocations|
+|CheckId|CA2016|
+|Category|Microsoft.Performance|
+|Breaking Change|Non-breaking|
+
+## Cause
+
+This rule locates method invocations that could accept a <xref:System.Threading.CancellationToken> parameter, but are not passing any, and suggests to forward the parent method's `CancellationToken` to them.
+
+## Rule description
+
+This rule analyzes method definitions that take a `CancellationToken` as their last parameter, then analyzes all methods invoked in its body. If any of the method invocations can either accept a `CancellationToken` as the last parameter, or have an overload that takes a `CancellationToken` as the last parameter, then the rule suggests using that option instead to ensure that the cancellation notification gets propagated to all operations that can listen to it.
+
+> [!NOTE]
+> Rule CA2016 is available in all .NET versions where the `CancellationToken` type is available. See [CancellationToken "Applies to" section](https://docs.microsoft.com/dotnet/api/system.threading.cancellationtoken#moniker-applies-to)
+
+## How to fix violations
+
+You can either fix them manually, or you can opt to let Visual Studio do it for you, by hovering over the light bulb that shows up next to the method invocation, and selecting the suggested change.
+
+The following example shows two suggested changes:
+
+![Rule CA2016 - Forward the CancellationToken parameter to methods that take one](media/ca2016-diagnose.png)
+
+It's safe to suppress a violation of this rule if you're not concerned about forwarding the canceled operation notification to lower method invocations.
+You can also explicitly pass `default` in C# (`Nothing` in Visual Basic) or <xref:System.Threading.CancellationToken.None> to suppress the rule violation.
+
+The rule can detect a variety of violations. The following examples show cases that the rule can detect:
+
+##### Example 1
+
+The rule will suggest forwarding the `c` parameter from `MyMethod` to the `MyMethodWithDefault` invocation, because the method defines an optional token parameter:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithDefault(CancellationToken ct = default)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault();
+        }
+    }
+}
+```
+
+##### Fix
+
+Forward the `c` parameter:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault(c);
+        }
+```
+
+If you are not concerned about forwarding cancellation notifications to lower invocations, you can either:
+
+Explicitly pass `default`:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault(default);
+        }
+```
+
+Or explicitly pass `CancellationToken.None`:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault(CancellationToken.None);
+        }
+```
+
+##### Example 2
+
+The rule will suggest forwarding the `c` parameter from `MyMethod` to the `MyMethodWithDefault` invocation, because the method has an overload that takes a `CancellationToken` parameter:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithOverload()
+        {
+        }
+
+        public static void MyMethodWithOverload(CancellationToken ct = default)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload();
+        }
+    }
+}
+```
+
+##### Fix
+
+Forward the `c` parameter:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload(c);
+        }
+```
+
+If you are not concerned about forwarding cancellation notifications to lower invocations, you can either:
+
+Explicitly pass `default`:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload(default);
+        }
+```
+
+Or explicitly pass `CancellationToken.None`:
+```csharp
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload(CancellationToken.None);
+        }
+```
+
+
+#### No diagnosis
+
+##### Example 1
+
+The `CancellationToken` parameter in the parent method is not in the last position:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithDefault(CancellationToken ct = default)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c, int lastParameter)
+        {
+            MyMethodWithDefault();
+        }
+    }
+}
+```
+
+##### Example 2
+
+The `CancellationToken` parameter in the default method is not in the last position:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithDefault(CancellationToken ct = default, int lastParameter = 0)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault();
+        }
+    }
+}
+```
+
+##### Example 3
+
+The `CancellationToken` parameter in the overload method is not in the last position:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithOverload(int lastParameter)
+        {
+        }
+        public static void MyMethodWithOverload(CancellationToken ct, int lastParameter)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload();
+        }
+    }
+}
+```
+
+##### Example 4
+
+The parent method defines more than one `CancellationToken` parameter:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithDefault(CancellationToken ct = default)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c1, CancellationToken c2)
+        {
+            MyMethodWithDefault();
+        }
+    }
+}
+```
+
+##### Example 5
+
+The method with defaults defines more than one `CancellationToken` parameter:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithDefault(CancellationToken c1 = default, CancellationToken c2 = default)
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithDefault();
+        }
+    }
+}
+```
+
+##### Example 6
+
+The method overload defines more than one `CancellationToken` parameter:
+
+```csharp
+using System.Threading;
+
+namespace ConsoleApp
+{
+    public static class MyTestClass
+    {
+        public static void MyMethodWithOverload(CancellationToken c1, CancellationToken c2)
+        {
+        }
+
+        public static void MyMethodWithOverload()
+        {
+        }
+
+        public static void MyMethod(CancellationToken c)
+        {
+            MyMethodWithOverload();
+        }
+    }
+}
+```