Rules

Name can be simplified

Simplify member access

Member access should be qualified

Remove unnecessary cast

Open declaration can be removed

Prefer `var` over an explicit type in local variable declarations.

Use explicit type instead of var

Member access should be qualified

Add missing cases to switch statement

Require braces around the bodies of if, else, for, while, and similar statements.

Use throw expression

Prefer object initializers over separate property assignments.

Inline variable declaration

Use pattern matching to avoid as followed by a null check

Use pattern matching to avoid is check followed by a cast (without variable)

Use expression body for constructors

Use expression body for methods

Use expression body for operators

Use expression body for operators

Use expression body for properties

Use expression body for indexers

Use expression body for accessors

Prefer collection initializers over repeated `Add` calls.

Prefer the null-coalescing operator `??` over equivalent conditionals.

Null check can be simplified (if null check)

Prefer the null-conditional operator `?.` over null-check conditionals.

Use auto-implemented property

Use explicitly provided tuple name

Simplify default expression

Remove unreachable code

Order modifiers

Use inferred member name

Use pattern matching to avoid is check followed by a cast (without variable)

Use local function instead of lambda

Require explicit accessibility modifiers (e.g. `private`) on members.

Use 'is null' check

Deconstruct variable declaration

Mark fields that are only assigned in the constructor as `readonly`.

Use conditional expression for assignment

Use conditional expression for return

Add parentheses for clarity

Add parentheses for clarity

Use language keywords instead of framework type names for type references

Convert anonymous type to tuple

Remove unused private member

Remove unread private member

Use expression body for lambdas

Use coalesce compound assignment

Enforce consistent whitespace, indentation, and new-line formatting.

Use index operator

Use range operator

Remove unnecessary expression value

The value is unused

Flag parameters that are never used by the method body.

Use expression body for local functions

Make local function static

Prefer the declaration-form `using` statement over a `using` block.

Make struct fields writable

Control whether `using` directives go inside or outside the namespace.

Prefer a `switch` expression over a `switch` statement where applicable.

Use System.HashCode.Combine

Simplify interpolation

Add missing cases to switch expression

Require file header

Use coalesce compound assignment

Simplify conditional expression

Remove invalid global SuppressMessageAttribute

Avoid legacy format target in global SuppressMessageAttribute

Use pattern matching

Remove unnecessary suppression

Remove unnecessary suppression operator

Remove ByVal

Convert typeof to nameof

Use pattern matching (not operator)

Use pattern matching (IsNot operator)

Use target-typed `new()` when the type is apparent.

Remove unnecessary equality operator

Remove unnecessary discard

Simplify LINQ expression

Simplify LINQ type check and cast

Namespace does not match folder structure

Simplify object creation

Prefer null check over type check

Use file-scoped namespace

Prefer file-scoped namespace declarations.

Simplify property pattern

Use tuple to swap values

Remove unnecessary lambda expression

Convert to top-level statements

Convert to 'Program.Main' style program

Add explicit cast

Add explicit cast

Use UTF-8 string literal

Nullable directive is redundant

Nullable directive is unnecessary

Struct can be made 'readonly'

Member can be made 'readonly'

Use pattern matching

Null check can be simplified (if null check)

Use 'nameof'

Use primary constructor

Use collection expression for array

Use collection expression for empty

Use collection expression for stackalloc

Use collection expression for Create

Use collection expression for builder

Use collection expression for fluent

Use collection expression for new

Make anonymous function static

Prefer 'System.Threading.Lock'

Use unbound generic type

Use implicitly typed lambda

Simplify property accessor

Remove unnecessary suppression

Remove unnecessary unsafe modifier

Use conditional delegate call

Enforce naming conventions (e.g. PascalCase for public members).

Avoid multiple blank lines

Embedded statements must be on their own line

Consecutive braces must not have blank line between them

Blank line required between block and subsequent statement

Blank line not allowed after constructor initializer colon

Blank line not allowed after conditional expression token

Blank line not allowed after arrow expression clause token

Implement with Copilot

Do not declare static members on generic types

Types that own disposable fields should be disposable

Do not expose generic lists

Use generic event handler instances

Avoid excessive parameters on generic types

Enums should have zero value

Collections should implement generic interface

Abstract types should not have public constructors

Mark assemblies with CLSCompliantAttribute

Mark assemblies with AssemblyVersionAttribute

Mark assemblies with ComVisibleAttribute

Mark attributes with AttributeUsageAttribute

Define accessors for attribute arguments

Avoid out parameters

Use properties where appropriate

Mark enums with FlagsAttribute

Enum storage should be Int32

Use events where appropriate

Avoid catching `Exception` or `SystemException` broadly.

Implement standard exception constructors

Interface methods should be callable by child types

Nested types should not be visible

Override methods on comparable types

Avoid empty interfaces

Provide ObsoleteAttribute message

Use integral or string argument for indexers

Properties should not be write only

Do not pass types by reference

Do not overload operator equals on reference types

Do not declare protected members in sealed types

Declare types in namespaces

Expose data through properties rather than public fields.

Static holder types should be Static or NotInheritable

Static holder types should not have default constructors

URI parameters should not be strings

URI return values should not be strings

URI properties should not be strings

Types should not extend certain base types

Move P/Invokes to NativeMethods class

Do not hide base class methods

Null-check reference parameters of externally visible methods.

Implement IDisposable correctly

Exceptions should be public

Do not raise exceptions in unexpected locations

Implement IEquatable when overriding Equals

Override Equals when implementing IEquatable

CancellationToken parameters must come last

Enums should not have duplicate values

Do not declare event fields as virtual

Avoid using cref tags with a prefix

Do not pass literals as localized parameters

Specify CultureInfo

Pass an explicit culture / format provider to formatting APIs.

Specify StringComparison for clarity

Normalize strings to uppercase

Use ordinal StringComparison

Pass an explicit StringComparison to string operations.

Specify a culture or use an invariant version

P/Invokes should not be visible

Validate platform compatibility

Do not use OutAttribute on string parameters for P/Invokes

Validate platform compatibility

Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle'

Property, type, or attribute requires runtime marshalling

Method uses runtime marshalling when DisableRuntimeMarshallingAttribute is applied

Validate platform compatibility - obsoleted APIs

Avoid excessive inheritance

Avoid excessive complexity

Avoid unmaintainable code

Avoid excessive class coupling

Use nameof in place of string

Avoid dead conditional code

Invalid entry in code metrics configuration file

Use ArgumentNullException throw helper

Use ArgumentException throw helper

Use ArgumentOutOfRangeException throw helper

Use ObjectDisposedException throw helper

Avoid redundant length argument

Consider making public types internal

Use cross-platform intrinsics

Do not name enum values 'Reserved'

Identifiers should not contain underscores

Identifiers should differ by more than case

Identifiers should have correct suffix

Identifiers should not have incorrect suffix

Do not prefix enum values with type name

Events should not have before or after prefix

Flags enums should have plural names

Identifiers should have correct prefix

Identifiers should not match keywords

Only FlagsAttribute enums should have plural names

Identifiers should not contain type names

Property names should not match get methods

Type names should not match namespaces

Parameter names should match base declaration

Use PascalCase for named placeholders

Review unused parameters

Use Literals Where Appropriate

Do not initialize unnecessarily

Do not ignore method results

Initialize reference type static fields inline

Avoid uninstantiated internal classes

Avoid unsealed attributes

Prefer jagged arrays over multidimensional

Override equals and operator equals on value types

Call `GC.SuppressFinalize(this)` in Dispose implementations.

Properties should not return arrays

Test for empty strings using string length

Remove empty finalizers

Mark members that do not access instance state as `static`.

Avoid unused private fields

Mark assemblies with NeutralResourcesLanguageAttribute

Use `Array.Empty<T>()` instead of allocating an empty array.

Use property instead of Linq Enumerable method

Do not use Count()/LongCount() when Any() can be used

Do not use CountAsync/LongCountAsync when AnyAsync can be used

Use Length/Count property instead of Enumerable.Count method

Prefer strongly-typed Append and Insert method overloads on StringBuilder

Use AsSpan instead of Range-based indexers for string when appropriate

Use AsSpan or AsMemory instead of Range-based indexers for getting ReadOnlySpan or ReadOnlyMemory portion of an array

Use AsSpan or AsMemory instead of Range-based indexers for getting Span or Memory portion of an array

Use StringBuilder.Append(char) for single character strings

Prefer the memory-based overloads of ReadAsync/WriteAsync methods in stream-based classes

Prefer IsEmpty over Count when available

Use Environment.ProcessId instead of Process.GetCurrentProcess().Id

Avoid StringBuilder parameters for P/Invokes

Use Environment.ProcessPath instead of Process.GetCurrentProcess().MainModule.FileName

Use Environment.CurrentManagedThreadId instead of Thread.CurrentThread.ManagedThreadId

Prefer Dictionary Contains methods

Do not use 'WhenAll' with a single task

Do not use 'WaitAll' with a single task

Provide memory-based overrides of async methods when subclassing 'Stream'

Use span-based 'string.Concat'

Prefer AsSpan over Substring

Use String.Contains(char) instead of String.Contains(string) with single characters

Use the LoggerMessage delegates

Prefer awaiting async APIs over their blocking counterparts.

Prefer static HashData method over ComputeHash

Possible multiple enumerations of IEnumerable collection

Seal internal types

Unnecessary call to 'Dictionary.ContainsKey(key)'

Prefer the IDictionary.TryGetValue(TKey, out TValue) method

Use Span\<T>.Clear() instead of Span\<T>.Fill()

Incorrect usage of ConstantExpected attribute

The parameter expects a constant for optimal performance

Use StartsWith instead of IndexOf

Use concrete types when possible for improved performance

Avoid using 'Enumerable.Any()' extension method

Avoid constant arrays as arguments

Use the 'StringComparison' method overloads to perform case-insensitive string comparisons

Use CompositeFormat

Prefer the 'IDictionary.TryAdd(TKey, TValue)' method

Unnecessary call to 'Contains' for sets

Cache and reuse 'JsonSerializerOptions' instances

Use a cached 'SearchValues' instance

Do not pass a nullable struct to 'ArgumentNullException.ThrowIfNull'

Prefer Convert.ToHexString and Convert.ToHexStringLower over call chains based on BitConverter.ToString

Avoid potentially expensive logging

Use Regex.IsMatch

Use Regex.Count

Use Path.Combine or Path.Join overloads

Dispose IDisposable objects before they go out of scope.

Do not lock on objects with weak identity

Call `ConfigureAwait(false)` on awaited tasks in library code.

Do not create tasks without passing a TaskScheduler

Do not call ToImmutableCollection on an ImmutableCollection value

Do not assign property within its setter

Use ValueTasks correctly

Do not use ReferenceEquals with value types

Do not use stackalloc in loops

Do not define finalizers for types derived from MemoryManager&lt;T&gt;

Forward the CancellationToken parameter to methods that take one

Parameter count mismatch

The count argument to Buffer.BlockCopy should specify the number of bytes to copy

ThreadStatic fields should not use inline initialization

Prevent behavioral change caused by built-in operators of IntPtr/UIntPtr

Don't call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types

Avoid inexact read with Stream.Read

Invalid braces in message template

Do not use StreamReader.EndOfStream in async methods

Do not pass 'IDisposable' instances into unawaited tasks

Prefer JsonElement.Parse over JsonDocument.Parse().RootElement

Avoid building SQL command text from untrusted input.

Specify marshalling for P/Invoke string arguments

Review visible event handlers

Seal methods that satisfy private interfaces

Avoid handling Corrupted State Exceptions

Rethrow to preserve stack details

Do not raise reserved exception types

Initialize value type static fields inline

Instantiate argument exceptions correctly

Non-constant fields should not be visible

Disposable fields should be disposed