Neolution.CodeAnalysis.globalconfig

# Top level entry required to mark this as a global AnalyzerConfig file
# NOTE: Do not create section headers for configuration entries
is_global = true

# For conflicting rules, the higher level has higher priority 
global_level = 100

# Literals should not be passed as localized parameters
; Localization is not needed in every project and for every message. This rule disallows string literals everywhere e.g. for log messages, content that does not need to be translated etc.
dotnet_diagnostic.S4055.severity = none
dotnet_diagnostic.CA1303.severity = silent

# Each source file should start with a header stating file ownership and the license which must be used to distribute the application
; Header is not needed for each file. If the source code of a project will be distributed, the text can be added to each file individually at a later point in time to satisfy this rule.
dotnet_diagnostic.S1451.severity = none
dotnet_diagnostic.SA1633.severity = none

# A field name in C# does not begin with an underscore.
; Field names must not begin with an underscore. The `this.` qualifier is used in favor of the underscore
dotnet_diagnostic.SX1309.severity = none
dotnet_diagnostic.SX1309S.severity = none

# Do not prefix local calls with `this.`.
; Always prefix local calls with "this.". The "this." qualifier is used in favor of the underscore.
dotnet_diagnostic.SX1101.severity = none
dotnet_diagnostic.IDE0003.severity = none

# Use explicit type
; Do not force explicit type usage. Prefer using the implicit type (var) but you can use the explicit type to improve reading flow and comprehension.
dotnet_diagnostic.IDE0007.severity = suggestion
dotnet_diagnostic.IDE0008.severity = none

# Track uses of in-source issue suppressions
; Suppressions should be allowed, but still tracked.
dotnet_diagnostic.S1309.severity = silent

# Mark assemblies with CLSCompliant
; It is not needed to mark assemblies with CLSCompliant. We actively use libraries that are not compliant. If we mark our assemblies as CLS compliant we cannot use these anymore.
dotnet_diagnostic.CA1014.severity = none
dotnet_diagnostic.S3992.severity = none
dotnet_diagnostic.S3990.severity = none

# "Exception" should not be caught when not required by called methods
; This rule probably originates from Java where the Exception that will be thrown can be declared in the source code which is then checked by the compiler.
dotnet_diagnostic.S2221.severity = none
dotnet_diagnostic.CA1031.severity = none

# Use properties where appropriate
; Developers can make a correct decision when the property is a better option than a method.
dotnet_diagnostic.CA1024.severity = none

# URI properties or parameters should not be strings
; The team decided to drop this rule due to inconveniences resulting from System.Uri not having a parameterless constructor.
dotnet_diagnostic.CA1054.severity = none
dotnet_diagnostic.CA1056.severity = none
dotnet_diagnostic.S3996.severity = silent
dotnet_diagnostic.S3994.severity = silent

# Pass System.Uri objects instead of strings
; Dropped in favor of S4005
dotnet_diagnostic.CA2234.severity = none
dotnet_diagnostic.S4005.severity = warning

# Redundant parentheses should not be used
; The team decided to drop this rule because most of the team members are used to write redundant parentheses.
dotnet_diagnostic.S3235.severity = silent

# Collection properties should be read only
; The team decided to drop this rule due to the additional effort that is needed to write methods that add items for these type of properties.
dotnet_diagnostic.CA2227.severity = none
dotnet_diagnostic.S4004.severity = silent

# Convert to conditional expression
; Conflicts with rule S3358.
dotnet_diagnostic.IDE0045.severity = none
dotnet_diagnostic.IDE0046.severity = none
dotnet_diagnostic.S3358.severity = warning

# Avoid excessive class coupling
; Even if this rule might sound useful, in practice it was generating too many false-positives. Also, EF LINQ Queries are very prone to this and unit and integration tests have to setup and configure numerous dependencies in the same class.
dotnet_diagnostic.CA1506.severity = none

# Generic methods should provide type parameters
; Using the generic argument as return type does not lead to bugs. Only when calling the method, you need to write a little more explicit code.
dotnet_diagnostic.S4018.severity = none

# Mark members as static
; Dropped in favor of S2325.
dotnet_diagnostic.CA1822.severity = none
dotnet_diagnostic.S2325.severity = warning

# PropertyDocumentationMustHaveValue
; The documentation of the property value is doomed to become a hollow echo of the name and the summary.
dotnet_diagnostic.SA1609.severity = none

# DoNotCombineAttributes
; The team voted to deactivate this rule on 28.02.2019.
dotnet_diagnostic.SA1133.severity = none

# Normalize strings to uppercase
; Too many false positives for paths, URLs etc.
dotnet_diagnostic.CA1308.severity = none
dotnet_diagnostic.S4040.severity = silent

# Track uses of "TODO" tags
; Still show it to the developer in his IDE.
dotnet_diagnostic.S1135.severity = suggestion

# Missing XML comment for publicly visible type or member 'Type_or_Member'
; Dropped in favor of SA1600.
dotnet_diagnostic.CS1591.severity = none
dotnet_diagnostic.SA1600.severity = warning

# C# Expression value is never used
; Is reporting way too many false negatives.
dotnet_diagnostic.IDE0058.severity = none

# Methods and properties should not be too complex
; Deactivated in favor of the more elaborate rule S3776 (Cognitive Complexity of methods should not be too high).
dotnet_diagnostic.S1541.severity = none
dotnet_diagnostic.CA1502.severity = none
dotnet_diagnostic.S3776.severity = warning

# Documentation text should end with a period
; Does not add too much quality and developers find it too annoying to comply with this.
dotnet_diagnostic.SA1629.severity = silent

# Misplaced using directive
; Placing using directives outside of the namespace conflicts with our code style.
dotnet_diagnostic.IDE0065.severity = none

# Types that own disposable fields should be disposable
; Dropped in favor of S2931.
dotnet_diagnostic.CA1001.severity = none

# Overloads with a "StringComparison" parameter should be used.
; Generated too many false positives for EF queries.
dotnet_diagnostic.CA1307.severity = none
dotnet_diagnostic.S4058.severity = silent

# Do not raise reserved exception types
; Dropped in favor of S112
dotnet_diagnostic.CA2201.severity = none
dotnet_diagnostic.S112.severity = warning

# Name can be simplified
; Can lead to conflicting scenarios in the using directives with SA1135.
dotnet_diagnostic.IDE0001.severity = none

# Lines should not be too long
; Developers should be in charge to decide when the line is too long. Horizontal scrolling is not a big issue anymore with todays display sizes and resolutions.
dotnet_diagnostic.S103.severity = silent

# Magic numbers should not be used
; Developers are advised to add a comment to demystify the meaning of such a number.
dotnet_diagnostic.S109.severity = suggestion

# Console logging should not be used
; This rule has been superseded by S106 (https://jira.sonarsource.com/browse/RSPEC-2228).
dotnet_diagnostic.S2228.severity = none
dotnet_diagnostic.S106.severity = warning

# Single line comments should begin with single space
; Dropped in favor of S125.
dotnet_diagnostic.SA1005.severity = none
dotnet_diagnostic.S125.severity = warning

# Unnecessary using directive
; Dropped in favor of S1128.
dotnet_diagnostic.CS8019.severity = none
dotnet_diagnostic.IDE0005.severity = none
dotnet_diagnostic.S1128.severity = warning

# Validate arguments of public methods
; Dropped in favor of S3900.
dotnet_diagnostic.CA1062.severity = none
dotnet_diagnostic.S3900.severity = warning

# Specify IFormatProvider
; Dropped in favor of S4056.
dotnet_diagnostic.CA1305.severity = none
dotnet_diagnostic.S4056.severity = warning

# Unread "private" fields should be removed
; Dropped in favor of S4487
dotnet_diagnostic.IDE0052.severity = none
dotnet_diagnostic.S4487.severity = warning

# "switch" statements should have at least 3 "case" clauses
; Removed based on team vote. They prefer switch even if it has only one `case` clause.
dotnet_diagnostic.S1301.severity = silent

# break statements should not be used except for switch cases
; We enforce multiple rules to force developers to write simple functions. In simple functions, break statements should not be too problematic concerning readability.
dotnet_diagnostic.S1227.severity = silent

# URIs should not be hardcoded
; The suggestion is helpful, but should not be enforced in all cases.
dotnet_diagnostic.S1075.severity = suggestion

# Rethrow to preserve stack details
; Dropped in favor of S3445.
dotnet_diagnostic.CA2200.severity = none
dotnet_diagnostic.S3445.severity = warning

# Do not expose generic lists
; Dropped in favor of S3956.
dotnet_diagnostic.CA1002.severity = none
dotnet_diagnostic.S3956.severity = warning

# Use the LoggerMessage delegates
; Not all logging needs to be high performance.
dotnet_diagnostic.CA1848.severity = silent

# Fix formatting
; Conflicts with several StyleCop spacing rules.
dotnet_diagnostic.IDE0055.severity = none

# SQL keywords should be delimited by whitespace
; Has a confirmed FP that makes it unusable when using nameof(): https://github.com/SonarSource/sonar-dotnet/issues/6126
dotnet_diagnostic.S2857.severity = none

# Calling ConfigureAwait on the awaited task
; Drop S3216 in favor of CA2007
dotnet_diagnostic.S3216.severity = none
dotnet_diagnostic.CA2007.severity = warning

# SA1305: Field names should not use Hungarian notation
; Exceptions can be configured in stylecop.json
dotnet_diagnostic.SA1412.severity = warning

# S113: Files should contain an empty newline at the end
; Some tools (e.g. Git Diff) work better when files end with an empty line.
dotnet_diagnostic.S113.severity = warning
dotnet_diagnostic.SA1518.severity = none

# S3242: Method parameters should be declared with base types
; False positive with IEnumerable<T> that could lead to multiple enumerations. This should be only applied on Developers discretion.
dotnet_diagnostic.S3242.severity = suggestion

# S3257: Declarations and initializations should be as concise as possible
; In some cases developers may prefer the verbosity of a unused parameter over the easier readability of a discard.
dotnet_diagnostic.S3257.severity = suggestion

# S3267: Loops should be simplified with "LINQ" expressions
; This can be an annoying rule in cases where it does not really improve readability or even worsens it.
dotnet_diagnostic.S3267.severity = suggestion

# CA2000: Dispose objects before losing scopes
; Developers should be warned when they create disposable objects without disposing them
dotnet_diagnostic.CA2000.severity = warning

# S1133	Do not forget to remove this deprecated code someday.
; Deprecated code should eventually be removed, but it should not break the current build.
dotnet_diagnostic.S1133.severity = suggestion

# S6602: "Find" method should be used instead of the "FirstOrDefault" extension
; It seems like the potential performance gains here will be negative after .NET9: https://github.com/SonarSource/sonar-dotnet/issues/9664
dotnet_diagnostic.S6602.severity = none

# S6603: The collection-specific "TrueForAll" method should be used instead of the "All" extension
; Only has a performance gain with "large" collections and has a slightly different syntax when used with Arrays which could lead to confusion.
dotnet_diagnostic.S6603.severity = none

# S6605: Collection-specific "Exists" method should be used instead of the "Any" extension
; It seems like the potential performance gains here will be negative after .NET9: https://github.com/SonarSource/sonar-dotnet/issues/9665
dotnet_diagnostic.S6605.severity = none

# S6608: Prefer indexing instead of "Enumerable" methods on types implementing "IList"
; Better readability of `First()` and `Last()` are preferred over performance gains
dotnet_diagnostic.S6608.severity = none

# S6931: ASP.NET controller actions should not have a route template starting with "/"
; This rule has no effect for our projects, since we mainly use Endpoints which limits developers to only implement one action per "Controller".
dotnet_diagnostic.S6931.severity = none

# S6678: Use PascalCase for named placeholders
; Team decided that enforcing this rule is not worth the effort
dotnet_diagnostic.S6678.severity = suggestion

# S6964: Value type property used as input in a controller action should be nullable, required or annotated with the JsonRequiredAttribute to avoid under-posting
; This is handled by a custom model binder in our project templates that produces a bad request response in case of under-posting 
dotnet_diagnostic.S6964.severity = none

# S2139: Exceptions should be either logged or rethrown but not both
; Although this rule makes sense, we do not want to enforce it
dotnet_diagnostic.S2139.severity = suggestion

# S107: Methods should not have too many parameters
dotnet_diagnostic.S107.severity = warning

# S134: Control flow statements "if", "switch", "for", "foreach", "while", "do"  and "try" should not be nested too deeply
dotnet_diagnostic.S134.severity = warning

# S138: Functions should not have too many lines of code
dotnet_diagnostic.S138.severity = warning

# S1067: Expressions should not be too complex
dotnet_diagnostic.S1067.severity = warning

# S1151: "switch case" clauses should not have too many lines of code
dotnet_diagnostic.S1151.severity = warning

# S1200: Classes should not be coupled to too many other classes (Single Responsibility Principle)
dotnet_diagnostic.S1200.severity = warning

# S1244: Floating point numbers should not be tested for equality
dotnet_diagnostic.S1244.severity = warning

# S2360: Optional parameters should not be used
dotnet_diagnostic.S2360.severity = warning

# S3876: Strings or integral types should be used for indexers
dotnet_diagnostic.S3876.severity = warning

# S4017: Method signatures should not contain nested generic types
dotnet_diagnostic.S4017.severity = warning

# S4049: Properties should be preferred
dotnet_diagnostic.S4049.severity = warning

# S100: Methods and properties should be named in PascalCase
dotnet_diagnostic.S100.severity = warning

# S104: Files should not have too many lines of code
dotnet_diagnostic.S104.severity = warning

# S105: Tabulation characters should not be used
dotnet_diagnostic.S105.severity = warning

# S110: Inheritance tree of classes should not be too deep
dotnet_diagnostic.S110.severity = warning

# S1109: A close curly brace should be located at the beginning of a line
dotnet_diagnostic.S1109.severity = warning

# S1144: Unused private types or members should be removed
dotnet_diagnostic.S1144.severity = warning

# S1147: Exit methods should not be called
dotnet_diagnostic.S1147.severity = error

# S1192: String literals should not be duplicated
dotnet_diagnostic.S1192.severity = warning

# S121: Control structures should use curly braces
dotnet_diagnostic.S121.severity = warning

# S122: Statements should be on separate lines
dotnet_diagnostic.S122.severity = warning

# S1226: Method parameters, caught exceptions and foreach variables' initial values should not be ignored
dotnet_diagnostic.S1226.severity = warning

# S126: "if ... else if" constructs should end with "else" clauses
dotnet_diagnostic.S126.severity = warning

# S127: "for" loop stop conditions should be invariant
dotnet_diagnostic.S127.severity = warning

# S131: "switch/Select" statements should contain a "default/Case Else" clauses
dotnet_diagnostic.S131.severity = warning

# S1449: Culture should be specified for "string" operations
dotnet_diagnostic.S1449.severity = warning

# S1479: "switch" statements should not have too many "case" clauses
dotnet_diagnostic.S1479.severity = warning

# S1659: Multiple variables should not be declared on the same line
dotnet_diagnostic.S1659.severity = warning

# S1694: An abstract class should have both abstract and concrete methods
dotnet_diagnostic.S1694.severity = warning

# S1696: NullReferenceException should not be caught
dotnet_diagnostic.S1696.severity = warning

# S1698: "==" should not be used when "Equals" is overridden
dotnet_diagnostic.S1698.severity = warning

# S1821: "switch" statements should not be nested
dotnet_diagnostic.S1821.severity = warning

# S1858: "ToString()" calls should not be redundant
dotnet_diagnostic.S1858.severity = warning

# S1994: "for" loop increment clauses should modify the loops' counters
dotnet_diagnostic.S1994.severity = warning

# S2148: Underscores should be used to make large numbers readable
dotnet_diagnostic.S2148.severity = warning

# S3937: Number patterns should be regular
dotnet_diagnostic.S3937.severity = warning

# S2156: "sealed" classes should not have "protected" members
dotnet_diagnostic.S2156.severity = warning

# S2197: Modulus results should not be checked for direct equality
dotnet_diagnostic.S2197.severity = error

# S2302: "nameof" should be used
dotnet_diagnostic.S2302.severity = warning

# S2327: "try" statements with identical "catch" and/or "finally" blocks should be merged
dotnet_diagnostic.S2327.severity = warning

# S2330: Array covariance should not be used
dotnet_diagnostic.S2330.severity = warning

# S2333: Redundant modifiers should not be used
dotnet_diagnostic.S2333.severity = warning

# S2339: Public constant members should not be used
dotnet_diagnostic.S2339.severity = warning

# S2342: Enumeration types should comply with a naming convention
dotnet_diagnostic.S2342.severity = warning

# S2357: Fields should be private
dotnet_diagnostic.S2357.severity = warning

# S2387: Child class fields should not shadow parent class fields
dotnet_diagnostic.S2387.severity = warning

# S2436: Types and methods should not have too many generic parameters
dotnet_diagnostic.S2436.severity = warning

# S2437: Silly bit operations should not be performed
dotnet_diagnostic.S2437.severity = warning

# S2674: The length returned from a stream read should be checked
dotnet_diagnostic.S2674.severity = warning

# S2701: Literal boolean values should not be used in assertions
dotnet_diagnostic.S2701.severity = warning

# S2760: Sequential tests should not check the same condition
dotnet_diagnostic.S2760.severity = warning

# S2931: Classes with "IDisposable" members should implement "IDisposable"
dotnet_diagnostic.S2931.severity = warning

# S2952: Classes should "Dispose" of members from the classes' own "Dispose" methods
dotnet_diagnostic.S2952.severity = error

# S2955: Generic parameters not constrained to reference types should not be compared to "null"
dotnet_diagnostic.S2955.severity = warning

# S3052: Members should not be initialized to default values
dotnet_diagnostic.S3052.severity = warning

# S3215: "interface" instances should not be cast to concrete types
dotnet_diagnostic.S3215.severity = warning

# S3234: "GC.SuppressFinalize" should not be invoked for types without destructors
dotnet_diagnostic.S3234.severity = error

# S3240: The simplest possible condition syntax should be used
dotnet_diagnostic.S3240.severity = warning

# S3253: Constructor and destructor declarations should not be redundant
dotnet_diagnostic.S3253.severity = warning

# S3254: Default parameter values should not be passed as arguments
dotnet_diagnostic.S3254.severity = warning

# S3353: Unchanged local variables should be "const"
dotnet_diagnostic.S3353.severity = warning

# S3366: "this" should not be exposed from constructors
dotnet_diagnostic.S3366.severity = error

# S3441: Redundant property names should be omitted in anonymous classes
dotnet_diagnostic.S3441.severity = warning

# S3532: Empty "default" clauses should be removed
dotnet_diagnostic.S3532.severity = warning

# S3717: Track use of "NotImplementedException"
dotnet_diagnostic.S3717.severity = warning

# S3872: Parameter names should not duplicate the names of their methods
dotnet_diagnostic.S3872.severity = warning

# S3874: "out" and "ref" parameters should not be used
dotnet_diagnostic.S3874.severity = warning

# S3880: Finalizers should not be empty
dotnet_diagnostic.S3880.severity = error

# S3898: Value types should implement "IEquatable<T>"
dotnet_diagnostic.S3898.severity = warning

# S3902: "Assembly.GetExecutingAssembly" should not be called
dotnet_diagnostic.S3902.severity = warning

# S3906: Event Handlers should have the correct signature
dotnet_diagnostic.S3906.severity = warning

# S3908: Generic event handlers should be used
dotnet_diagnostic.S3908.severity = warning

# S3909: Collections should implement the generic interface
dotnet_diagnostic.S3909.severity = warning

# S3949: Calculations should not overflow
dotnet_diagnostic.S3949.severity = warning

# S3962: "static readonly" constants should be "const" instead
dotnet_diagnostic.S3962.severity = warning

# S3967: Multidimensional arrays should not be used
dotnet_diagnostic.S3967.severity = error

# S3993: Custom attributes should be marked with "System.AttributeUsageAttribute"
dotnet_diagnostic.S3993.severity = warning

# S3995: URI return values should not be strings
dotnet_diagnostic.S3995.severity = warning

# S3997: String URI overloads should call "System.Uri" overloads
dotnet_diagnostic.S3997.severity = warning

# S4000: Pointers to unmanaged memory should not be visible
dotnet_diagnostic.S4000.severity = error

# S4002: Disposable types should declare finalizers
dotnet_diagnostic.S4002.severity = error

# S4016: Enumeration members should not be named "Reserved"
dotnet_diagnostic.S4016.severity = error

# S4022: Enumerations should have "Int32" storage
dotnet_diagnostic.S4022.severity = error

# S4023: Interfaces should not be empty
dotnet_diagnostic.S4023.severity = warning

# S4025: Child class fields should not differ from parent class fields only by capitalization
dotnet_diagnostic.S4025.severity = warning

# S4026: Assemblies should be marked with "NeutralResourcesLanguageAttribute"
dotnet_diagnostic.S4026.severity = warning

# S4027: Exceptions should provide standard constructors
dotnet_diagnostic.S4027.severity = error

# S4039: Interface methods should be callable by derived types
dotnet_diagnostic.S4039.severity = warning

# S4041: Type names should not match namespaces
dotnet_diagnostic.S4041.severity = warning

# S4047: Generics should be used when appropriate
dotnet_diagnostic.S4047.severity = warning

# S4050: Operators should be overloaded consistently
dotnet_diagnostic.S4050.severity = warning

# S4052: Types should not extend outdated base types
dotnet_diagnostic.S4052.severity = error

# S4057: Locales should be set for data types
dotnet_diagnostic.S4057.severity = warning

# S4059: Property names should not match get methods
dotnet_diagnostic.S4059.severity = warning

# S4060: Non-abstract attributes should be sealed
dotnet_diagnostic.S4060.severity = warning

# S4212: Serialization constructors should be secured
dotnet_diagnostic.S4212.severity = error

# S4214: "P/Invoke" methods should not be visible
dotnet_diagnostic.S4214.severity = error

# S4225: Extension methods should not extend "object"
dotnet_diagnostic.S4225.severity = error

# S4226: Extensions should be in separate namespaces
dotnet_diagnostic.S4226.severity = warning

# S4261: Methods should be named according to their synchronicities
dotnet_diagnostic.S4261.severity = warning

# S4457: Parameter validation in "async"/"await" methods should be wrapped
dotnet_diagnostic.S4457.severity = warning

# S4462: Calls to "async" methods should not be blocking
dotnet_diagnostic.S4462.severity = warning

# S4564: ASP.NET HTTP request validation feature should not be disabled
dotnet_diagnostic.S4564.severity = error

# CA5386: Avoid hardcoding SecurityProtocolType value
dotnet_diagnostic.CA5386.severity = error

# CA5394: Do not use insecure randomness
dotnet_diagnostic.CA5394.severity = error

# SA1200: Using directives should be placed correctly
dotnet_diagnostic.SA1200.severity = warning

# CA5351: Do Not Use Broken Cryptographic Algorithms
dotnet_diagnostic.CA5351.severity = error

# SA1412: Store files as UTF-8 with byte order mark
dotnet_diagnostic.SA1412.severity = error

# CA1016: Mark assemblies with assembly version
dotnet_diagnostic.CA1016.severity = warning

# CA1018: Mark attributes with AttributeUsageAttribute
dotnet_diagnostic.CA1018.severity = warning

# CA1041: Provide ObsoleteAttribute message
dotnet_diagnostic.CA1041.severity = warning

# CA1047: Do not declare protected member in sealed type
dotnet_diagnostic.CA1047.severity = warning

# CA1050: Declare types in namespaces
dotnet_diagnostic.CA1050.severity = warning

# CA1061: Do not hide base class methods
dotnet_diagnostic.CA1061.severity = warning

# CA1067: Override Object.Equals(object) when implementing IEquatable<T>
dotnet_diagnostic.CA1067.severity = warning

# CA1068: CancellationToken parameters must come last
dotnet_diagnostic.CA1068.severity = warning

# CA1069: Enums values should not be duplicated
dotnet_diagnostic.CA1069.severity = warning

# CA1070: Do not declare event fields as virtual
dotnet_diagnostic.CA1070.severity = warning

# CA1401: P/Invokes should not be visible
dotnet_diagnostic.CA1401.severity = warning

# CA1419: Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle'
dotnet_diagnostic.CA1419.severity = warning

# CA1507: Use nameof to express symbol names
dotnet_diagnostic.CA1507.severity = warning

# CA1806: Do not ignore method results
dotnet_diagnostic.CA1806.severity = warning

# CA1816: Dispose methods should call SuppressFinalize
dotnet_diagnostic.CA1816.severity = warning

# CA1821: Remove empty Finalizers
dotnet_diagnostic.CA1821.severity = warning

# CA1824: Mark assemblies with NeutralResourcesLanguageAttribute
dotnet_diagnostic.CA1824.severity = warning

# CA1825: Avoid zero-length array allocations
dotnet_diagnostic.CA1825.severity = warning

# CA1826: Do not use Enumerable methods on indexable collections
dotnet_diagnostic.CA1826.severity = warning

# CA1827: Do not use Count() or LongCount() when Any() can be used
dotnet_diagnostic.CA1827.severity = warning

# CA1828: Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used
dotnet_diagnostic.CA1828.severity = warning

# CA1829: Use Length/Count property instead of Count() when available
dotnet_diagnostic.CA1829.severity = warning

# CA1830: Prefer strongly-typed Append and Insert method overloads on StringBuilder
dotnet_diagnostic.CA1830.severity = warning

# CA1832: Use AsSpan or AsMemory instead of Range-based indexers when appropriate
dotnet_diagnostic.CA1832.severity = warning

# CA1833: Use AsSpan or AsMemory instead of Range-based indexers when appropriate
dotnet_diagnostic.CA1833.severity = warning

# CA1834: Consider using 'StringBuilder.Append(char)' when applicable
dotnet_diagnostic.CA1834.severity = warning

# CA1835: Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync'
dotnet_diagnostic.CA1835.severity = warning

# CA1836: Prefer IsEmpty over Count
dotnet_diagnostic.CA1836.severity = warning

# CA1837: Use 'Environment.ProcessId'
dotnet_diagnostic.CA1837.severity = warning

# CA1839: Use 'Environment.ProcessPath'
dotnet_diagnostic.CA1839.severity = warning

# CA1840: Use 'Environment.CurrentManagedThreadId'
dotnet_diagnostic.CA1840.severity = warning

# CA1841: Prefer Dictionary.Contains methods
dotnet_diagnostic.CA1841.severity = warning

# CA1842: Do not use 'WhenAll' with a single task
dotnet_diagnostic.CA1842.severity = warning

# CA1843: Do not use 'WaitAll' with a single task
dotnet_diagnostic.CA1843.severity = warning

# CA1844: Provide memory-based overrides of async methods when subclassing 'Stream'
dotnet_diagnostic.CA1844.severity = warning

# CA1845: Use span-based 'string.Concat'
dotnet_diagnostic.CA1845.severity = warning

# CA1846: Prefer 'AsSpan' over 'Substring'
dotnet_diagnostic.CA1846.severity = warning

# CA1847: Use char literal for a single character lookup
dotnet_diagnostic.CA1847.severity = warning

# CA2009: Do not call ToImmutableCollection on an ImmutableCollection value
dotnet_diagnostic.CA2009.severity = warning

# CA2011: Avoid infinite recursion
dotnet_diagnostic.CA2011.severity = warning

# CA2012: Use ValueTasks correctly
dotnet_diagnostic.CA2012.severity = warning

# CA2016: Forward the 'CancellationToken' parameter to methods
dotnet_diagnostic.CA2016.severity = warning

# CA2101: Specify marshaling for P/Invoke string arguments
dotnet_diagnostic.CA2101.severity = warning

# CA2208: Instantiate argument exceptions correctly
dotnet_diagnostic.CA2208.severity = warning

# CA2211: Non-constant fields should not be visible
dotnet_diagnostic.CA2211.severity = warning

# CA2218: Override GetHashCode on overriding Equals
dotnet_diagnostic.CA2218.severity = warning

# CA2219: Do not raise exceptions in finally clauses
dotnet_diagnostic.CA2219.severity = warning

# CA2224: Override Equals on overloading operator equals
dotnet_diagnostic.CA2224.severity = warning

# CA2231: Overload operator equals on overriding value type Equals
dotnet_diagnostic.CA2231.severity = warning

# CA2241: Provide correct arguments to formatting methods
dotnet_diagnostic.CA2241.severity = warning

# CA2242: Test for NaN correctly
dotnet_diagnostic.CA2242.severity = warning

# CA2244: Do not duplicate indexed element initializations
dotnet_diagnostic.CA2244.severity = warning

# CA2245: Do not assign a property to itself
dotnet_diagnostic.CA2245.severity = warning

# CA2246: Assigning symbol and its member in the same statement
dotnet_diagnostic.CA2246.severity = warning

# CA2248: Provide correct 'enum' argument to 'Enum.HasFlag'
dotnet_diagnostic.CA2248.severity = warning

# CA2249: Consider using 'string.Contains' instead of 'string.IndexOf'
dotnet_diagnostic.CA2249.severity = warning

# CA2250: Use 'ThrowIfCancellationRequested'
dotnet_diagnostic.CA2250.severity = warning

# CA2252: This API requires opting into preview features
dotnet_diagnostic.CA2252.severity = warning