Add documentation for CA1860. (#34157)

Author: CollinAlpert

docs/fundamentals/code-analysis/quality-rules/ca1860.md

@@ -0,0 +1,98 @@
+---
+title: "CA1860: Avoid using 'Enumerable.Any()' extension method"
+description: "Learn about code analyzer rule CA1860 - Avoid using 'Enumerable.Any()' extension method"
+ms.date: 03/01/2023
+ms.topic: reference
+f1_keywords:
+ - CA1860
+ - PreferLengthCountIsEmptyOverAnyAnalyzer
+helpviewer_keywords:
+ - CA1860
+dev_langs:
+ - CSharp
+ - VB
+---
+
+# CA1860: Avoid using 'Enumerable.Any()' extension method
+
+|                                     | Value                                  |
+| ----------------------------------- |----------------------------------------|
+| **Rule ID**                         | CA1860                                 |
+| **Category**                        | [Performance](performance-warnings.md) |
+| **Fix is breaking or non-breaking** | Non-breaking                           |
+
+## Cause
+
+<xref:System.Linq.Enumerable.Any%2A?displayProperty=nameWithType> is called on a type that has a `Length`, `Count`, or `IsEmpty` property.
+
+## Rule description
+
+It's more efficient and clearer to use `Length`, `Count`, or `IsEmpty` (if possible) than to call <xref:System.Linq.Enumerable.Any%2A?displayProperty=nameWithType> to determine whether a collection type has any elements.
+
+`Any()`, which is an extension method, uses language integrated query (LINQ). It's more efficient to rely on the collection's own properties, and it also clarifies intent.
+
+## How to fix violations
+
+Replace a call to <xref:System.Linq.Enumerable.Any%2A?displayProperty=nameWithType> with a call to the collection's `Length`, `Count`, or `IsEmpty` property.
+
+## Example
+
+The following code snippet shows a violation of CA1860:
+
+```csharp
+bool HasElements(string[] strings)
+{
+    return strings.Any();
+}
+```
+
+```vb
+Function HasElements(strings As String()) As Boolean
+    Return strings.Any()
+End Function
+```
+
+The following code snippet fixes the violation:
+
+```csharp
+bool HasElements(string[] strings)
+{
+    return strings.Length > 0;
+}
+```
+
+```vb
+Function HasElements(strings As String()) As Boolean
+    Return strings.Length > 0
+End Function
+```
+
+## When to suppress warnings
+
+It's safe to suppress this warning if performance isn't a concern.
+
+## Suppress a warning
+
+If you just want to suppress a single violation, add preprocessor directives to your source file to disable and then re-enable the rule.
+
+```csharp
+#pragma warning disable CA1860
+// The code that's violating the rule is on this line.
+#pragma warning restore CA1860
+```
+
+To disable the rule for a file, folder, or project, set its severity to `none` in the [configuration file](../configuration-files.md).
+
+```ini
+[*.{cs,vb}]
+dotnet_diagnostic.CA1860.severity = none
+```
+
+To disable this entire category of rules, set the severity for the category to `none` in the [configuration file](../configuration-files.md).
+
+```ini
+[*.{cs,vb}]
+dotnet_analyzer_diagnostic.category-Performance.severity = none
+```
+
+For more information, see [How to suppress code analysis warnings](../suppress-warnings.md).

docs/fundamentals/code-analysis/quality-rules/index.md

@@ -154,6 +154,7 @@ The following table lists code quality analysis rules.
 > | [CA1854: Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method](ca1854.md) | Prefer 'TryGetValue' over a Dictionary indexer access guarded by a 'ContainsKey' check. 'ContainsKey' and the indexer both look up the key, so using 'TryGetValue' avoids the extra lookup. |
 > | [CA1855: Use Span\<T>.Clear() instead of Span\<T>.Fill()](ca1855.md) | It's more efficient to call <xref:System.Span%601.Clear?displayProperty=nameWithType> than to call <xref:System.Span%601.Fill(%600)?displayProperty=nameWithType> to fill the elements of the span with a default value. |
 > | [CA1858: Use StartsWith instead of IndexOf](ca1858.md) | It's more efficient to call <xref:System.String.StartsWith%2A?displayProperty=nameWithType> than to call <xref:System.String.IndexOf%2A?displayProperty=nameWithType> to check whether a string starts with a given prefix. |
+> | [CA1860: Avoid using 'Enumerable.Any()' extension method](ca1860.md) | It's more efficient and clearer to use `Length`, `Count`, or `IsEmpty` (if possible) than to call <xref:System.Linq.Enumerable.Any%2A?displayProperty=nameWithType> to determine whether a collection type has any elements. |
 > | [CA2000: Dispose objects before losing scope](ca2000.md) | Because an exceptional event might occur that will prevent the finalizer of an object from running, the object should be explicitly disposed before all references to it are out of scope. |
 > | [CA2002: Do not lock on objects with weak identity](ca2002.md) |An object is said to have a weak identity when it can be directly accessed across application domain boundaries. A thread that tries to acquire a lock on an object that has a weak identity can be blocked by a second thread in a different application domain that has a lock on the same object. |
 > | [CA2007: Do not directly await a Task](ca2007.md) | An asynchronous method [awaits](../../../csharp/language-reference/operators/await.md) a <xref:System.Threading.Tasks.Task> directly. When an asynchronous method awaits a <xref:System.Threading.Tasks.Task> directly, continuation occurs in the same thread that created the task. This behavior can be costly in terms of performance and can result in a deadlock on the UI thread. Consider calling <xref:System.Threading.Tasks.Task.ConfigureAwait(System.Boolean)?displayProperty=nameWithType> to signal your intention for continuation. |

docs/fundamentals/code-analysis/quality-rules/performance-warnings.md

@@ -67,3 +67,4 @@ Performance rules support high-performance libraries and applications.
 | [CA1854: Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method](ca1854.md) | Prefer 'TryGetValue' over a Dictionary indexer access guarded by a 'ContainsKey' check. 'ContainsKey' and the indexer both look up the key, so using 'TryGetValue' avoids the extra lookup. |
 | [CA1855: Use Span\<T>.Clear() instead of Span\<T>.Fill()](ca1855.md) | It's more efficient to call <xref:System.Span%601.Clear?displayProperty=nameWithType> than to call <xref:System.Span%601.Fill(%600)?displayProperty=nameWithType> to fill the elements of the span with a default value. |
 | [CA1858: Use StartsWith instead of IndexOf](ca1858.md) | It's more efficient to call <xref:System.String.StartsWith%2A?displayProperty=nameWithType> than to call <xref:System.String.IndexOf%2A?displayProperty=nameWithType> to check whether a string starts with a given prefix. |
+| [CA1860: Avoid using 'Enumerable.Any()' extension method](ca1860.md) | It's more efficient and clearer to use `Length`, `Count`, or `IsEmpty` (if possible) than to call <xref:System.Linq.Enumerable.Any%2A?displayProperty=nameWithType> to determine whether a collection type has any elements. |

docs/navigate/tools-diagnostics/toc.yml

@@ -783,6 +783,8 @@ items:
                     href: ../../fundamentals/code-analysis/quality-rules/ca1855.md
                   - name: CA1858
                     href: ../../fundamentals/code-analysis/quality-rules/ca1858.md
+                  - name: CA1860
+                    href: ../../fundamentals/code-analysis/quality-rules/ca1860.md
               - name: SingleFile rules
                 items:
                   - name: Overview