Added documentation for new rule CA1847 - Use string.Contains(char) whenever possible (#23377)

Author: MeikTranel

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

@@ -0,0 +1,74 @@
+---
+title: "CA1847: Use char literal for a single character lookup"
+description: "Use string.Contains(char) instead of string.Contains(string) when searching for a single character"
+ms.date: 03/03/2021
+ms.topic: reference
+f1_keywords:
+  - "CA1847"
+helpviewer_keywords:
+  - "CA1847"
+author: MeikTranel
+dev_langs:
+- CSharp
+- VB
+---
+
+# CA1847: Use string.Contains(char) instead of string.Contains(string) with single characters
+
+| | Value |
+|-|-|
+| **Rule ID** |CA1847|
+| **Category** |[Performance](performance-warnings.md)|
+| **Fix is breaking or non-breaking** |Non-breaking|
+
+## Cause
+
+`string.Contains(string)` is used when `string.Contains(char)` was available.
+
+## Rule description
+
+When searching for a single character, using `string.Contains(char)` offers better performance than `string.Contains(string)`.
+
+## How to fix violations
+
+In general, the rule is fixed simply by using a char literal instead of a string literal.
+
+```csharp
+public bool ContainsLetterI()
+{
+    var testString = "I am a test string.";
+    return testString.Contains("I");
+}
+```
+
+```vb
+Public Function ContainsLetterI() As Boolean
+    Dim testString As String = "I am a test string."
+    Return testString.Contains("I")
+End Function
+```
+
+This code can be changed to use a char literal instead.
+
+```csharp
+public bool ContainsLetterI()
+{
+    var testString = "I am a test string.";
+    return testString.Contains('I');
+}
+```
+
+```vb
+Public Function ContainsLetterI() As Boolean
+    Dim testString As String = "I am a test string."
+    Return testString.Contains("I"c)
+End Function
+```
+
+## When to suppress warnings
+
+Suppress a violation of this rule if you're not concerned about the performance impact of the search invocation in question.
+
+## See also
+
+- [Performance rules](performance-warnings.md)

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

@@ -133,6 +133,7 @@ The following table lists code quality analysis rules.
 > | [CA1844: Provide memory-based overrides of async methods when subclassing 'Stream'](ca1844.md) | To improve performance, override the memory-based async methods when subclassing 'Stream'. Then implement the array-based methods in terms of the memory-based methods. |
 > | [CA1845: Use span-based 'string.Concat'](ca1845.md) | It is more efficient to use `AsSpan` and `string.Concat`, instead of `Substring` and a concatenation operator. |
 > | [CA1846: Prefer `AsSpan` over `Substring`](ca1846.md) | `AsSpan` is more efficient than `Substring`. `Substring` performs an O(n) string copy, while `AsSpan` does not and has a constant cost. `AsSpan` also does not perform any heap allocations. |
+> | [CA1847: Use char literal for a single character lookup](ca1847.md) | Use `string.Contains(char)` instead of `string.Contains(string)` when searching for a single character. |
 > | [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

@@ -53,3 +53,4 @@ Performance rules support high-performance libraries and applications.
 | [CA1844: Provide memory-based overrides of async methods when subclassing 'Stream'](ca1844.md) | To improve performance, override the memory-based async methods when subclassing 'Stream'. Then implement the array-based methods in terms of the memory-based methods. |
 | [CA1845: Use span-based 'string.Concat'](ca1845.md) | It is more efficient to use `AsSpan` and `string.Concat`, instead of `Substring` and a concatenation operator. |
 | [CA1846: Prefer `AsSpan` over `Substring`](ca1846.md) | `AsSpan` is more efficient than `Substring`. `Substring` performs an O(n) string copy, while `AsSpan` does not and has a constant cost. `AsSpan` also does not perform any heap allocations. |
+| [CA1847: Use char literal for a single character lookup](ca1847.md) | Use `string.Contains(char)` instead of `string.Contains(string)` when searching for a single character. |

docs/fundamentals/toc.yml

@@ -927,6 +927,8 @@ items:
             href: code-analysis/quality-rules/ca1845.md
           - name: CA1846
             href: code-analysis/quality-rules/ca1846.md
+          - name: CA1847
+            href: code-analysis/quality-rules/ca1847.md
         - name: SingleFile rules
           items:
           - name: Overview