SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
C#

C# static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your C# code

  • All rules 493
  • Vulnerability46
  • Bug88
  • Security Hotspot24
  • Code Smell335

  • Quick Fix 61
 
Tags
    Impact
      Clean code attribute
        1. Parameter names should match base declaration and other partial definitions

           Code Smell
        2. "goto" statement should not be used

           Code Smell
        3. Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression

           Code Smell
        4. Literal suffixes should be upper case

           Code Smell
        5. First/Single should be used instead of FirstOrDefault/SingleOrDefault on collections that are known to be non-empty

           Code Smell
        6. Actions that return a value should be annotated with ProducesResponseTypeAttribute containing the return type

           Code Smell
        7. ModelState.IsValid should be called in controller actions

           Code Smell
        8. Awaitable method should be used

           Code Smell
        9. REST API actions should be annotated with an HTTP verb attribute

           Code Smell
        10. Value type property used as input in a controller action should be nullable, required or annotated with the JsonRequiredAttribute to avoid under-posting.

           Code Smell
        11. You should pool HTTP connections with HttpClientFactory

           Code Smell
        12. API Controllers should derive from ControllerBase instead of Controller

           Code Smell
        13. Controllers should not have mixed responsibilities

           Code Smell
        14. A Route attribute should be added to the controller when a route template is specified at the action level

           Code Smell
        15. Use model binding instead of reading raw request data

           Code Smell
        16. ASP.NET controller actions should not have a route template starting with "/"

           Code Smell
        17. Parameters with SupplyParameterFromQuery attribute should be used only in routable components

           Code Smell
        18. Using lambda expressions in loops should be avoided in Blazor markup section

           Code Smell
        19. Use PascalCase for named placeholders

           Code Smell
        20. "Trace.WriteLineIf" should not be used with "TraceSwitch" levels

           Code Smell
        21. Log message template placeholders should be in the right order

           Code Smell
        22. Generic logger injection should match enclosing type

           Code Smell
        23. "Trace.Write" and "Trace.WriteLine" should not be used

           Code Smell
        24. Logger field or property name should comply with a naming convention

           Code Smell
        25. Logging arguments should be passed to the correct parameter

           Code Smell
        26. Logging in a catch clause should pass the caught exception as a parameter.

           Code Smell
        27. The code block contains too many logging calls

           Code Smell
        28. "string.Create" should be used instead of "FormattableString"

           Code Smell
        29. "Contains" should be used instead of "Any" for simple equality checks

           Code Smell
        30. "First" and "Last" properties of "LinkedList" should be used instead of the "First()" and "Last()" extension methods

           Code Smell
        31. The lambda parameter should be used instead of capturing arguments in "ConcurrentDictionary" methods

           Code Smell
        32. "StartsWith" and "EndsWith" overloads that take a "char" should be used instead of the ones that take a "string"

           Code Smell
        33. "Min/Max" properties of "Set" types should be used instead of the "Enumerable" extension methods

           Code Smell
        34. Prefer indexing instead of "Enumerable" methods on types implementing "IList"

           Code Smell
        35. The collection should be filtered before sorting by using "Where" before "OrderBy"

           Code Smell
        36. Collection-specific "Exists" method should be used instead of the "Any" extension

           Code Smell
        37. The collection-specific "TrueForAll" method should be used instead of the "All" extension

           Code Smell
        38. "Find" method should be used instead of the "FirstOrDefault" extension

           Code Smell
        39. Use the "UnixEpoch" field instead of creating "DateTime" instances that point to the beginning of the Unix epoch

           Code Smell
        40. Don't hardcode the format when turning dates and times to strings

           Code Smell
        41. Use a format provider when parsing date and time

           Code Smell
        42. Use "TimeZoneInfo.FindSystemTimeZoneById" without converting the timezones with "TimezoneConverter"

           Code Smell
        43. Use "DateTimeOffset" instead of "DateTime"

           Code Smell
        44. Use UTC when recording DateTime instants

           Code Smell
        45. Always set the "DateTimeKind" when creating new "DateTime" instances

           Code Smell
        46. Avoid using "DateTime.Now" for benchmarking or timing operations

           Code Smell
        47. "ExcludeFromCodeCoverage" attributes should include a justification

           Code Smell
        48. Interfaces for durable entities should satisfy the restrictions

           Code Smell
        49. Azure Functions should log all failures

           Code Smell
        50. Calls to "async" methods should not be blocking in Azure Functions

           Code Smell
        51. Azure Functions should use Structured Error Handling

           Code Smell
        52. Client instances should not be recreated on each Azure Function invocation

           Code Smell
        53. Azure Functions should be stateless

           Code Smell
        54. Use a testable date/time provider

           Code Smell
        55. "ValueTask" should be consumed correctly

           Code Smell
        56. Comments should not be empty

           Code Smell
        57. Start index should be used instead of calling Substring

           Code Smell
        58. "new Guid()" should not be used

           Code Smell
        59. "DebuggerDisplayAttribute" strings should reference existing members

           Code Smell
        60. "default" clauses should be first or last

           Code Smell
        61. Unread "private" fields should be removed

           Code Smell
        62. Calls to "async" methods should not be blocking

           Code Smell
        63. Parameter validation in "async"/"await" methods should be wrapped

           Code Smell
        64. Parameter validation in yielding methods should be wrapped

           Code Smell
        65. Methods should be named according to their synchronicities

           Code Smell
        66. Extensions should be in separate namespaces

           Code Smell
        67. Extension methods should not extend "object"

           Code Smell
        68. Events should have proper arguments

           Code Smell
        69. "P/Invoke" methods should not be visible

           Code Smell
        70. Null checks should not be combined with "is" operator checks

           Code Smell
        71. Native methods should be wrapped

           Code Smell
        72. Methods should not have identical implementations

           Code Smell
        73. Method overloads should be grouped together

           Code Smell
        74. Non-flags enums should not be marked with "FlagsAttribute"

           Code Smell
        75. Operator overloads should have named alternatives

           Code Smell
        76. "params" should be used instead of "varargs"

           Code Smell
        77. Non-abstract attributes should be sealed

           Code Smell
        78. Property names should not match get methods

           Code Smell
        79. Overloads with a "StringComparison" parameter should be used

           Code Smell
        80. Locales should be set for data types

           Code Smell
        81. Overloads with a "CultureInfo" or an "IFormatProvider" parameter should be used

           Code Smell
        82. Literals should not be passed as localized parameters

           Code Smell
        83. Types should not extend outdated base types

           Code Smell
        84. Operators should be overloaded consistently

           Code Smell
        85. Properties should be preferred

           Code Smell
        86. Generics should be used when appropriate

           Code Smell
        87. Type names should not match namespaces

           Code Smell
        88. Strings should be normalized to uppercase

           Code Smell
        89. Interface methods should be callable by derived types

           Code Smell
        90. Classes implementing "IEquatable<T>" should be sealed

           Code Smell
        91. Exceptions should provide standard constructors

           Code Smell
        92. Assemblies should be marked with "NeutralResourcesLanguageAttribute"

           Code Smell
        93. Child class fields should not differ from parent class fields only by capitalization

           Code Smell
        94. Interfaces should not be empty

           Code Smell
        95. Enumerations should have "Int32" storage

           Code Smell
        96. Base class methods should not be hidden

           Code Smell
        97. All type parameters should be used in the parameter list to enable type inference

           Code Smell
        98. Method signatures should not contain nested generic types

           Code Smell
        99. Enumeration members should not be named "Reserved"

           Code Smell
        100. Inherited member visibility should not be decreased

           Code Smell
        101. "System.Uri" arguments should be used instead of strings

           Code Smell
        102. Collection properties should be readonly

           Code Smell
        103. Disposable types should declare finalizers

           Code Smell
        104. Pointers to unmanaged memory should not be visible

           Code Smell
        105. Threads should not lock on objects with weak identity

           Code Smell
        106. String URI overloads should call "System.Uri" overloads

           Code Smell
        107. URI properties should not be strings

           Code Smell
        108. URI return values should not be strings

           Code Smell
        109. URI Parameters should not be strings

           Code Smell
        110. Custom attributes should be marked with "System.AttributeUsageAttribute"

           Code Smell
        111. Assemblies should explicitly specify COM visibility

           Code Smell
        112. Assemblies should be marked as CLS compliant

           Code Smell
        113. A conditionally executed single line should be denoted by indentation

           Code Smell
        114. Conditionals should start on new lines

           Code Smell
        115. "GC.SuppressFinalize" should not be called

           Code Smell
        116. Multidimensional arrays should not be used

           Code Smell
        117. Objects should not be disposed more than once

           Code Smell
        118. "static" fields should be initialized inline

           Code Smell
        119. "static readonly" constants should be "const" instead

           Code Smell
        120. "Generic.List" instances should not be part of public APIs

           Code Smell
        121. Number patterns should be regular

           Code Smell
        122. Parameter names used into ArgumentException constructors should match an existing one

           Code Smell
        123. "ISerializable" should be implemented correctly

           Code Smell
        124. Collections should implement the generic interface

           Code Smell
        125. Generic event handlers should be used

           Code Smell
        126. Event Handlers should have the correct signature

           Code Smell
        127. Assemblies should have version information

           Code Smell
        128. "Assembly.GetExecutingAssembly" should not be called

           Code Smell
        129. Arguments of public methods should be validated against null

           Code Smell
        130. Value types should implement "IEquatable<T>"

           Code Smell
        131. Classes that provide "Equals(<T>)" should implement "IEquatable<T>"

           Code Smell
        132. "Assembly.Load" should be used

           Code Smell
        133. "IDisposable" should be implemented correctly

           Code Smell
        134. Finalizers should not be empty

           Code Smell
        135. Arrays should not be created for params parameters

           Code Smell
        136. Exceptions should not be thrown from unexpected methods

           Code Smell
        137. Strings or integral types should be used for indexers

           Code Smell
        138. "operator==" should not be overloaded on reference types

           Code Smell
        139. "out" and "ref" parameters should not be used

           Code Smell
        140. Parameter names should not duplicate the names of their methods

           Code Smell
        141. Exception types should be "public"

           Code Smell
        142. Cognitive Complexity of methods should not be too high

           Code Smell
        143. Track use of "NotImplementedException"

           Code Smell
        144. Jump statements should not be redundant

           Code Smell
        145. Member initializer values should not be redundant

           Code Smell
        146. "params" should not be introduced on overrides

           Code Smell
        147. "ServiceContract" and "OperationContract" attributes should be used together

           Code Smell
        148. Empty "default" clauses should be removed

           Code Smell
        149. Unassigned members should be removed

           Code Smell
        150. Empty "case" clauses that fall through to the "default" should be omitted

           Code Smell
        151. Composite format strings should be used correctly

           Code Smell
        152. "[DefaultValue]" should not be used when "[DefaultParameterValue]" is meant

           Code Smell
        153. Parameters with "[DefaultParameterValue]" attributes should also be marked "[Optional]"

           Code Smell
        154. "[Optional]" should not be used on "ref" or "out" parameters

           Code Smell
        155. Exceptions should not be explicitly rethrown

           Code Smell
        156. Interfaces should not simply inherit from base interfaces with colliding members

           Code Smell
        157. Type should not be examined on "System.Type" instances

           Code Smell
        158. "abstract" classes should not have "public" constructors

           Code Smell
        159. Redundant property names should be omitted in anonymous classes

           Code Smell
        160. Variables should not be checked against the values they're about to be assigned

           Code Smell
        161. Test method signatures should be correct

           Code Smell
        162. "[ExpectedException]" should not be used

           Code Smell
        163. Method overloads with default parameter values should not overlap

           Code Smell
        164. Loggers should be named for their enclosing types

           Code Smell
        165. Assertion arguments should be passed in the correct order

           Code Smell
        166. Methods should not return constants

           Code Smell
        167. "private" methods called only by inner classes should be moved to those classes

           Code Smell
        168. Attribute, EventArgs, and Exception type names should end with the type being extended

           Code Smell
        169. "this" should not be exposed from constructors

           Code Smell
        170. Ternary operators should not be nested

           Code Smell
        171. Unchanged variables should be marked as "const"

           Code Smell
        172. Loops should be simplified with "LINQ" expressions

           Code Smell
        173. Non-flags enums should not be used in bitwise operations

           Code Smell
        174. Events should be invoked

           Code Smell
        175. "params" should be used on overrides

           Code Smell
        176. Namespaces should not be empty

           Code Smell
        177. Non-derived "private" classes and records should be "sealed"

           Code Smell
        178. Declarations and initializations should be as concise as possible

           Code Smell
        179. "string.IsNullOrEmpty" should be used

           Code Smell
        180. Default parameter values should not be passed as arguments

           Code Smell
        181. Constructor and destructor declarations should not be redundant

           Code Smell
        182. Implementations should be provided for "partial" methods

           Code Smell
        183. Duplicate casts should not be made

           Code Smell
        184. Generic type parameters should be co/contravariant when possible

           Code Smell
        185. Method parameters should be declared with base types

           Code Smell
        186. Methods should not return values that are never used

           Code Smell
        187. The simplest possible condition syntax should be used

           Code Smell
        188. "value" contextual keyword should be used

           Code Smell
        189. Caller information arguments should not be provided explicitly

           Code Smell
        190. Redundant parentheses should not be used

           Code Smell
        191. "GC.SuppressFinalize" should not be invoked for types without destructors

           Code Smell
        192. Method calls should not resolve ambiguously to overloads with "params"

           Code Smell
        193. Inner class members should not shadow outer class "static" or type members

           Code Smell
        194. "Explicit" conversions of "foreach" loops should not be used

           Code Smell
        195. "ConfigureAwait(false)" should be used

           Code Smell
        196. "interface" instances should not be cast to concrete types

           Code Smell
        197. Multiple "OrderBy" calls should not be used

           Code Smell
        198. "StringBuilder" data should be used

           Code Smell
        199. "is" should not be used with "this"

           Code Smell
        200. Types should not have members with visibility set higher than the type's visibility

           Code Smell
        201. Members should not be initialized to default values

           Code Smell
        202. Reflection should not be used to increase accessibility of classes, methods, or fields

           Code Smell
        203. Static fields should not be updated in constructors

           Code Smell
        204. LINQ expressions should be simplified

           Code Smell
        205. Assertions should be complete

           Code Smell
        206. Methods named "Dispose" should implement "IDisposable.Dispose"

           Code Smell
        207. Fields that are only assigned in the constructor should be "readonly"

           Code Smell
        208. "Thread.Sleep" should not be used in tests

           Code Smell
        209. Sequential tests should not check the same condition

           Code Smell
        210. Static fields should not be used in generic types

           Code Smell
        211. "catch" clauses should do more than rethrow

           Code Smell
        212. Literal boolean values should not be used in assertions

           Code Smell
        213. Tests should include assertions

           Code Smell
        214. Instance members should not write to "static" fields

           Code Smell
        215. "IndexOf" checks should not be for positive numbers

           Code Smell
        216. Multiline blocks should be enclosed in curly braces

           Code Smell
        217. Logging templates should be constant

           Code Smell
        218. Boolean expressions should not be gratuitous

           Code Smell
        219. Generic exceptions should not be ignored

           Code Smell
        220. Whitespace and control characters in string literals should be explicit

           Code Smell
        221. Unnecessary bit operations should not be performed

           Code Smell
        222. Types and methods should not have too many generic parameters

           Code Smell
        223. Child class fields should not shadow parent class fields

           Code Smell
        224. Mutable fields should not be "public static"

           Code Smell
        225. Write-only properties should not be used

           Code Smell
        226. Exceptions should not be thrown from property getters

           Code Smell
        227. Public methods should not have multidimensional array parameters

           Code Smell
        228. Properties should not make collection or array copies

           Code Smell
        229. Optional parameters should not be used

           Code Smell
        230. Fields should be private

           Code Smell
        231. Flags enumerations zero-value members should be named "None"

           Code Smell
        232. Enumeration type names should not have "Flags" or "Enum" suffixes

           Code Smell
        233. Enumeration types should comply with a naming convention

           Code Smell
        234. Public constant members should not be used

           Code Smell
        235. Redundant modifiers should not be used

           Code Smell
        236. Array covariance should not be used

           Code Smell
        237. "try" statements with identical "catch" and/or "finally" blocks should be merged

           Code Smell
        238. Unused type parameters should be removed

           Code Smell
        239. Methods and properties that don't access instance data should be static

           Code Smell
        240. "async" and "await" should not be used as identifiers

           Code Smell
        241. "nameof" should be used

           Code Smell
        242. Trivial properties should be auto-implemented

           Code Smell
        243. Overflow checking should not be disabled for "Enumerable.Sum"

           Code Smell
        244. Field-like events should not be virtual

           Code Smell
        245. Arguments should be passed in the same order as the method parameters

           Code Smell
        246. Non-constant static fields should not be visible

           Code Smell
        247. "Exception" should not be caught

           Code Smell
        248. Runtime type checking should be simplified

           Code Smell
        249. Unnecessary mathematical comparisons should not be made

           Code Smell
        250. Modulus results should not be checked for direct equality

           Code Smell
        251. Test classes should contain at least one test case

           Code Smell
        252. Short-circuit logic should be used in boolean contexts

           Code Smell
        253. Classes named like "Exception" should extend "Exception" or a subclass

           Code Smell
        254. "sealed" classes should not have "protected" members

           Code Smell
        255. Underscores should be used to make large numbers readable

           Code Smell
        256. Exceptions should be either logged or rethrown but not both

           Code Smell
        257. Classes should not be empty

           Code Smell
        258. "for" loop increment clauses should modify the loops' counters

           Code Smell
        259. Invalid casts should be avoided

           Code Smell
        260. Boolean checks should not be inverted

           Code Smell
        261. Inheritance list should not be redundant

           Code Smell
        262. Redundant casts should not be used

           Code Smell
        263. Two branches in a conditional structure should not have exactly the same implementation

           Code Smell
        264. "ToString()" calls should not be redundant

           Code Smell
        265. Unused assignments should be removed

           Code Smell
        266. "switch" statements should not be nested

           Code Smell
        267. Constructors should only call non-overridable methods

           Code Smell
        268. "==" should not be used when "Equals" is overridden

           Code Smell
        269. NullReferenceException should not be caught

           Code Smell
        270. An abstract class should have both abstract and concrete methods

           Code Smell
        271. Multiple variables should not be declared on the same line

           Code Smell
        272. Strings should not be concatenated using '+' in a loop

           Code Smell
        273. Tests should not be ignored

           Code Smell
        274. Methods and properties should not be too complex

           Code Smell
        275. Unused local variables should be removed

           Code Smell
        276. "switch" statements with many "case" clauses should have only one statement

           Code Smell
        277. Track lack of copyright and license headers

           Code Smell
        278. Private fields only used as local variables in methods should become local variables

           Code Smell
        279. Culture should be specified for "string" operations

           Code Smell
        280. Functions should not have too many lines of code

           Code Smell
        281. Control flow statements "if", "switch", "for", "foreach", "while", "do" and "try" should not be nested too deeply

           Code Smell
        282. Logger fields should be "private static readonly"

           Code Smell
        283. "switch/Select" statements should contain a "default/Case Else" clauses

           Code Smell
        284. Track uses of in-source issue suppressions

           Code Smell
        285. "switch" statements should have at least 3 "case" clauses

           Code Smell
        286. "for" loop stop conditions should be invariant

           Code Smell
        287. A "while" loop should be used instead of a "for" loop

           Code Smell
        288. "if ... else if" constructs should end with "else" clauses

           Code Smell
        289. Sections of code should not be commented out

           Code Smell
        290. break statements should not be used except for switch cases

           Code Smell
        291. Statements should be on separate lines

           Code Smell
        292. "GC.Collect" should not be called

           Code Smell
        293. "Equals" and the comparison operators should be overridden when implementing "IComparable"

           Code Smell
        294. Control structures should use curly braces

           Code Smell
        295. Classes should not be coupled to too many other classes

           Code Smell
        296. Nested code blocks should not be used

           Code Smell
        297. String literals should not be duplicated

           Code Smell
        298. Methods should not be empty

           Code Smell
        299. Overriding members should do more than simply call the same member in the base class

           Code Smell
        300. Unused method parameters should be removed

           Code Smell
        301. Empty arrays and collections should be returned instead of null

           Code Smell
        302. Exceptions should not be thrown in finally blocks

           Code Smell
        303. "Any()" should be used to test for emptiness

           Code Smell
        304. "switch case" clauses should not have too many lines of code

           Code Smell
        305. Exit methods should not be called

           Code Smell
        306. Unused private types or members should be removed

           Code Smell
        307. Track uses of "TODO" tags

           Code Smell
        308. Track uses of "FIXME" tags

           Code Smell
        309. Deprecated code should be removed

           Code Smell
        310. Files should end with a newline

           Code Smell
        311. Unnecessary "using" should be removed

           Code Smell
        312. Boolean literals should not be redundant

           Code Smell
        313. "Obsolete" attributes should include explanations

           Code Smell
        314. Assignments should not be made from within sub-expressions

           Code Smell
        315. General or reserved exceptions should never be thrown

           Code Smell
        316. Utility classes should not have public constructors

           Code Smell
        317. Local variables should not shadow class fields or properties

           Code Smell
        318. Empty statements should be removed

           Code Smell
        319. Redundant pairs of parentheses should be removed

           Code Smell
        320. A close curly brace should be located at the beginning of a line

           Code Smell
        321. Fields should not have public accessibility

           Code Smell
        322. Inheritance tree of classes should not be too deep

           Code Smell
        323. Magic numbers should not be used

           Code Smell
        324. Nested blocks of code should not be left empty

           Code Smell
        325. URIs should not be hardcoded

           Code Smell
        326. Methods should not have too many parameters

           Code Smell
        327. Expressions should not be too complex

           Code Smell
        328. Mergeable "if" statements should be combined

           Code Smell
        329. Standard outputs should not be used directly to log anything

           Code Smell
        330. Tabulation characters should not be used

           Code Smell
        331. Files should not have too many lines of code

           Code Smell
        332. Lines should not be too long

           Code Smell
        333. Types should be named in PascalCase

           Code Smell
        334. Method overrides should not change parameter defaults

           Code Smell
        335. Methods and properties should be named in PascalCase

           Code Smell

        Expressions should not be too complex

        adaptability - focused
        maintainability
        Code Smell
        • brain-overload

        Why is this an issue?

        The complexity of an expression is defined by the number of &&, || and condition ? ifTrue : ifFalse operators it contains.

        A single expression’s complexity should not become too high to keep the code readable.

        Noncompliant code example

        With the default threshold value of 3

        if (((condition1 && condition2) || (condition3 && condition4)) && condition5) { ... }
        

        Compliant solution

        if ((MyFirstCondition() || MySecondCondition()) && MyLastCondition()) { ... }
        
          Available In:
        • SonarQube IdeCatch issues on the fly,
          in your IDE
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories
        • SonarQube Community BuildAnalyze code in your
          on-premise CI
          Available Since
          9.1
        • SonarQube ServerAnalyze code in your
          on-premise CI
          Developer Edition
          Available Since
          9.1

        © 2008-2025 SonarSource SA. All rights reserved.

        Sonar helps developers write Clean Code.
        Privacy Policy | Cookie Policy | Terms of Use