root = true

[*]
indent_style = space
# (Please don't specify an indent_size here; that has too many unintended consequences.)

# Code files
[*.{cs,tt,config,xml,json,csproj,props}]
indent_size = 4
end_of_line = crlf
insert_final_newline = true
charset = utf-8-bom
trim_trailing_whitespace = true

###############################
# .NET/C# Coding Conventions  #
###############################
[*.cs]
# namespace preferences
csharp_style_namespace_declarations=file_scoped:warning

# Organize usings
dotnet_sort_system_directives_first = true
dotnet_separate_import_directive_groups = false

# this. and Me. preferences
dotnet_style_qualification_for_event = false
dotnet_style_qualification_for_field = false
dotnet_style_qualification_for_method = false
dotnet_style_qualification_for_property = false

# Language keywords vs BCL types preferences
dotnet_style_predefined_type_for_locals_parameters_members = true:warning
dotnet_style_predefined_type_for_member_access = true:warning

# Modifier preferences
dotnet_style_require_accessibility_modifiers = for_non_interface_members:warning
dotnet_style_readonly_field = true:warning

# Expression-level preferences
dotnet_style_object_initializer = true:silent
dotnet_style_collection_initializer = true:silent
dotnet_style_null_propagation = true:warning
dotnet_style_coalesce_expression = true:silent
dotnet_style_prefer_is_null_check_over_reference_equality_method = true:none
dotnet_style_prefer_inferred_anonymous_type_member_names = true:silent
dotnet_style_prefer_conditional_expression_over_assignment = true:silent
dotnet_style_prefer_conditional_expression_over_return = true:silent

# var preferences
csharp_style_var_for_built_in_types = false:silent
csharp_style_var_when_type_is_apparent = true:warning
csharp_style_var_elsewhere = false:silent

# Expression-bodied members
csharp_style_expression_bodied_methods = when_on_single_line:silent
csharp_style_expression_bodied_constructors = when_on_single_line:none
csharp_style_expression_bodied_operators = when_on_single_line:silent
csharp_style_expression_bodied_properties = when_on_single_line:silent
csharp_style_expression_bodied_indexers = when_on_single_line:silent
csharp_style_expression_bodied_accessors = when_on_single_line:silent
csharp_style_expression_bodied_lambdas = when_on_single_line:silent
csharp_style_expression_bodied_local_functions = when_on_single_line:silent

# Pattern matching preferences
csharp_style_pattern_matching_over_is_with_cast_check = true:warning
csharp_style_pattern_matching_over_as_with_null_check = true:warning

# primary constructor
csharp_style_prefer_primary_constructors = false:suggestion

# Null-checking preferences
csharp_style_throw_expression = true:warning
csharp_style_conditional_delegate_call = true:warning

# Modifier preferences
csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning

# Expression-level preferences
csharp_prefer_braces = true:warning
csharp_style_deconstructed_variable_declaration = true:silent
csharp_prefer_simple_default_expression = true:warning
csharp_style_pattern_local_over_anonymous_function = true:warning

# Other features
csharp_style_prefer_index_operator = true:warning
csharp_style_prefer_range_operator = true:warning
csharp_style_inlined_variable_declaration = true:warning

# New line preferences
csharp_new_line_before_open_brace = all
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_between_query_expression_clauses = true

# Indentation preferences
csharp_indent_case_contents = true
csharp_indent_switch_labels = true
csharp_indent_labels = flush_left
csharp_indent_block_contents = true
csharp_indent_braces = false
csharp_indent_case_contents_when_block = false

# Space preferences
csharp_space_after_cast = false
csharp_space_after_keywords_in_control_flow_statements = true
csharp_space_between_method_call_parameter_list_parentheses = false
csharp_space_between_method_declaration_parameter_list_parentheses = false
csharp_space_between_parentheses = false
csharp_space_before_colon_in_inheritance_clause = true
csharp_space_after_colon_in_inheritance_clause = true
csharp_space_around_binary_operators = before_and_after
csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
csharp_space_between_method_call_name_and_opening_parenthesis = false
csharp_space_between_method_call_empty_parameter_list_parentheses = false
csharp_space_between_method_declaration_name_and_open_parenthesis = false
csharp_space_after_comma = true
csharp_space_before_comma = false
csharp_space_after_dot = false
csharp_space_before_dot = false
csharp_space_after_semicolon_in_for_statement = true
csharp_space_before_semicolon_in_for_statement = false
csharp_space_around_declaration_statements = false
csharp_space_before_open_square_brackets = false
csharp_space_between_empty_square_brackets = false
csharp_space_between_square_brackets = false

# Wrapping preferences
csharp_preserve_single_line_statements = false
csharp_preserve_single_line_blocks = true

###############################
# Naming Convetions           #
###############################
dotnet_naming_style.camel_case_style.capitalization               = camel_case

dotnet_naming_style.underscore_camel_case_style.capitalization    = camel_case
dotnet_naming_style.underscore_camel_case_style.required_prefix   = _

dotnet_naming_style.pascal_case_style.capitalization              = pascal_case
dotnet_naming_style.I_prefix_style.required_prefix                = I
dotnet_naming_style.I_prefix_style.capitalization                 = pascal_case

dotnet_naming_style.T_prefix_style.required_prefix                = T
dotnet_naming_style.T_prefix_style.capitalization                 = pascal_case

# Use _camelCase for private fields
dotnet_naming_rule.local_fields_should_be_camel_case.severity     = error
dotnet_naming_rule.local_fields_should_be_camel_case.symbols      = private_fields
dotnet_naming_rule.local_fields_should_be_camel_case.style        = underscore_camel_case_style
dotnet_naming_symbols.private_fields.applicable_accessibilities   = private
dotnet_naming_symbols.private_fields.applicable_kinds             = field

# Use PascalCase for constant fields
dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = error
dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields
dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style
dotnet_naming_symbols.constant_fields.applicable_kinds            = field
dotnet_naming_symbols.constant_fields.applicable_accessibilities  = *
dotnet_naming_symbols.constant_fields.required_modifiers          = const

# Use PascalCase for public fields
dotnet_naming_rule.pascal_case_for_public_fields.severity         = error
dotnet_naming_rule.pascal_case_for_public_fields.symbols          = public_fields
dotnet_naming_rule.pascal_case_for_public_fields.style            = pascal_case_style
dotnet_naming_symbols.public_fields.applicable_kinds              = field
dotnet_naming_symbols.public_fields.applicable_accessibilities    = public

# Interfaces must be PascalCase and prefixed with an uppercase letter I
dotnet_naming_rule.interfaces_start_with_I.severity               = error
dotnet_naming_rule.interfaces_start_with_I.symbols                = any_interface
dotnet_naming_rule.interfaces_start_with_I.style                  = I_prefix_style
dotnet_naming_symbols.any_interface.applicable_accessibilities    = *
dotnet_naming_symbols.any_interface.applicable_kinds              = interface

# Type Parameters must be PascalCase and prefixed with an uppercase letter T
dotnet_naming_rule.type_parameters_start_with_I.severity               = error
dotnet_naming_rule.type_parameters_start_with_I.symbols                = any_type_parameter
dotnet_naming_rule.type_parameters_start_with_I.style                  = T_prefix_style
dotnet_naming_symbols.any_type_parameter.applicable_accessibilities    = *
dotnet_naming_symbols.any_type_parameter.applicable_kinds              = type_parameter

# Everything else is camelCase
dotnet_naming_rule.parameter_naming.severity                = error
dotnet_naming_rule.parameter_naming.symbols                 = parameter
dotnet_naming_rule.parameter_naming.style                   = camel_case_style
dotnet_naming_symbols.parameter.applicable_kinds            = parameter
dotnet_naming_symbols.parameter.applicable_accessibilities  = *

# Classes, structs, methods, enums, events, properties, delegates must be PascalCase
dotnet_naming_rule.general_naming.severity                        = error
dotnet_naming_rule.general_naming.symbols                         = general
dotnet_naming_rule.general_naming.style                           = pascal_case_style
dotnet_naming_symbols.general.applicable_kinds                    = class,struct,enum,property,method,event,delegate,type_parameter,namespace,local_function
dotnet_naming_symbols.general.applicable_accessibilities          = *

# Everything else is camelCase
dotnet_naming_rule.everything_else_naming.severity                = error
dotnet_naming_rule.everything_else_naming.symbols                 = everything_else
dotnet_naming_rule.everything_else_naming.style                   = camel_case_style
dotnet_naming_symbols.everything_else.applicable_kinds            = *
dotnet_naming_symbols.everything_else.applicable_accessibilities  = *


###############################
# Code analysis               #
###############################

dotnet_diagnostic.CA1000.severity = warning     # Do not declare static members on generic types
dotnet_diagnostic.CA1001.severity = warning     # Types that own disposable fields should be disposable
dotnet_diagnostic.CA1002.severity = none        # Do not expose generic lists
dotnet_diagnostic.CA1003.severity = warning     # Use generic event handler instances
dotnet_diagnostic.CA1005.severity = suggestion  # Avoid excessive parameters on generic types
dotnet_diagnostic.CA1008.severity = warning     # Enums should have zero value
dotnet_diagnostic.CA1010.severity = warning     # Collections should implement generic interface
dotnet_diagnostic.CA1012.severity = warning     # Abstract types should not have constructors
#dotnet_diagnostic.CA1014.severity = warning     # CA1014: Mark assemblies with CLSCompliantAttribute handled in Directory.Build.props as warning is not tied to .cs files.
dotnet_diagnostic.CA1016.severity = none        # Mark assemblies with AssemblyVersionAttribute
dotnet_diagnostic.CA1017.severity = none        # Mark assemblies with ComVisibleAttribute
dotnet_diagnostic.CA1018.severity = warning     # Mark attributes with AttributeUsageAttribute
dotnet_diagnostic.CA1019.severity = warning     # Define accessors for attribute arguments
dotnet_diagnostic.CA1021.severity = none        # Avoid out parameters
dotnet_diagnostic.CA1024.severity = warning     # Use properties where appropriate
dotnet_diagnostic.CA1027.severity = warning     # Mark enums with FlagsAttribute
dotnet_diagnostic.CA1028.severity = silent      # Enum storage should be Int32
dotnet_diagnostic.CA1030.severity = warning     # Use events where appropriate
dotnet_diagnostic.CA1031.severity = warning     # Do not catch general exception types
dotnet_diagnostic.CA1032.severity = none        # Implement standard exception constructors
dotnet_diagnostic.CA1033.severity = warning     # Interface methods should be callable by child types
dotnet_diagnostic.CA1034.severity = warning     # Nested types should not be visible
dotnet_diagnostic.CA1036.severity = warning     # Override methods on comparable types
dotnet_diagnostic.CA1040.severity = warning     # Avoid empty interfaces
dotnet_diagnostic.CA1041.severity = warning     # Provide ObsoleteAttribute message
dotnet_diagnostic.CA1043.severity = warning     # Use integral or string argument for indexers
dotnet_diagnostic.CA1044.severity = warning     # Properties should not be write only
dotnet_diagnostic.CA1045.severity = warning     # Do not pass types by reference
dotnet_diagnostic.CA1046.severity = warning     # Do not overload operator equals on reference types
dotnet_diagnostic.CA1047.severity = warning     # Do not declare protected members in sealed types
dotnet_diagnostic.CA1050.severity = warning     # Declare types in namespaces
dotnet_diagnostic.CA1051.severity = warning     # Do not declare visible instance fields
dotnet_diagnostic.CA1052.severity = warning     # Static holder types should be sealed
dotnet_diagnostic.CA1053.severity = warning     # Static holder types should not have constructors
dotnet_diagnostic.CA1054.severity = silent      # URI parameters should not be strings
dotnet_diagnostic.CA1055.severity = silent      # URI return values should not be strings
dotnet_diagnostic.CA1056.severity = silent      # URI properties should not be strings
dotnet_diagnostic.CA1058.severity = warning     # Types should not extend certain base types
dotnet_diagnostic.CA1060.severity = warning     # Move P/Invokes to NativeMethods class
dotnet_diagnostic.CA1061.severity = warning     # Do not hide base class methods

# Deaktiviert, da nicht mit C#8 nullable reference types kompatibel (warten auf https://github.com/dotnet/roslyn-analyzers/issues/2877)
dotnet_diagnostic.CA1062.severity = none        # Validate arguments of public methods
dotnet_diagnostic.CA1063.severity = warning     # Implement IDisposable correctly
dotnet_diagnostic.CA1064.severity = warning     # Exceptions should be public
dotnet_diagnostic.CA1065.severity = warning     # Do not raise exceptions in unexpected locations
dotnet_diagnostic.CA1066.severity = warning     # Implement IEquatable when overriding Equals
dotnet_diagnostic.CA1067.severity = warning     # Override Equals when implementing IEquatable
dotnet_diagnostic.CA1068.severity = warning     # CancellationToken parameters must come last
dotnet_diagnostic.CA1069.severity = warning     # Enums should not have duplicate values
dotnet_diagnostic.CA1070.severity = warning     # Do not declare event fields as virtual

dotnet_diagnostic.CA1200.severity = warning     # Avoid using cref tags with a prefix

dotnet_diagnostic.CA1303.severity = warning     # Do not pass literals as localized parameters
dotnet_code_quality.CA1303.use_naming_heuristic = false
dotnet_diagnostic.CA1304.severity = silent      # Specify CultureInfo
dotnet_diagnostic.CA1305.severity = silent      # Specify IFormatProvider
dotnet_diagnostic.CA1307.severity = none        # Specify StringComparison for clarity
dotnet_diagnostic.CA1308.severity = warning     # Normalize strings to uppercase
dotnet_diagnostic.CA1309.severity = warning     # Use ordinal StringComparison
dotnet_diagnostic.CA1310.severity = none        # Specify StringComparison for correctness
dotnet_diagnostic.CA1311.severity = suggestion  # Specify a culture or use an invariant version

dotnet_diagnostic.CA1401.severity = warning     # P/Invokes should not be visible
dotnet_diagnostic.CA1416.severity = warning     # Validate platform compatibility
dotnet_diagnostic.CA1417.severity = warning     # Do not use OutAttribute on string parameters for P/Invokes
dotnet_diagnostic.CA1418.severity = warning     # Validate platform compatibility
dotnet_diagnostic.CA1419.severity = warning     # Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle'
dotnet_diagnostic.CA1420.severity = warning     # Property, type, or attribute requires runtime marshalling
dotnet_diagnostic.CA1422.severity = warning     # Validate platform compatibility - obsoleted APIs

dotnet_diagnostic.CA1501.severity = warning     # Avoid excessive inheritance
dotnet_diagnostic.CA1502.severity = warning     # Avoid excessive complexity
dotnet_diagnostic.CA1505.severity = warning     # Avoid unmaintainable code
dotnet_diagnostic.CA1507.severity = warning     # Use nameof in place of string
dotnet_diagnostic.CA1510.severity = warning     # Use ArgumentNullException throw helper
dotnet_diagnostic.CA1511.severity = warning     # Use ArgumentException throw helper
dotnet_diagnostic.CA1512.severity = warning     # Use ArgumentOutOfRangeException throw helper
dotnet_diagnostic.CA1513.severity = warning     # Use ObjectDisposedException throw helper
dotnet_diagnostic.CA1514.severity = warning     # Avoid redundant length argument
dotnet_diagnostic.CA1515.severity = none        # Consider making public types internal


# Deaktiviert, da es mit .NET SDK 5.0.301 / 5.0.7 noch false positives mit string.IsNullOrEmpty gibt.
# aktivieren, sobald auf .NET 6 gewechselt wird (https://github.com/dotnet/sdk/milestone/48)
dotnet_diagnostic.CA1508.severity = none     # Avoid dead conditional code
dotnet_diagnostic.CA1509.severity = warning     # Invalid entry in code metrics configuration file

dotnet_diagnostic.CA1700.severity = warning     # Do not name enum values 'Reserved'
dotnet_diagnostic.CA1707.severity = none        # Identifiers should not contain underscores
dotnet_diagnostic.CA1708.severity = warning     # Identifiers should differ by more than case
dotnet_diagnostic.CA1710.severity = warning     # Identifiers should have correct suffix
dotnet_diagnostic.CA1711.severity = warning     # Identifiers should not have incorrect suffix
dotnet_diagnostic.CA1712.severity = warning     # Do not prefix enum values with type name
dotnet_diagnostic.CA1713.severity = warning     # Events should not have before or after prefix
dotnet_diagnostic.CA1714.severity = none        # Flags enums should have plural names
dotnet_diagnostic.CA1715.severity = warning     # Identifiers should have correct prefix
dotnet_diagnostic.CA1716.severity = warning     # Identifiers should not match keywords
dotnet_diagnostic.CA1717.severity = none        # Only FlagsAttribute enums should have plural names
dotnet_diagnostic.CA1720.severity = warning     # Identifiers should not contain type names
dotnet_diagnostic.CA1721.severity = warning     # Property names should not match get methods
dotnet_diagnostic.CA1724.severity = warning     # Type Names Should Not Match Namespaces
dotnet_diagnostic.CA1725.severity = warning     # Parameter names should match base declaration
dotnet_diagnostic.CA1727.severity = warning     # Use PascalCase for named placeholders

dotnet_diagnostic.CA1801.severity = warning     # Review unused parameters
dotnet_diagnostic.CA1802.severity = warning     # Use Literals Where Appropriate
dotnet_diagnostic.CA1805.severity = warning     # Do not initialize unnecessarily
dotnet_diagnostic.CA1806.severity = warning     # Do not ignore method results
dotnet_diagnostic.CA1810.severity = silent      # Initialize reference type static fields inline
dotnet_diagnostic.CA1812.severity = warning     # Avoid uninstantiated internal classes
dotnet_diagnostic.CA1813.severity = warning     # Avoid unsealed attributes
dotnet_diagnostic.CA1814.severity = silent      # Prefer jagged arrays over multidimensional
dotnet_diagnostic.CA1815.severity = warning     # Override equals and operator equals on value types
dotnet_diagnostic.CA1816.severity = warning     # Call GC.SuppressFinalize correctly
dotnet_diagnostic.CA1819.severity = warning     # Properties should not return arrays
dotnet_diagnostic.CA1820.severity = warning     # Test for empty strings using string length
dotnet_diagnostic.CA1821.severity = warning     # Remove empty finalizers
dotnet_diagnostic.CA1822.severity = warning     # Mark members as static
dotnet_diagnostic.CA1823.severity = warning     # Avoid unused private fields
dotnet_diagnostic.CA1824.severity = warning     # Mark assemblies with NeutralResourcesLanguageAttribute
dotnet_diagnostic.CA1825.severity = warning     # Avoid zero-length array allocations
dotnet_diagnostic.CA1826.severity = none        # Use property instead of Linq Enumerable method
dotnet_diagnostic.CA1827.severity = warning     # Do not use Count/LongCount when Any can be used
dotnet_diagnostic.CA1828.severity = warning     # Do not use CountAsync/LongCountAsync when AnyAsync can be used
dotnet_diagnostic.CA1829.severity = warning     # Use Length/Count property instead of Enumerable.Count method
dotnet_diagnostic.CA1830.severity = warning     # Prefer strongly-typed Append and Insert method overloads on StringBuilder
dotnet_diagnostic.CA1831.severity = warning     # Use AsSpan instead of Range-based indexers for string when appropriate
dotnet_diagnostic.CA1832.severity = warning     # Use AsSpan or AsMemory instead of Range-based indexers for getting ReadOnlySpan or ReadOnlyMemory portion of an array
dotnet_diagnostic.CA1833.severity = warning     # Use AsSpan or AsMemory instead of Range-based indexers for getting Span or Memory portion of an array
dotnet_diagnostic.CA1834.severity = warning     # Use StringBuilder.Append(char) for single character strings
dotnet_diagnostic.CA1835.severity = warning     # Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync'
dotnet_diagnostic.CA1836.severity = warning     # Prefer IsEmpty over Count when available
dotnet_diagnostic.CA1837.severity = warning     # Use Environment.ProcessId instead of Process.GetCurrentProcess().Id
dotnet_diagnostic.CA1838.severity = warning     # Avoid StringBuilder parameters for P/Invokes
dotnet_diagnostic.CA1841.severity = warning     # Prefer Dictionary Contains methods
dotnet_diagnostic.CA1845.severity = warning     # Use span-based 'string.Concat'
dotnet_diagnostic.CA1846.severity = warning     # Prefer AsSpan over Substring
dotnet_diagnostic.CA1848.severity = none        # For improved performance, use the LoggerMessage delegates instead of calling 'LoggerExtensions.Log...(ILogger, string, params object[])'
dotnet_diagnostic.CA1849.severity = warning     # Call async methods when in an async method
dotnet_diagnostic.CA1850.severity = suggestion  # Prefer static HashData method over ComputeHash
dotnet_diagnostic.CA1851.severity = suggestion  # Possible multiple enumerations of IEnumerable collection
dotnet_diagnostic.CA1852.severity = none        # Seal internal types
dotnet_diagnostic.CA1853.severity = warning     # Unnecessary call to 'Dictionary.ContainsKey(key)'
dotnet_diagnostic.CA1854.severity = warning     # Unnecessary call to 'Dictionary.ContainsKey(key)'
dotnet_diagnostic.CA1855.severity = warning     # Use Span<T>.Clear() instead of Span<T>.Fill()
dotnet_diagnostic.CA1856.severity = warning     # Incorrect usage of ConstantExpected attribute
dotnet_diagnostic.CA1857.severity = warning     # The parameter expects a constant for optimal performance
dotnet_diagnostic.CA1858.severity = warning     # Use StartsWith instead of IndexOf
dotnet_diagnostic.CA1859.severity = suggestion  # Use concrete types when possible for improved performance
dotnet_diagnostic.CA1860.severity = warning     # Avoid using 'Enumerable.Any()' extension method
dotnet_diagnostic.CA1861.severity = suggestion  # Avoid constant arrays as arguments
dotnet_diagnostic.CA1862.severity = suggestion  # Use the 'StringComparison' method overloads to perform case-insensitive string comparisons
dotnet_diagnostic.CA1863.severity = suggestion  # Use 'CompositeFormat'
dotnet_diagnostic.CA1864.severity = warning     # Prefer the 'IDictionary.TryAdd(TKey, TValue)' method
dotnet_diagnostic.CA1865.severity = warning     # Use 'string.Method(char)' instead of 'string.Method(string)' for string with single char. Applies when a safe transformation can be performed automatically with a code fix.
dotnet_diagnostic.CA1866.severity = warning     # Use 'string.Method(char)' instead of 'string.Method(string)' for string with single char. Applies when there's no specified comparison.
dotnet_diagnostic.CA1867.severity = none        # Use 'string.Method(char)' instead of 'string.Method(string)' for string with single char. Applies for any other string comparison not covered by the other two rules.

dotnet_diagnostic.CA2000.severity = warning     # Dispose objects before losing scope
dotnet_code_quality.CA2000.excluded_symbol_names = T:System.Data.DataSet|T:System.Data.DataTable
dotnet_diagnostic.CA2002.severity = warning     # Do not lock on objects with weak identity
dotnet_diagnostic.CA2007.severity = none        # Do not directly await a Task
dotnet_diagnostic.CA2008.severity = none        # Do not create tasks without passing a TaskScheduler
dotnet_diagnostic.CA2009.severity = warning     # Do not call ToImmutableCollection on an ImmutableCollection value
dotnet_diagnostic.CA2011.severity = warning     # Do not assign property within its setter
dotnet_diagnostic.CA2012.severity = warning     # Use ValueTasks correctly
dotnet_diagnostic.CA2013.severity = warning     # Do not use ReferenceEquals with value types
dotnet_diagnostic.CA2014.severity = warning     # Do not use stackalloc in loops.
dotnet_diagnostic.CA2015.severity = warning     # Do not define finalizers for types derived from MemoryManager<T>
dotnet_diagnostic.CA2016.severity = warning     # Forward the CancellationToken parameter to methods that take one
dotnet_diagnostic.CA2017.severity = warning     # Parameter count mismatch
dotnet_diagnostic.CA2018.severity = warning     # The count argument to Buffer.BlockCopy should specify the number of bytes to copy
dotnet_diagnostic.CA2019.severity = warning     # ThreadStatic fields should not use inline initialization
dotnet_diagnostic.CA2020.severity = warning     # Prevent behavioral change caused by built-in operators of IntPtr/UIntPtr
dotnet_diagnostic.CA2021.severity = warning     # Don't call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types

dotnet_diagnostic.CA2100.severity = warning     # Review SQL queries for security vulnerabilities
dotnet_diagnostic.CA2101.severity = warning     # Specify marshaling for P/Invoke string arguments
dotnet_diagnostic.CA2109.severity = warning     # Review visible event handlers
dotnet_diagnostic.CA2119.severity = none        # Seal methods that satisfy private interfaces
dotnet_diagnostic.CA2153.severity = warning     # Avoid handling Corrupted State Exceptions

dotnet_diagnostic.CA2200.severity = warning     # Rethrow to preserve stack details
dotnet_diagnostic.CA2201.severity = warning     # Do not raise reserved exception types
dotnet_diagnostic.CA2207.severity = none        # Initialize value type static fields inline
dotnet_diagnostic.CA2208.severity = warning     # Instantiate argument exceptions correctly
dotnet_diagnostic.CA2211.severity = warning     # Non-constant fields should not be visible
dotnet_diagnostic.CA2213.severity = warning     # Disposable fields should be disposed
dotnet_diagnostic.CA2214.severity = warning     # Do not call overridable methods in constructors
dotnet_diagnostic.CA2215.severity = warning     # Dispose methods should call base class dispose
dotnet_diagnostic.CA2216.severity = warning     # Disposable types should declare finalizer
dotnet_diagnostic.CA2218.severity = warning     # Override GetHashCode on overriding Equals
dotnet_diagnostic.CA2217.severity = warning     # Do not mark enums with FlagsAttribute
dotnet_diagnostic.CA2219.severity = warning     # Do not raise exceptions in exception clauses
dotnet_diagnostic.CA2224.severity = warning     # Override equals on overloading operator equals
dotnet_diagnostic.CA2225.severity = warning     # Operator overloads have named alternates
dotnet_diagnostic.CA2226.severity = warning     # Operators should have symmetrical overloads
dotnet_diagnostic.CA2227.severity = none        # Collection properties should be read only
dotnet_diagnostic.CA2229.severity = none        # Implement serialization constructors
dotnet_diagnostic.CA2231.severity = warning     # Overload operator equals on overriding ValueType.Equals
dotnet_diagnostic.CA2234.severity = silent      # Pass System.Uri objects instead of strings
dotnet_diagnostic.CA2235.severity = warning     # Mark all non-serializable fields
dotnet_diagnostic.CA2237.severity = warning     # Mark ISerializable types with SerializableAttribute
dotnet_diagnostic.CA2241.severity = warning     # Provide correct arguments to formatting methods
dotnet_diagnostic.CA2242.severity = warning     # Test for NaN correctly
dotnet_diagnostic.CA2243.severity = warning     # Attribute string literals should parse correctly
dotnet_diagnostic.CA2244.severity = warning     # Do not duplicate indexed element initializations
dotnet_diagnostic.CA2245.severity = warning     # Do not assign a property to itself
dotnet_diagnostic.CA2246.severity = warning     # Do not assign a symbol and its member in the same statement
dotnet_diagnostic.CA2247.severity = warning     # Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum.
dotnet_diagnostic.CA2248.severity = warning     # Provide correct enum argument to Enum.HasFlag
dotnet_diagnostic.CA2249.severity = warning     # Consider using String.Contains instead of String.IndexOf
dotnet_diagnostic.CA2250.severity = warning     # Use ThrowIfCancellationRequested
dotnet_diagnostic.CA2251.severity = warning     # Use String.Equals over String.Compare
dotnet_diagnostic.CA2252.severity = warning     # Opt in to preview features before using them
dotnet_diagnostic.CA2253.severity = warning     # Named placeholders should not be numeric values
dotnet_diagnostic.CA2254.severity = warning     # Template should be a static expression
dotnet_diagnostic.CA2255.severity = warning     # The ModuleInitializer attribute should not be used in libraries
dotnet_diagnostic.CA2256.severity = warning     # All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface
dotnet_diagnostic.CA2257.severity = warning     # Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static'
dotnet_diagnostic.CA2258.severity = warning     # Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported
dotnet_diagnostic.CA2259.severity = warning     # Ensure ThreadStatic is only used with static fields
dotnet_diagnostic.CA2260.severity = warning     # Implement generic math interfaces correctly
dotnet_diagnostic.CA2261.severity = warning     # Do not use ConfigureAwaitOptions.SuppressThrowing with Task<TResult>
dotnet_diagnostic.CA2262.severity = warning     # Set 'MaxResponseHeadersLength' properly
dotnet_diagnostic.CA2263.severity = warning     # Prefer generic overload when type is known

dotnet_diagnostic.CA2300.severity = warning     # Do not use insecure deserializer BinaryFormatter
dotnet_diagnostic.CA2301.severity = warning     # Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder
dotnet_diagnostic.CA2302.severity = warning     # Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize
dotnet_diagnostic.CA2305.severity = warning     # Do not use insecure deserializer LosFormatter
dotnet_diagnostic.CA2310.severity = warning     # Do not use insecure deserializer NetDataContractSerializer
dotnet_diagnostic.CA2311.severity = warning     # Do not deserialize without first setting NetDataContractSerializer.Binder
dotnet_diagnostic.CA2312.severity = warning     # Ensure NetDataContractSerializer.Binder is set before deserializing
dotnet_diagnostic.CA2315.severity = warning     # Do not use insecure deserializer ObjectStateFormatter
dotnet_diagnostic.CA2321.severity = warning     # Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver
dotnet_diagnostic.CA2322.severity = warning     # Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing
dotnet_diagnostic.CA2326.severity = warning     # Do not use TypeNameHandling values other than None
dotnet_diagnostic.CA2327.severity = warning     # Do not use insecure JsonSerializerSettings
dotnet_diagnostic.CA2328.severity = warning     # Ensure that JsonSerializerSettings are secure
dotnet_diagnostic.CA2329.severity = warning     # Do not deserialize with JsonSerializer using an insecure configuration
dotnet_diagnostic.CA2330.severity = warning     # Ensure that JsonSerializer has a secure configuration when deserializing
dotnet_diagnostic.CA2350.severity = warning     # Ensure DataTable.ReadXml()'s input is trusted
dotnet_diagnostic.CA2351.severity = warning     # Ensure DataSet.ReadXml()'s input is trusted
dotnet_diagnostic.CA2352.severity = warning     # Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks
dotnet_diagnostic.CA2353.severity = warning     # Unsafe DataSet or DataTable in serializable type
dotnet_diagnostic.CA2354.severity = warning     # Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attack
dotnet_diagnostic.CA2355.severity = warning     # Unsafe DataSet or DataTable in deserialized object graph
dotnet_diagnostic.CA2356.severity = warning     # Unsafe DataSet or DataTable in web deserialized object graph
dotnet_diagnostic.CA2361.severity = warning     # Ensure autogenerated class containing DataSet.ReadXml() is not used with untrusted data
dotnet_diagnostic.CA2362.severity = warning     # Unsafe DataSet or DataTable in autogenerated serializable type can be vulnerable to remote code execution attacks

dotnet_diagnostic.CA3001.severity = warning     # Review code for SQL injection vulnerabilities
dotnet_diagnostic.CA3002.severity = warning     # Review code for XSS vulnerabilities
dotnet_diagnostic.CA3003.severity = warning     # Review code for file path injection vulnerabilities
dotnet_diagnostic.CA3004.severity = warning     # Review code for information disclosure vulnerabilities
dotnet_diagnostic.CA3005.severity = warning     # Review code for LDAP injection vulnerabilities
dotnet_diagnostic.CA3006.severity = warning     # Review code for process command injection vulnerabilities
dotnet_diagnostic.CA3007.severity = warning     # Review code for open redirect vulnerabilities
dotnet_diagnostic.CA3008.severity = warning     # Review code for XPath injection vulnerabilities
dotnet_diagnostic.CA3009.severity = warning     # Review code for XML injection vulnerabilities
dotnet_diagnostic.CA3010.severity = warning     # Review code for XAML injection vulnerabilities
dotnet_diagnostic.CA3011.severity = warning     # Review code for DLL injection vulnerabilities
dotnet_diagnostic.CA3012.severity = warning     # Review code for regex injection vulnerabilities
dotnet_diagnostic.CA3061.severity = warning     # Do not add schema by URL
dotnet_diagnostic.CA3075.severity = warning     # Insecure DTD Processing
dotnet_diagnostic.CA3076.severity = warning     # Insecure XSLT Script Execution
dotnet_diagnostic.CA3077.severity = warning     # Insecure Processing in API Design, XML Document and XML Text Reader

dotnet_diagnostic.CA3147.severity = warning     # Mark verb handlers with ValidateAntiForgeryToken

dotnet_diagnostic.CA5350.severity = warning     # Do Not Use Weak Cryptographic Algorithms
dotnet_diagnostic.CA5351.severity = warning     # Do Not Use Broken Cryptographic Algorithms
dotnet_diagnostic.CA5358.severity = warning     # Do Not Use Unsafe Cipher Modes
dotnet_diagnostic.CA5359.severity = warning     # Do not disable certificate validation
dotnet_diagnostic.CA5360.severity = warning     # Do not call dangerous methods in deserialization
dotnet_diagnostic.CA5361.severity = warning     # Do not disable Schannel use of strong crypto
dotnet_diagnostic.CA5362.severity = warning     # Potential reference cycle in deserialized object graph
dotnet_diagnostic.CA5363.severity = warning     # Do not disable request validation
dotnet_diagnostic.CA5364.severity = warning     # Do not use deprecated security protocols
dotnet_diagnostic.CA5365.severity = warning     # Do Not Disable HTTP Header Checking
dotnet_diagnostic.CA5366.severity = warning     # Use XmlReader For DataSet Read XML
dotnet_diagnostic.CA5367.severity = warning     # Do Not Serialize Types With Pointer Fields
dotnet_diagnostic.CA5368.severity = warning     # Set ViewStateUserKey For Classes Derived From Page
dotnet_diagnostic.CA5369.severity = warning     # Use XmlReader for Deserialize
dotnet_diagnostic.CA5370.severity = warning     # Use XmlReader for validating reader
dotnet_diagnostic.CA5371.severity = warning     # Use XmlReader for schema read
dotnet_diagnostic.CA5372.severity = warning     # Use XmlReader for XPathDocument
dotnet_diagnostic.CA5373.severity = warning     # Do not use obsolete key derivation function
dotnet_diagnostic.CA5374.severity = warning     # Do Not Use XslTransform
dotnet_diagnostic.CA5375.severity = warning     # Do not use account shared access signature
dotnet_diagnostic.CA5376.severity = warning     # Use SharedAccessProtocol HttpsOnly
dotnet_diagnostic.CA5377.severity = warning     # Use container level access policy
dotnet_diagnostic.CA5378.severity = warning     # Do not disable ServicePointManagerSecurityProtocols
dotnet_diagnostic.CA5379.severity = warning     # Do not use weak key derivation function algorithm
dotnet_diagnostic.CA5380.severity = warning     # Do not add certificates to root store
dotnet_diagnostic.CA5381.severity = warning     # Ensure certificates are not added to root store
dotnet_diagnostic.CA5382.severity = warning     # Use secure cookies in ASP.NET Core
dotnet_diagnostic.CA5383.severity = warning     # Ensure use secure cookies in ASP.NET Core
dotnet_diagnostic.CA5384.severity = warning     # Do not use digital signature algorithm (DSA)
dotnet_diagnostic.CA5385.severity = warning     # Use Rivest–Shamir–Adleman (RSA) algorithm with sufficient key size
dotnet_diagnostic.CA5386.severity = warning     # Avoid hardcoding SecurityProtocolType value
dotnet_diagnostic.CA5387.severity = warning     # Do not use weak key derivation function with insufficient iteration count
dotnet_diagnostic.CA5388.severity = warning     # Ensure sufficient iteration count when using weak key derivation function
dotnet_diagnostic.CA5389.severity = warning     # Do not add archive item's path to the target file system path
dotnet_diagnostic.CA5390.severity = warning     # Do not hard-code encryption key
dotnet_diagnostic.CA5391.severity = warning     # Use antiforgery tokens in ASP.NET Core MVC controllers
dotnet_diagnostic.CA5392.severity = warning     # Use DefaultDllImportSearchPaths attribute for P/Invokes
dotnet_diagnostic.CA5393.severity = warning     # Do not use unsafe DllImportSearchPath value
dotnet_diagnostic.CA5394.severity = warning     # Do not use insecure randomness
dotnet_diagnostic.CA5395.severity = warning     # Miss HttpVerb attribute for action methods
dotnet_diagnostic.CA5396.severity = warning     # Set HttpOnly to true for HttpCookie
dotnet_diagnostic.CA5397.severity = warning     # Do not use deprecated SslProtocols values
dotnet_diagnostic.CA5398.severity = warning     # Avoid hardcoded SslProtocols values
dotnet_diagnostic.CA5399.severity = warning     # Definitely disable HttpClient certificate revocation list check
dotnet_diagnostic.CA5400.severity = warning     # Ensure HttpClient certificate revocation list check is not disabled
dotnet_diagnostic.CA5401.severity = warning     # Do not use CreateEncryptor with non-default IV
dotnet_diagnostic.CA5402.severity = warning     # Use CreateEncryptor with the default IV
dotnet_diagnostic.CA5403.severity = warning     # Do not hard-code certificate
dotnet_diagnostic.CA5404.severity = warning     # Do not disable token validation checks
dotnet_diagnostic.CA5405.severity = warning     # Do not always skip token validation in delegates

dotnet_diagnostic.IL3000.severity = warning     # Avoid accessing Assembly file path when publishing as a single file
dotnet_diagnostic.IL3001.severity = warning     # Avoid accessing Assembly file path when publishing as a single-file
dotnet_diagnostic.IL3002.severity = warning     # Avoid calling members annotated with 'RequiresAssemblyFilesAttribute' when publishing as a single file

dotnet_diagnostic.IDE0003.severity = warning     # Remove this or Me qualification
dotnet_diagnostic.IDE0009.severity = none        # Add this or Me qualification
dotnet_diagnostic.IDE0032.severity = warning     # Use auto property
dotnet_diagnostic.IDE0040.severity = warning     # Add accessibility modifiers
dotnet_diagnostic.IDE0047.severity = warning     # Remove unnecessary parentheses
dotnet_diagnostic.IDE0048.severity = none        # Add parentheses for clarity
dotnet_diagnostic.IDE0054.severity = warning     # Use compound assignment
# Deaktiviert, da keine Ausschlüsse/Areas definiert werden können (warten auf https://github.com/dotnet/roslyn/issues/47832)
dotnet_diagnostic.IDE0058.severity = none     # Remove unused expression value
dotnet_diagnostic.IDE0059.severity = warning     # Remove unnecessary value assignment
dotnet_diagnostic.IDE0060.severity = warning     # Remove unused parameter
dotnet_diagnostic.IDE0062.severity = warning     # Make local function static
dotnet_diagnostic.IDE0063.severity = silent      # Use simple using statement
dotnet_diagnostic.IDE0065.severity = warning     # using directive placement
dotnet_diagnostic.IDE0066.severity = silent      # Use switch expression
dotnet_diagnostic.IDE0071.severity = warning     # Simplify interpolation
dotnet_diagnostic.IDE0074.severity = none        # Use coalesce compound assignment
dotnet_diagnostic.IDE0075.severity = warning     # Simplify conditional expression
dotnet_diagnostic.IDE0078.severity = warning     # Use pattern matching
dotnet_diagnostic.IDE0079.severity = suggestion  # Remove unnecessary suppression
dotnet_diagnostic.IDE0083.severity = warning     # Use pattern matching (not operator)
dotnet_diagnostic.IDE0084.severity = warning     # Use pattern matching (IsNot operator)
dotnet_diagnostic.IDE0090.severity = suggestion  # Simplify new expression
dotnet_diagnostic.IDE0001.severity = warning     # Simplify name
dotnet_diagnostic.IDE0002.severity = warning     # Simplify member access
dotnet_diagnostic.IDE0004.severity = warning     # Remove unnecessary cast
dotnet_diagnostic.IDE0005.severity = warning     # Remove unnecessary import
dotnet_diagnostic.IDE0010.severity = silent      # Add missing cases to switch statement
dotnet_diagnostic.IDE0035.severity = warning     # Remove unreachable code
dotnet_diagnostic.IDE0051.severity = none        # Remove unused private member
dotnet_diagnostic.IDE0052.severity = warning     # Remove unread private member
dotnet_diagnostic.IDE0064.severity = warning     # Make struct fields writable
dotnet_diagnostic.IDE0070.severity = warning     # Use System.HashCode.Combine
dotnet_diagnostic.IDE0072.severity = silent      # Add missing cases to switch expression
dotnet_diagnostic.IDE0076.severity = warning     # Remove invalid global SuppressMessageAttribute
dotnet_diagnostic.IDE0077.severity = warning     # Avoid legacy format target in global SuppressMessageAttribute
dotnet_diagnostic.IDE0080.severity = warning     # Remove unnecessary suppression operator
dotnet_diagnostic.IDE0082.severity = warning     # Convert typeof to nameof
dotnet_diagnostic.IDE0100.severity = warning     # Remove unnecessary equality operator
dotnet_diagnostic.IDE0110.severity = warning     # Remove unnecessary discard
dotnet_diagnostic.IDE0130.severity = warning     # Namespace does not match folder structure
dotnet_diagnostic.IDE1006.severity = warning     # Naming styles

# disabled because already handled with dotnet style options or code analysis
# dotnet_diagnostic.IDE0007.severity =             # Use var instead of explicit type
# dotnet_diagnostic.IDE0008.severity =             # Use explicit type instead of var
# dotnet_diagnostic.IDE0011.severity =             # Add braces
# dotnet_diagnostic.IDE0016.severity =             # Use throw expression
# dotnet_diagnostic.IDE0017.severity =             # Use object initializers
# dotnet_diagnostic.IDE0018.severity =             # Inline variable declaration
# dotnet_diagnostic.IDE0019.severity =             # Use pattern matching to avoid as followed by a null check
# dotnet_diagnostic.IDE0020.severity =             # Use pattern matching to avoid is check followed by a cast (with variable)
# dotnet_diagnostic.IDE0021.severity =             # Use expression body for constructors
# dotnet_diagnostic.IDE0022.severity =             # Use expression body for methods
# dotnet_diagnostic.IDE0023.severity =             # Use expression body for conversion operators
# dotnet_diagnostic.IDE0024.severity =             # Use expression body for operators
# dotnet_diagnostic.IDE0025.severity =             # Use expression body for properties
# dotnet_diagnostic.IDE0026.severity =             # Use expression body for indexers
# dotnet_diagnostic.IDE0027.severity =             # Use expression body for accessors
# dotnet_diagnostic.IDE0028.severity =             # Use collection initializers
# dotnet_diagnostic.IDE0029.severity =             # Use coalesce expression (non-nullable types)
# dotnet_diagnostic.IDE0030.severity =             # Use coalesce expression (nullable types)
# dotnet_diagnostic.IDE0031.severity =             # Use null propagation
# dotnet_diagnostic.IDE0033.severity =             # Use explicitly provided tuple name
# dotnet_diagnostic.IDE0034.severity =             # Simplify default expression
# dotnet_diagnostic.IDE0036.severity =             # Order modifiers
# dotnet_diagnostic.IDE0037.severity =             # Use inferred member name
# dotnet_diagnostic.IDE0038.severity =             # Use pattern matching to avoid is check followed by a cast (without variable)
# dotnet_diagnostic.IDE0039.severity =             # Use local function instead of lambda
# dotnet_diagnostic.IDE0041.severity =             # Use is null check
# dotnet_diagnostic.IDE0042.severity =             # Deconstruct variable declaration
# dotnet_diagnostic.IDE0044.severity =             # Add readonly modifier
# dotnet_diagnostic.IDE0045.severity =             # Use conditional expression for assignment
# dotnet_diagnostic.IDE0046.severity =             # Use conditional expression for return
# dotnet_diagnostic.IDE0049.severity =             # Use language keywords instead of framework type names for type references
# dotnet_diagnostic.IDE0053.severity =             # Use expression body for lambdas
# dotnet_diagnostic.IDE0056.severity =             # Use index operator
# dotnet_diagnostic.IDE0057.severity =             # Use range operator
# dotnet_diagnostic.IDE0061.severity =             # Use expression body for local functions
# dotnet_diagnostic.IDE0073.severity =             # Use file header
# dotnet_diagnostic.IDE0140.severity =             # Simplify object creation
# dotnet_diagnostic.IDE1005.severity =             # Use conditional delegate call
# dotnet_diagnostic.IDE0050.severity =             # Convert anonymous type to tuple
# dotnet_diagnostic.IDE0055.severity =             # Fix formatting
# dotnet_diagnostic.IDE0081.severity =             # Remove ByVal

###############################
# StyleCop.Analyzers          #
###############################

# Special Rules
dotnet_diagnostic.SA0001.severity = none        # XmlCommentAnalysisDisabled: All diagnostics of XML documentation comments has been disabled due to the current project configuration.
dotnet_diagnostic.SA0002.severity = error       # InvalidSettingsFile: The stylecop.json settings file could not be loaded due to a deserialization error.
# Spacing Rules
dotnet_diagnostic.SA1000.severity = warning     # KeywordsMustBeSpacedCorrectly: The spacing around a C# keyword is incorrect.
dotnet_diagnostic.SA1001.severity = warning     # CommasMustBeSpacedCorrectly: The spacing around a comma is incorrect, within a C# code file.
dotnet_diagnostic.SA1002.severity = warning     # SemicolonsMustBeSpacedCorrectly: The spacing around a semicolon is incorrect, within a C# code file.
dotnet_diagnostic.SA1003.severity = warning     # SymbolsMustBeSpacedCorrectly: The spacing around an operator symbol is incorrect, within a C# code file.
dotnet_diagnostic.SA1004.severity = warning     # DocumentationLinesMustBeginWithSingleSpace: A line within a documentation header above a C# element does not begin with a single space.
dotnet_diagnostic.SA1005.severity = warning     # SingleLineCommentsMustBeginWithSingleSpace: A single-line comment within a C# code file does not begin with a single space.
dotnet_diagnostic.SA1006.severity = warning     # PreprocessorKeywordsMustNotBePrecededBySpace: A C# preprocessor-type keyword is preceded by space.
dotnet_diagnostic.SA1007.severity = warning     # OperatorKeywordMustBeFollowedBySpace: The operator keyword within a C# operator overload method is not followed by any whitespace.
dotnet_diagnostic.SA1008.severity = warning     # OpeningParenthesisMustBeSpacedCorrectly: An opening parenthesis within a C# statement is not spaced correctly.
dotnet_diagnostic.SA1009.severity = none        # ClosingParenthesisMustBeSpacedCorrectly: A closing parenthesis within a C# statement is not spaced correctly.
dotnet_diagnostic.SA1010.severity = warning     # OpeningSquareBracketsMustBeSpacedCorrectly: An opening square bracket within a C# statement is not spaced correctly.
dotnet_diagnostic.SA1011.severity = warning     # ClosingSquareBracketsMustBeSpacedCorrectly: A closing square bracket within a C# statement is not spaced correctly.
dotnet_diagnostic.SA1012.severity = warning     # OpeningBracesMustBeSpacedCorrectly: An opening brace within a C# element is not spaced correctly.
dotnet_diagnostic.SA1013.severity = warning     # ClosingBracesMustBeSpacedCorrectly: A closing brace within a C# element is not spaced correctly.
dotnet_diagnostic.SA1014.severity = warning     # OpeningGenericBracketsMustBeSpacedCorrectly: An opening generic bracket within a C# element is not spaced correctly.
dotnet_diagnostic.SA1015.severity = warning     # ClosingGenericBracketsMustBeSpacedCorrectly: A closing generic bracket within a C# element is not spaced correctly.
dotnet_diagnostic.SA1016.severity = warning     # OpeningAttributeBracketsMustBeSpacedCorrectly: An opening attribute bracket within a C# element is not spaced correctly.
dotnet_diagnostic.SA1017.severity = warning     # ClosingAttributeBracketsMustBeSpacedCorrectly: A closing attribute bracket within a C# element is not spaced correctly.
dotnet_diagnostic.SA1018.severity = warning     # NullableTypeSymbolsMustNotBePrecededBySpace: A nullable type symbol within a C# element is not spaced correctly.
dotnet_diagnostic.SA1019.severity = warning     # MemberAccessSymbolsMustBeSpacedCorrectly: The spacing around a member access symbol is incorrect, within a C# code file.
dotnet_diagnostic.SA1020.severity = warning     # IncrementDecrementSymbolsMustBeSpacedCorrectly: An increment or decrement symbol within a C# element is not spaced correctly.
dotnet_diagnostic.SA1021.severity = warning     # NegativeSignsMustBeSpacedCorrectly: A negative sign within a C# element is not spaced correctly.
dotnet_diagnostic.SA1022.severity = warning     # PositiveSignsMustBeSpacedCorrectly: A positive sign within a C# element is not spaced correctly.
dotnet_diagnostic.SA1023.severity = warning     # DereferenceAndAccessOfMustBeSpacedCorrectly: A dereference symbol or an access-of symbol within a C# element is not spaced correctly.
dotnet_diagnostic.SA1024.severity = warning     # ColonsMustBeSpacedCorrectly: A colon within a C# element is not spaced correctly.
dotnet_diagnostic.SA1025.severity = warning     # CodeMustNotContainMultipleWhitespaceInARow: The code contains multiple whitespace characters in a row.
dotnet_diagnostic.SA1026.severity = warning     # CodeMustNotContainSpaceAfterNewKeywordInImplicitlyTypedArrayAllocation: An implicitly typed new array allocation within a C# code file is not spaced correctly.
dotnet_diagnostic.SA1027.severity = warning     # UseTabsCorrectly: The code contains a tab or space character which is not consistent with the current project settings.
dotnet_diagnostic.SA1028.severity = warning     # CodeMustNotContainTrailingWhitespace: A line of code ends with a space, tab, or other whitespace characters before the end of line character(s).
# Readability Rules
dotnet_diagnostic.SA1100.severity = warning     # DoNotPrefixCallsWithBaseUnlessLocalImplementationExists: A call to a member from an inherited class begins with base., and the local class does not contain an override or implementation of the member.
dotnet_diagnostic.SA1101.severity = none        # PrefixLocalCallsWithThis: A call to an instance member of the local class or a base class is not prefixed with 'this.', within a C# code file.
dotnet_diagnostic.SA1102.severity = warning     # QueryClauses: A C# query clause does not begin on the same line as the previous clause, or on the next line.
dotnet_diagnostic.SA1103.severity = warning     # QueryClauses: The clauses within a C# query expression are not all placed on the same line, and each clause is not placed on its own line.
dotnet_diagnostic.SA1104.severity = warning     # QueryClauses: A clause within a C# query expression begins on the same line as the previous clause, when the previous clause spans across multiple lines.
dotnet_diagnostic.SA1105.severity = warning     # QueryClauses: A clause within a C# query expression spans across multiple lines, and does not begin on its own line.
dotnet_diagnostic.SA1106.severity = warning     # CodeMustNotContainEmptyStatements: The C# code contains an extra semicolon.
dotnet_diagnostic.SA1107.severity = warning     # CodeMustNotContainMultipleStatementsOnOneLine: The C# code contains more than one statement on a single line.
dotnet_diagnostic.SA1108.severity = silent      # BlockStatementsMustNotContainEmbeddedComments: A C# statement contains a comment between the declaration of the statement and the opening brace of the statement.
dotnet_diagnostic.SA1109.severity = warning     # BlockStatementsMustNotContainEmbeddedRegions: A C# statement contains a region tag between the declaration of the statement and the opening brace of the statement.
dotnet_diagnostic.SA1110.severity = warning     # OpeningParenthesisMustBeOnDeclarationLine: The opening parenthesis or bracket in a call to a C# method or indexer, or the declaration of a method or indexer, is not placed on the same line as the method or indexer name.
dotnet_diagnostic.SA1111.severity = warning     # ClosingParenthesisMustBeOnLineOfLastParameter: The closing parenthesis or bracket in a call to a C# method or indexer, or the declaration of a method or indexer, is not placed on the same line as the last parameter.
dotnet_diagnostic.SA1112.severity = warning     # ClosingParenthesisMustBeOnLineOfOpeningParenthesis: The closing parenthesis or bracket in a call to a C# method or indexer, or the declaration of a method or indexer, is not placed on the same line as the opening bracket when the element does not take any parameters.
dotnet_diagnostic.SA1113.severity = warning     # CommaMustBeOnSameLineAsPreviousParameter: A comma between two parameters in a call to a C# method or indexer, or in the declaration of a method or indexer, is not placed on the same line as the previous parameter.
dotnet_diagnostic.SA1114.severity = warning     # ParameterListMustFollowDeclaration: The start of the parameter list for a method or indexer call or declaration does not begin on the same line as the opening bracket, or on the line after the opening bracket.
dotnet_diagnostic.SA1115.severity = warning     # ParameterMustFollowComma: A parameter within a C# method or indexer call or declaration does not begin on the same line as the previous parameter, or on the next line.
dotnet_diagnostic.SA1116.severity = warning     # SplitParametersMustStartOnLineAfterDeclaration: The parameters to a C# method or indexer call or declaration span across multiple lines, but the first parameter does not start on the line after the opening bracket.
dotnet_diagnostic.SA1117.severity = warning     # ParametersMustBeOnSameLineOrSeparateLines: The parameters to a C# method or indexer call or declaration are not all on the same line or each on a separate line.
dotnet_diagnostic.SA1118.severity = warning     # ParameterMustNotSpanMultipleLines: A parameter to a C# method or indexer, other than the first parameter, spans across multiple lines.
dotnet_diagnostic.SA1120.severity = warning     # CommentsMustContainText: The C# comment does not contain any comment text.
dotnet_diagnostic.SA1121.severity = warning     # UseBuiltInTypeAlias: The code uses one of the basic C# types, but does not use the built-in alias for the type.
dotnet_diagnostic.SA1122.severity = warning     # UseStringEmptyForEmptyStrings: The C# code includes an empty string, written as "".
dotnet_diagnostic.SA1123.severity = warning     # DoNotPlaceRegionsWithinElements: The C# code contains a region within the body of a code element.
dotnet_diagnostic.SA1124.severity = silent      # DoNotUseRegions: The C# code contains a region.
dotnet_diagnostic.SA1125.severity = warning     # UseShorthandForNullableTypes: The Nullable type has been defined not using the C# shorthand.
dotnet_diagnostic.SA1126.severity = warning     # PrefixCallsCorrectly: A call to a member is not prefixed with the 'this.', 'base.', 'object.' or 'typename.' prefix to indicate the intended method call, within a C# code file.
dotnet_diagnostic.SA1127.severity = warning     # GenericTypeConstraintsMustBeOnOwnLine: A generic constraint on a type or method declaration is on the same line as the declaration, within a C# code file.
dotnet_diagnostic.SA1128.severity = warning     # ConstructorInitializerMustBeOnOwnLine: A constructor initializer is on the same line as the constructor declaration, within a C# code file.
dotnet_diagnostic.SA1129.severity = warning     # DoNotUseDefaultValueTypeConstructor: A value type was constructed using the syntax new T().
dotnet_diagnostic.SA1130.severity = warning     # UseLambdaSyntax: An anonymous method was declared using the form delegate (parameters) { }, when a lambda expression would provide equivalent behavior with the syntax (parameters) => { }.
dotnet_diagnostic.SA1131.severity = warning     # UseReadableConditions: A comparison was made between a variable and a literal or constant value, and the variable appeared on the right-hand side of the expression.
dotnet_diagnostic.SA1132.severity = warning     # DoNotCombineFields: Two or more fields were declared in the same field declaration syntax.
dotnet_diagnostic.SA1133.severity = warning     # DoNotCombineAttributes: Two or more attributes appeared within the same set of square brackets.
dotnet_diagnostic.SA1134.severity = warning     # AttributesMustNotShareLine: An attribute is placed on the same line of code as another attribute or element.
dotnet_diagnostic.SA1135.severity = warning     # UsingDirectivesMustBeQualified: A using directive is not qualified.
dotnet_diagnostic.SA1136.severity = warning     # EnumValuesShouldBeOnSeparateLines: Multiple enum values are placed on the same line of code.
dotnet_diagnostic.SA1137.severity = warning     # ElementsShouldHaveTheSameIndentation: Two sibling elements which each start on their own line have different levels of indentation.
dotnet_diagnostic.SA1139.severity = warning     # UseLiteralsSuffixNotationInsteadOfCasting: Use literal suffix notation instead of casting.
dotnet_diagnostic.SA1141.severity = warning     # UseTupleSyntax: Use tuple syntax instead of the underlying ValueTuple implementation type.
dotnet_diagnostic.SA1142.severity = warning     # ReferToTupleElementsByName: An element of a tuple was referenced by its metadata name when an element name is available.
# Ordering Rules
dotnet_diagnostic.SA1200.severity = none        # UsingDirectivesMustBePlacedCorrectly: A C# using directive is placed outside of a namespace element.
dotnet_diagnostic.SA1201.severity = warning     # ElementsMustAppearInTheCorrectOrder: An element within a C# code file is out of order in relation to the other elements in the code.
dotnet_diagnostic.SA1202.severity = warning     # ElementsMustBeOrderedByAccess: An element within a C# code file is out of order within regard to access level, in relation to other elements in the code.
dotnet_diagnostic.SA1203.severity = warning     # ConstantsMustAppearBeforeFields: A constant field is placed beneath a non-constant field.
dotnet_diagnostic.SA1204.severity = none        # StaticElementsMustAppearBeforeInstanceElements: A static element is positioned beneath an instance element of the same type.
dotnet_diagnostic.SA1205.severity = none        # PartialElementsMustDeclareAccess: The partial element does not have an access modifier defined.
dotnet_diagnostic.SA1206.severity = none        # DeclarationKeywordsMustFollowOrder: The keywords within the declaration of an element do not follow a standard ordering scheme.
dotnet_diagnostic.SA1207.severity = none        # ProtectedMustComeBeforeInternal: The keyword protected is positioned after the keyword internal within the declaration of a protected internal C# element.
dotnet_diagnostic.SA1208.severity = warning     # SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives: A using directive which declares a member of the System namespace appears after a using directive which declares a member of a different namespace, within a C# code file.
dotnet_diagnostic.SA1209.severity = warning     # UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives: A using-alias directive is positioned before a regular using directive.
dotnet_diagnostic.SA1210.severity = warning     # UsingDirectivesMustBeOrderedAlphabeticallyByNamespace: The using directives within a C# code file are not sorted alphabetically by namespace.
dotnet_diagnostic.SA1211.severity = warning     # UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName: The using-alias directives within a C# code file are not sorted alphabetically by alias name.
dotnet_diagnostic.SA1212.severity = warning     # PropertyAccessorsMustFollowOrder: A get accessor appears after a set accessor within a property or indexer.
dotnet_diagnostic.SA1213.severity = warning     # EventAccessorsMustFollowOrder: An add accessor appears after a remove accessor within an event.
dotnet_diagnostic.SA1214.severity = warning     # ReadonlyElementsMustAppearBeforeNonReadonlyElements: A readonly field is positioned beneath a non-readonly field.
dotnet_diagnostic.SA1215.severity = none        # InstanceReadonlyElementsMustAppearBeforeInstanceNonReadonlyElements: An instance readonly element is positioned beneath an instance non-readonly element of the same type.
dotnet_diagnostic.SA1216.severity = none        # UsingStaticDirectivesMustBePlacedAtTheCorrectLocation: A using static directive is positioned at the wrong location (before a regular using directive or after an alias using directive).
dotnet_diagnostic.SA1217.severity = none        # UsingStaticDirectivesMustBeOrderedAlphabetically: The using static directives within a C# code file are not sorted alphabetically by full type name.
# Naming Rules
dotnet_diagnostic.SA1300.severity = none        # ElementMustBeginWithUpperCaseLetter: The name of a C# element does not begin with an upper-case letter.
dotnet_diagnostic.SA1301.severity = none        # ElementMustBeginWithLowerCaseLetter: There are currently no situations in which this rule will fire.
dotnet_diagnostic.SA1302.severity = none        # InterfaceNamesMustBeginWithI: The name of a C# interface does not begin with the capital letter I.
dotnet_diagnostic.SA1303.severity = none        # ConstFieldNamesMustBeginWithUpperCaseLetter: The name of a constant C# field should begin with an upper-case letter.
dotnet_diagnostic.SA1304.severity = none        # NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter: The name of a non-private readonly C# field should being with an upper-case letter.
dotnet_diagnostic.SA1305.severity = none        # FieldNamesMustNotUseHungarianNotation: The name of a field or variable in C# uses Hungarian notation.
dotnet_diagnostic.SA1306.severity = none        # FieldNamesMustBeginWithLowerCaseLetter: The name of a field in C# does not begin with a lower-case letter.
dotnet_diagnostic.SA1307.severity = none        # AccessibleFieldsMustBeginWithUpperCaseLetter: The name of a public or internal field in C# does not begin with an upper-case letter.
dotnet_diagnostic.SA1308.severity = none        # VariableNamesMustNotBePrefixed: A field name in C# is prefixed with m_ or s_.
dotnet_diagnostic.SA1309.severity = none        # FieldNamesMustNotBeginWithUnderscore: A field name in C# begins with an underscore.
dotnet_diagnostic.SA1310.severity = none        # FieldNamesMustNotContainUnderscore: A field name in C# contains an underscore.
dotnet_diagnostic.SA1311.severity = none        # StaticReadonlyFieldsMustBeginWithUpperCaseLetter: The name of a static readonly field does not begin with an upper-case letter.
dotnet_diagnostic.SA1312.severity = none        # VariableNamesMustBeginWithLowerCaseLetter: The name of a variable in C# does not begin with a lower-case letter.
dotnet_diagnostic.SA1313.severity = warning     # ParameterNamesMustBeginWithLowerCaseLetter: The name of a parameter in C# does not begin with a lower-case letter.
dotnet_diagnostic.SA1314.severity = warning     # TypeParameterNamesMustBeginWithT: The name of a C# type parameter does not begin with the capital letter T.
dotnet_diagnostic.SA1316.severity = warning     # TupleElementNamesShouldUseCorrectCasing: Element names within a tuple type should have the correct casing.
# Maintainability Rules
dotnet_diagnostic.SA1119.severity = none        # StatementMustNotUseUnnecessaryParenthesis: A C# statement contains parenthesis which are unnecessary and should be removed.
dotnet_diagnostic.SA1400.severity = none        # AccessModifierMustBeDeclared: The access modifier for a C# element has not been explicitly defined.
dotnet_diagnostic.SA1401.severity = none        # FieldsMustBePrivate: A field within a C# class has an access modifier other than private.
dotnet_diagnostic.SA1402.severity = warning     # FileMayOnlyContainASingleType: A C# code file contains more than one unique type.
dotnet_diagnostic.SA1403.severity = warning     # FileMayOnlyContainASingleNamespace: A C# code file contains more than one namespace.
dotnet_diagnostic.SA1404.severity = warning     # CodeAnalysisSuppressionMustHaveJustification: A Code Analysis SuppressMessage attribute does not include a justification.
dotnet_diagnostic.SA1405.severity = warning     # DebugAssertMustProvideMessageText: A call to Debug.Assert in C# code does not include a descriptive message.
dotnet_diagnostic.SA1406.severity = warning     # DebugFailMustProvideMessageText: A call to Debug.Fail in C# code does not include a descriptive message.
dotnet_diagnostic.SA1407.severity = none        # ArithmeticExpressionsMustDeclarePrecedence: A C# statement contains a complex arithmetic expression which omits parenthesis around operators.
dotnet_diagnostic.SA1408.severity = none        # ConditionalExpressionsMustDeclarePrecedence: A C# statement contains a complex conditional expression which omits parenthesis around operators.
dotnet_diagnostic.SA1409.severity = none        # RemoveUnnecessaryCode: A C# file contains code which is unnecessary and can be removed without changing the overall logic of the code.
dotnet_diagnostic.SA1410.severity = warning     # RemoveDelegateParenthesisWhenPossible: A call to a C# anonymous method does not contain any method parameters, yet the statement still includes parenthesis.
dotnet_diagnostic.SA1411.severity = warning     # AttributeConstructorMustNotUseUnnecessaryParenthesis: An attribute declaration does not contain any parameters, yet it still includes parenthesis.
dotnet_diagnostic.SA1412.severity = warning     # StoreFilesAsUtf8: The encoding of the file is not UTF-8 with byte order mark.
dotnet_diagnostic.SA1413.severity = warning     # UseTrailingCommasInMultiLineInitializers: A multi-line initializer should use a comma on the last item.
dotnet_diagnostic.SA1414.severity = warning     # TupleTypesInSignaturesShouldHaveElementNames: Tuple types appearing in member declarations should have explicitly named tuple elements.
# Layout Rules
dotnet_diagnostic.SA1500.severity = warning     # BracesForMultiLineStatementsMustNotShareLine: The opening or closing brace within a C# statement, element, or expression is not placed on its own line.
dotnet_diagnostic.SA1501.severity = warning     # StatementMustNotBeOnSingleLine: A C# statement containing opening and closing braces is written completely on a single line.
dotnet_diagnostic.SA1502.severity = warning     # ElementMustNotBeOnSingleLine: A C# element containing opening and closing braces is written completely on a single line.
dotnet_diagnostic.SA1503.severity = none        # BracesMustNotBeOmitted: The opening and closing braces for a C# statement have been omitted.
dotnet_diagnostic.SA1504.severity = warning     # AllAccessorsMustBeSingleLineOrMultiLine: Within a C# property, indexer or event, at least one of the child accessors is written on a single line, and at least one of the child accessors is written across multiple lines.
dotnet_diagnostic.SA1505.severity = warning     # OpeningBracesMustNotBeFollowedByBlankLine: An opening brace within a C# element, statement, or expression is followed by a blank line.
dotnet_diagnostic.SA1506.severity = warning     # ElementDocumentationHeadersMustNotBeFollowedByBlankLine: An element documentation header above a C# element is followed by a blank line.
dotnet_diagnostic.SA1507.severity = warning     # CodeMustNotContainMultipleBlankLinesInARow: The C# code contains multiple blank lines in a row.
dotnet_diagnostic.SA1508.severity = warning     # ClosingBracesMustNotBePrecededByBlankLine: A closing brace within a C# element, statement, or expression is preceded by a blank line.
dotnet_diagnostic.SA1509.severity = warning     # OpeningBracesMustNotBePrecededByBlankLine: An opening brace within a C# element, statement, or expression is preceded by a blank line.
dotnet_diagnostic.SA1510.severity = warning     # ChainedStatementBlocksMustNotBePrecededByBlankLine: Chained C# statements are separated by a blank line.
dotnet_diagnostic.SA1511.severity = warning     # WhileDoFooterMustNotBePrecededByBlankLine: The while footer at the bottom of a do-while statement is separated from the statement by a blank line.
dotnet_diagnostic.SA1512.severity = none        # SingleLineCommentsMustNotBeFollowedByBlankLine: A single-line comment within C# code is followed by a blank line.
dotnet_diagnostic.SA1513.severity = warning     # ClosingBraceMustBeFollowedByBlankLine: A closing brace within a C# element, statement, or expression is not followed by a blank line.
dotnet_diagnostic.SA1514.severity = warning     # ElementDocumentationHeaderMustBePrecededByBlankLine: An element documentation header above a C# element is not preceded by a blank line.
dotnet_diagnostic.SA1515.severity = none        # SingleLineCommentMustBePrecededByBlankLine: A single-line comment within C# code is not preceded by a blank line.
dotnet_diagnostic.SA1516.severity = none        # ElementsMustBeSeparatedByBlankLine: Adjacent C# elements are not separated by a blank line.
dotnet_diagnostic.SA1517.severity = warning     # CodeMustNotContainBlankLinesAtStartOfFile: The code file has blank lines at the start.
dotnet_diagnostic.SA1518.severity = warning     # UseLineEndingsCorrectlyAtEndOfFile: The line endings at the end of a file do not match the settings for the project.
dotnet_diagnostic.SA1519.severity = none        # BracesMustNotBeOmittedFromMultiLineChildStatement: The opening and closing braces for a multi-line C# statement have been omitted.
dotnet_diagnostic.SA1520.severity = none        # UseBracesConsistently: The opening and closing braces of a chained if/else if/else construct were included for some clauses, but omitted for others.
# Documentation Rules
dotnet_diagnostic.SA1600.severity = none        # ElementsMustBeDocumented: A C# code element is missing a documentation header.
dotnet_diagnostic.SA1601.severity = none        # PartialElementsMustBeDocumented: A C# partial element is missing a documentation header.
dotnet_diagnostic.SA1602.severity = none        # EnumerationItemsMustBeDocumented: An item within a C# enumeration is missing an Xml documentation header.
dotnet_diagnostic.SA1603.severity = warning     # DocumentationMustContainValidXml: The Xml within a C# element's document header is badly formed.
dotnet_diagnostic.SA1604.severity = suggestion  # ElementDocumentationMustHaveSummary: The Xml header documentation for a C# element is missing a <summary> tag.
dotnet_diagnostic.SA1605.severity = suggestion  # PartialElementDocumentationMustHaveSummary: The <summary> or <content> tag within the documentation header for a C# code element is missing or empty.
dotnet_diagnostic.SA1606.severity = warning     # ElementDocumentationMustHaveSummaryText: The <summary> tag within the documentation header for a C# code element is empty.
dotnet_diagnostic.SA1607.severity = warning     # PartialElementDocumentationMustHaveSummaryText: The <summary> or <content> tag within the documentation header for a C# code element is empty.
dotnet_diagnostic.SA1608.severity = warning     # ElementDocumentationMustNotHaveDefaultSummary: The <summary> tag within an element's Xml header documentation contains the default text generated by Visual Studio during the creation of the element.
dotnet_diagnostic.SA1609.severity = none        # PropertyDocumentationMustHaveValue: The Xml header documentation for a C# property does not contain a <value> tag.
dotnet_diagnostic.SA1610.severity = warning     # PropertyDocumentationMustHaveValueText: The Xml header documentation for a C# property contains an empty <value> tag.
dotnet_diagnostic.SA1611.severity = suggestion  # ElementParametersMustBeDocumented: A C# method, constructor, delegate or indexer element is missing documentation for one or more of its parameters.
dotnet_diagnostic.SA1612.severity = warning     # ElementParameterDocumentationMustMatchElementParameters: The documentation describing the parameters to a C# method, constructor, delegate or indexer element does not match the actual parameters on the element.
dotnet_diagnostic.SA1613.severity = warning     # ElementParameterDocumentationMustDeclareParameterName: A <param> tag within a C# element's documentation header is missing a name attribute containing the name of the parameter.
dotnet_diagnostic.SA1614.severity = warning     # ElementParameterDocumentationMustHaveText: A <param> tag within a C# element's documentation header is empty.
dotnet_diagnostic.SA1615.severity = suggestion  # ElementReturnValueMustBeDocumented: A C# element is missing documentation for its return value.
dotnet_diagnostic.SA1616.severity = warning     # ElementReturnValueDocumentationMustHaveText: The <returns> tag within a C# element's documentation header is empty.
dotnet_diagnostic.SA1617.severity = warning     # VoidReturnValueMustNotBeDocumented: A C# code element does not contain a return value, or returns void, but the documentation header for the element contains a <returns> tag.
dotnet_diagnostic.SA1618.severity = suggestion  # GenericTypeParametersMustBeDocumented: A generic C# element is missing documentation for one or more of its generic type parameters.
dotnet_diagnostic.SA1619.severity = suggestion  # GenericTypeParametersMustBeDocumentedPartialClass: A generic, partial C# element is missing documentation for one or more of its generic type parameters, and the documentation for the element contains a <summary> tag.
dotnet_diagnostic.SA1620.severity = warning     # GenericTypeParameterDocumentationMustMatchTypeParameters: The <typeparam> tags within the Xml header documentation for a generic C# element do not match the generic type parameters on the element.
dotnet_diagnostic.SA1621.severity = warning     # GenericTypeParameterDocumentationMustDeclareParameterName: A <typeparam> tag within the Xml header documentation for a generic C# element is missing a name attribute, or contains an empty name attribute.
dotnet_diagnostic.SA1622.severity = warning     # GenericTypeParameterDocumentationMustHaveText: A <typeparam> tag within the Xml header documentation for a generic C# element is empty.
dotnet_diagnostic.SA1623.severity = none        # PropertySummaryDocumentationMustMatchAccessors: The documentation text within a C# property's <summary> tag does not match the accessors within the property.
dotnet_diagnostic.SA1624.severity = warning     # PropertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess: The documentation text within a C# property's <summary> tag takes into account all of the accessors within the property, but one of the accessors has limited access.
dotnet_diagnostic.SA1625.severity = warning     # ElementDocumentationMustNotBeCopiedAndPasted: The Xml documentation for a C# element contains two or more identical entries, indicating that the documentation has been copied and pasted.
dotnet_diagnostic.SA1626.severity = warning     # SingleLineCommentsMustNotUseDocumentationStyleSlashes: The C# code contains a single-line comment which begins with three forward slashes in a row.
dotnet_diagnostic.SA1627.severity = warning     # DocumentationTextMustNotBeEmpty: The Xml header documentation for a C# code element contains an empty tag.
dotnet_diagnostic.SA1628.severity = warning     # DocumentationTextMustBeginWithACapitalLetter: A section of the Xml header documentation for a C# element does not begin with a capital letter.
dotnet_diagnostic.SA1629.severity = warning     # DocumentationTextMustEndWithAPeriod: A section of the Xml header documentation for a C# element does not end with a period (also known as a full stop).
dotnet_diagnostic.SA1630.severity = warning     # DocumentationTextMustContainWhitespace: A section of the Xml header documentation for a C# element does not contain any whitespace between words.
dotnet_diagnostic.SA1631.severity = warning     # DocumentationMustMeetCharacterPercentage: A section of the Xml header documentation for a C# element does not contain enough alphabetic characters.
dotnet_diagnostic.SA1632.severity = none        # DocumentationTextMustMeetMinimumCharacterLength: From StyleCop 4.5 this rule is disabled by default.
dotnet_diagnostic.SA1633.severity = none        # FileMustHaveHeader: A C# code file is missing a standard file header.
dotnet_diagnostic.SA1634.severity = none        # FileHeaderMustShowCopyright: The file header at the top of a C# code file is missing a copyright tag.
dotnet_diagnostic.SA1635.severity = none        # FileHeaderMustHaveCopyrightText: The file header at the top of a C# code file is missing copyright text.
dotnet_diagnostic.SA1636.severity = none        # FileHeaderCopyrightTextMustMatch: The file header at the top of a C# code file does not contain the appropriate copyright text.
dotnet_diagnostic.SA1637.severity = none        # FileHeaderMustContainFileName: The file header at the top of a C# code file is missing the file name.
dotnet_diagnostic.SA1638.severity = none        # FileHeaderFileNameDocumentationMustMatchFileName: The file tag within the file header at the top of a C# code file does not contain the name of the file.
dotnet_diagnostic.SA1639.severity = none        # FileHeaderMustHaveSummary: The file header at the top of a C# code file does not contain a filled-in summary tag.
dotnet_diagnostic.SA1640.severity = none        # FileHeaderMustHaveValidCompanyText: The file header at the top of a C# code file does not contain company name text.
dotnet_diagnostic.SA1641.severity = none        # FileHeaderCompanyNameTextMustMatch: The file header at the top of a C# code file does not contain the appropriate company name text.
dotnet_diagnostic.SA1642.severity = suggestion  # ConstructorSummaryDocumentationMustBeginWithStandardText: The XML documentation header for a C# constructor does not contain the appropriate summary text.
dotnet_diagnostic.SA1643.severity = suggestion  # DestructorSummaryDocumentationMustBeginWithStandardText: The Xml documentation header for a C# finalizer does not contain the appropriate summary text.
dotnet_diagnostic.SA1644.severity = warning     # DocumentationHeadersMustNotContainBlankLines: A section within the Xml documentation header for a C# element contains blank lines.
dotnet_diagnostic.SA1645.severity = warning     # IncludedDocumentationFileDoesNotExist: An included Xml documentation file does not exist.
dotnet_diagnostic.SA1646.severity = warning     # IncludedDocumentationXPathDoesNotExist: An included Xml documentation link contains an invalid path.
dotnet_diagnostic.SA1647.severity = warning     # IncludeNodeDoesNotContainValidFileAndPath: An include tag within an Xml documentation header does not contain valid file and path attribute.
dotnet_diagnostic.SA1648.severity = warning     # InheritDocMustBeUsedWithInheritingClass: <inheritdoc> has been used on an element that doesn't inherit from a base class or implement an interface.
dotnet_diagnostic.SA1649.severity = warning     # FileNameMustMatchTypeName: The file name of a C# code file does not match the first type declared in the file.
dotnet_diagnostic.SA1650.severity = warning     # ElementDocumentationMustBeSpelledCorrectly: The element documentation for the element contains one or more spelling mistakes or unrecognized words.
dotnet_diagnostic.SA1651.severity = warning     # DoNotUsePlaceholderElements: The documentation for the element contains one or more <placeholder> elements.
dotnet_diagnostic.SA1652.severity = none        # EnableXmlDocumentationOutput: This rule was moved to SA0001
# Alternative Rules
dotnet_diagnostic.SX1101.severity = none        # DoNotPrefixLocalMembersWithThis: A call to an instance member of the local class or a base class is prefixed with 'this.', within a C# code file.
dotnet_diagnostic.SX1309.severity = none        # FieldNamesMustBeginWithUnderscore: A field name does not begin with an underscore.
dotnet_diagnostic.SX1309S.severity = none       # StaticFieldNamesMustBeginWithUnderscore: A static field name does not begin with an underscore.

# Microsoft.VisualStudio.Threading
dotnet_diagnostic.VSTHRD001.severity = warning  # Avoid legacy thread switching methods
dotnet_diagnostic.VSTHRD002.severity = warning  # Avoid problematic synchronous waits
dotnet_diagnostic.VSTHRD003.severity = warning  # Avoid awaiting foreign Tasks
dotnet_diagnostic.VSTHRD004.severity = warning  # Await SwitchToMainThreadAsync
dotnet_diagnostic.VSTHRD100.severity = warning  # Avoid async void methods
dotnet_diagnostic.VSTHRD101.severity = warning  # Avoid unsupported async delegates
dotnet_diagnostic.VSTHRD103.severity = warning  # Call async methods when in an async method
dotnet_diagnostic.VSTHRD105.severity = warning  # Avoid method overloads that assume TaskScheduler.Current
dotnet_diagnostic.VSTHRD106.severity = warning  # Use InvokeAsync to raise async events
dotnet_diagnostic.VSTHRD107.severity = warning  # Await Task within using expression
dotnet_diagnostic.VSTHRD110.severity = warning  # Observe result of async calls
dotnet_diagnostic.VSTHRD200.severity = warning  # Use Async naming convention
dotnet_diagnostic.VSTHRD011.severity = warning  # Use AsyncLazy<T>
dotnet_diagnostic.VSTHRD102.severity = warning  # Implement internal logic asynchronously
dotnet_diagnostic.VSTHRD010.severity = none     # Invoke single-threaded types on Main thread
dotnet_diagnostic.VSTHRD012.severity = none     # Provide JoinableTaskFactory where allowed
dotnet_diagnostic.VSTHRD104.severity = none     # Offer async option
dotnet_diagnostic.VSTHRD108.severity = none     # Assert thread affinity unconditionally
dotnet_diagnostic.VSTHRD109.severity = none     # Switch instead of assert in async methods
dotnet_diagnostic.VSTHRD111.severity = none     # Use .ConfigureAwait(bool)
dotnet_diagnostic.VSTHRD112.severity = none     # Implement System.IAsyncDisposable
dotnet_diagnostic.VSTHRD113.severity = none     # Check for System.IAsyncDisposable
dotnet_diagnostic.VSTHRD114.severity = none     # Avoid returning null from a Task-returning method.

[*.Designer.cs]
generated_code = true
dotnet_diagnostic.CA1501.severity = none     # Avoid excessive inheritance
dotnet_diagnostic.CA1502.severity = none     # Avoid excessive complexity
dotnet_diagnostic.CA1505.severity = none     # Avoid unmaintainable code
dotnet_diagnostic.CA1506.severity = none     # Avoid excessive class coupling
dotnet_diagnostic.CA1507.severity = none     # Use nameof in place of string
dotnet_diagnostic.CA1508.severity = none     # Avoid dead conditional code
dotnet_diagnostic.CA1509.severity = none     # Invalid entry in code metrics configuration file

dotnet_diagnostic.CA3001.severity = none     # Review code for SQL injection vulnerabilities
dotnet_diagnostic.CA3002.severity = none     # Review code for XSS vulnerabilities
dotnet_diagnostic.CA3003.severity = none     # Review code for file path injection vulnerabilities
dotnet_diagnostic.CA3004.severity = none     # Review code for information disclosure vulnerabilities
dotnet_diagnostic.CA3005.severity = none     # Review code for LDAP injection vulnerabilities
dotnet_diagnostic.CA3006.severity = none     # Review code for process command injection vulnerabilities
dotnet_diagnostic.CA3007.severity = none     # Review code for open redirect vulnerabilities
dotnet_diagnostic.CA3008.severity = none     # Review code for XPath injection vulnerabilities
dotnet_diagnostic.CA3009.severity = none     # Review code for XML injection vulnerabilities
dotnet_diagnostic.CA3010.severity = none     # Review code for XAML injection vulnerabilities
dotnet_diagnostic.CA3011.severity = none     # Review code for DLL injection vulnerabilities
dotnet_diagnostic.CA3012.severity = none     # Review code for regex injection vulnerabilities
dotnet_diagnostic.CA3061.severity = none     # Do not add schema by URL
dotnet_diagnostic.CA3075.severity = none     # Insecure DTD Processing
dotnet_diagnostic.CA3076.severity = none     # Insecure XSLT Script Execution
dotnet_diagnostic.CA3077.severity = none     # Insecure Processing in API Design, XML Document and XML Text Reader

dotnet_diagnostic.CA5350.severity = none     # Do Not Use Weak Cryptographic Algorithms
dotnet_diagnostic.CA5351.severity = none     # Do Not Use Broken Cryptographic Algorithms
dotnet_diagnostic.CA5358.severity = none     # Do Not Use Unsafe Cipher Modes
dotnet_diagnostic.CA5359.severity = none     # Do not disable certificate validation
dotnet_diagnostic.CA5360.severity = none     # Do not call dangerous methods in deserialization
dotnet_diagnostic.CA5361.severity = none     # Do not disable Schannel use of strong crypto
dotnet_diagnostic.CA5362.severity = none     # Potential reference cycle in deserialized object graph
dotnet_diagnostic.CA5363.severity = none     # Do not disable request validation
dotnet_diagnostic.CA5364.severity = none     # Do not use deprecated security protocols
dotnet_diagnostic.CA5365.severity = none     # Do Not Disable HTTP Header Checking
dotnet_diagnostic.CA5366.severity = none     # Use XmlReader For DataSet Read XML
dotnet_diagnostic.CA5367.severity = none     # Do Not Serialize Types With Pointer Fields
dotnet_diagnostic.CA5368.severity = none     # Set ViewStateUserKey For Classes Derived From Page
dotnet_diagnostic.CA5369.severity = none     # Use XmlReader for Deserialize
dotnet_diagnostic.CA5370.severity = none     # Use XmlReader for validating reader
dotnet_diagnostic.CA5371.severity = none     # Use XmlReader for schema read
dotnet_diagnostic.CA5372.severity = none     # Use XmlReader for XPathDocument
dotnet_diagnostic.CA5373.severity = none     # Do not use obsolete key derivation function
dotnet_diagnostic.CA5374.severity = none     # Do Not Use XslTransform
dotnet_diagnostic.CA5375.severity = none     # Do not use account shared access signature
dotnet_diagnostic.CA5376.severity = none     # Use SharedAccessProtocol HttpsOnly
dotnet_diagnostic.CA5377.severity = none     # Use container level access policy
dotnet_diagnostic.CA5378.severity = none     # Do not disable ServicePointManagerSecurityProtocols
dotnet_diagnostic.CA5379.severity = none     # Do not use weak key derivation function algorithm
dotnet_diagnostic.CA5380.severity = none     # Do not add certificates to root store
dotnet_diagnostic.CA5381.severity = none     # Ensure certificates are not added to root store
dotnet_diagnostic.CA5382.severity = none     # Use secure cookies in ASP.NET Core
dotnet_diagnostic.CA5383.severity = none     # Ensure use secure cookies in ASP.NET Core
dotnet_diagnostic.CA5384.severity = none     # Do not use digital signature algorithm (DSA)
dotnet_diagnostic.CA5385.severity = none     # Use Rivest–Shamir–Adleman (RSA) algorithm with sufficient key size
dotnet_diagnostic.CA5386.severity = none     # Avoid hardcoding SecurityProtocolType value
dotnet_diagnostic.CA5387.severity = none     # Do not use weak key derivation function with insufficient iteration count
dotnet_diagnostic.CA5388.severity = none     # Ensure sufficient iteration count when using weak key derivation function
dotnet_diagnostic.CA5389.severity = none     # Do not add archive item's path to the target file system path
dotnet_diagnostic.CA5390.severity = none     # Do not hard-code encryption key
dotnet_diagnostic.CA5391.severity = none     # Use antiforgery tokens in ASP.NET Core MVC controllers
dotnet_diagnostic.CA5392.severity = none     # Use DefaultDllImportSearchPaths attribute for P/Invokes
dotnet_diagnostic.CA5393.severity = none     # Do not use unsafe DllImportSearchPath value
dotnet_diagnostic.CA5394.severity = none     # Do not use insecure randomness
dotnet_diagnostic.CA5395.severity = none     # Miss HttpVerb attribute for action methods
dotnet_diagnostic.CA5396.severity = none     # Set HttpOnly to true for HttpCookie
dotnet_diagnostic.CA5397.severity = none     # Do not use deprecated SslProtocols values
dotnet_diagnostic.CA5398.severity = none     # Avoid hardcoded SslProtocols values
dotnet_diagnostic.CA5399.severity = none     # Definitely disable HttpClient certificate revocation list check
dotnet_diagnostic.CA5400.severity = none     # Ensure HttpClient certificate revocation list check is not disabled
dotnet_diagnostic.CA5401.severity = none     # Do not use CreateEncryptor with non-default IV
dotnet_diagnostic.CA5402.severity = none     # Use CreateEncryptor with the default IV
dotnet_diagnostic.CA5403.severity = none     # Do not hard-code certificate
