Shared naming conventions allow teams to collaborate efficiently.
\nThis rule raises an issue when a method or a property name is not PascalCased.
\nFor example, the method
\n\npublic int doSomething() {...} // Noncompliant\n\nshould be renamed to
\n\npublic int DoSomething() {...}\n\nComImportAttribute or InterfaceTypeAttribute.extern methods.MyXMethod is compliant, but\n XM is not.'_' character.\nvoid My_method_(){...} // Noncompliant, leading and trailing underscores are reported\n\nvoid My_method(){...} // Compliant by exception\n\nMicrosoft Capitalization\nConventions
\n\n" }, { "path": "analyzers/rspec/cs/S100.json", "content": "{\n \"title\": \"Methods and properties should be named in PascalCase\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-100\",\n \"sqKey\": \"S100\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1006.html", "content": "\nclass Base\n{\n public virtual void Run(int distance = 42) { /* ... */ }\n}\n\nclass Derived : Base\n{\n public override void Run(int distance = 5) { /* ... */ }\n}\n\nBase x = new Base();\nx.Run(); // Here the default value of distance is 42\nDerived d = new Derived();\nd.Run(); // Here the default value of distance is 5\nBase b = new Derived();\nb.Run(); // Here the default value of distance is 42, not 5\n\nIf a default argument is different for a parameter in an overriding method, the value used in the call will be different when calls are made via\nthe base or derived object, which may be contrary to developer expectations.
\nDefault parameter values in
\ninterface IRunner\n{\n void Run(int distance = 42) { /* ... */ }\n}\n\nclass Runner : IRunner\n{\n void IRunner.Run(int distance = 5) { /* ... */ }\n}\n\nIRunner x = new Runner();\nx.Run(); // Here the default value of distance is 42\nRunner d = new Runner();\nd.Run(); // This will not compile as the Run method is only visible through the specified interface\n\n\nusing System;\n\npublic class Base\n{\n public virtual void Write(int i = 42)\n {\n Console.WriteLine(i);\n }\n}\n\npublic class Derived : Base\n{\n public override void Write(int i = 5) // Noncompliant\n {\n Console.WriteLine(i);\n }\n}\n\npublic class Program\n{\n public static void Main()\n {\n var derived = new Derived();\n derived.Write(); // writes 5\n Print(derived); // writes 42; was that expected?\n }\n\n private static void Print(Base item)\n {\n item.Write();\n }\n}\n\n\nusing System;\n\npublic class Base\n{\n public virtual void Write(int i = 42)\n {\n Console.WriteLine(i);\n }\n}\n\npublic class Derived : Base\n{\n public override void Write(int i = 42)\n {\n Console.WriteLine(i);\n }\n}\n\npublic class Program\n{\n public static void Main()\n {\n var derived = new Derived();\n derived.Write(); // writes 42\n Print(derived); // writes 42\n }\n\n private static void Print(Base item)\n {\n item.Write();\n }\n}\n\nShared naming conventions allow teams to collaborate efficiently.
\nThis rule raises an issue when a type name is not PascalCased.
\nFor example, the classes
\n\nclass my_class {...}\nclass SOMEName42 {...}\n\nshould be renamed to
\n\nclass MyClass {...}\nclass SomeName42 {...}\n\nComImportAttribute or InterfaceTypeAttribute.MyXClass is compliant,\n but XC is not.'_' characters in class names inside test projects: in that case, each word separated by '_'\n should be PascalCased.\nclass Some_Name___42 {...} // Compliant in tests\nclass Some_name___42 {...} // Noncompliant\nclass Some_Name_XC {...} // Noncompliant because of XC, should be Some_Name_Xc\n\nScrolling horizontally to see a full line of code lowers the code readability.
\n\n" }, { "path": "analyzers/rspec/cs/S103.json", "content": "{\n \"title\": \"Lines should not be too long\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-103\",\n \"sqKey\": \"S103\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S104.html", "content": "When a source file grows too much, it can accumulate numerous responsibilities and become challenging to understand and maintain.
\nAbove a specific threshold, refactor the file into smaller files whose code focuses on well-defined tasks. Those smaller files will be easier to\nunderstand and test.
\n\n" }, { "path": "analyzers/rspec/cs/S104.json", "content": "{\n \"title\": \"Files should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1h\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-104\",\n \"sqKey\": \"S104\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1048.html", "content": "The finalizers are used to perform\nany necessary final clean-up when\nthe garbage collector is collecting a class instance. The programmer has no control over when the finalizer is called; the garbage collector decides\nwhen to call it.
\nWhen creating a finalizer, it should never throw an exception, as there is a high risk of having the application terminated leaving unmanaged\nresources without a graceful cleanup.
\nThe rule raises an issue on throw statements used in a finalizer.
\nclass MyClass\n{\n ~MyClass()\n {\n throw new NotImplementedException(); // Noncompliant: finalizer throws an exception\n }\n}\n\n\nclass MyClass\n{\n ~MyClass()\n {\n // Compliant: finalizer does not throw an exception\n }\n}\n\nIn general object finalization can be a complex and error-prone operation and should not be implemented except within the
When cleaning up unmanaged resources, it is\nrecommended to implement the dispose pattern or, to cover uncalled Dispose method by the consumer, implement SafeHandle.
SafeHandle\n ClassIDisposable.Dispose\n MethodThe tab width can differ from one development environment to another. Using tabs may require other developers to configure their environment (text\neditor, preferences, etc.) to read source code.
\nThat is why using spaces is preferable.
\n\n" }, { "path": "analyzers/rspec/cs/S105.json", "content": "{\n \"title\": \"Tabulation characters should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-105\",\n \"sqKey\": \"S105\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S106.html", "content": "In software development, logs serve as a record of events within an application, providing crucial insights for debugging. When logging, it is\nessential to ensure that the logs are:
\nThose requirements are not met if a program directly writes to the standard outputs (e.g., Console). That is why defining and using a dedicated\nlogger is highly recommended.
\nThe rule doesn’t raise an issue for:
\n[Conditional (\"DEBUG\")]#if DEBUG)The following noncompliant code:
\n\npublic class MyClass\n{\n private void DoSomething()\n {\n // ...\n Console.WriteLine(\"My Message\"); // Noncompliant\n // ...\n }\n}\n\nCould be replaced by:
\n\npublic class MyClass\n{\n private readonly ILogger _logger;\n\n // ...\n\n private void DoSomething()\n {\n // ...\n _logger.LogInformation(\"My Message\");\n // ...\n }\n}\n\nNested code - blocks of code inside blocks of code - is eventually necessary, but increases complexity. This is why keeping the code as flat as\npossible, by avoiding unnecessary nesting, is considered a good practice.
\nMerging if statements when possible will decrease the nesting of the code and improve its readability.
Code like
\n\nif (condition1)\n{\n if (condition2) // Noncompliant\n {\n // ...\n }\n}\n\nWill be more readable as
\n\nif (condition1 && condition2) // Compliant\n{\n // ...\n}\n\nIf merging the conditions seems to result in a more complex code, extracting the condition or part of it in a named function or variable is a\nbetter approach to fix readability.
\n\nif (file != null)\n{\n if (file.isFile() || file.isDirectory()) // Noncompliant\n {\n /* ... */\n }\n}\n\n\nbool isFileOrDirectory(File file)\n{\n return file.isFile() || file.isDirectory();\n}\n\n/* ... */\n\nif (file != null && isFileOrDirectory(file)) // Compliant\n{\n /* ... */\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1066.json",
"content": "{\n \"title\": \"Mergeable \\\"if\\\" statements should be combined\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1066\",\n \"sqKey\": \"S1066\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1067.html",
"content": "The complexity of an expression is defined by the number of &&, || and condition ? ifTrue : ifFalse\noperators it contains.
A single expression’s complexity should not become too high to keep the code readable.
\nWith the default threshold value of 3
\n\nif (((condition1 && condition2) || (condition3 && condition4)) && condition5) { ... }\n\n\nif ((MyFirstCondition() || MySecondCondition()) && MyLastCondition()) { ... }\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1067.json",
"content": "{\n \"title\": \"Expressions should not be too complex\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"3min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1067\",\n \"sqKey\": \"S1067\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S107.html",
"content": "Methods with a long parameter list are difficult to use because maintainers must figure out the role of each parameter and keep track of their\nposition.
\n\nvoid SetCoordinates(int x1, int y1, int z1, int x2, int y2, int z2) // Noncompliant\n{\n // ...\n}\n\nThe solution can be to:
\n\n// Each function does a part of what the original setCoordinates function was doing, so confusion risks are lower\nvoid SetOrigin(int x, int y, int z)\n{\n // ...\n}\n\nvoid SetSize(int width, int height, int depth)\n{\n //\n}\n\n\n// In geometry, Point is a logical structure to group data\nreadonly record struct Point(int X, int Y, int Z);\n\nvoid SetCoordinates(Point p1, Point p2)\n{\n // ...\n}\n\nThis rule raises an issue when a method has more parameters than the provided threshold.
\nThe rule does not count the parameters intended for a base class constructor.
\nWith a maximum number of 4 parameters:
\n\npublic class BaseClass\n{\n public BaseClass(int param1)\n {\n // ...\n }\n}\n\npublic class DerivedClass : BaseClass\n{\n public DerivedClass(int param1, int param2, int param3, string param4, long param5) : base(param1) // Compliant by exception\n {\n // ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S107.json",
"content": "{\n \"title\": \"Methods should not have too many parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-107\",\n \"sqKey\": \"S107\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1075.html",
"content": "Hard-coding a URI makes it difficult to test a program for a variety of reasons:
\nIn addition, hard-coded URIs can contain sensitive information, like IP addresses, and they should not be stored in the code.
\nFor all those reasons, a URI should never be hard coded. Instead, it should be replaced by a customizable parameter.
\nFurther, even if the elements of a URI are obtained dynamically, portability can still be limited if the path delimiters are hard-coded.
\nThis rule raises an issue when URIs or path delimiters are hard-coded.
\nThis rule does not raise an issue when an ASP.NET virtual path is passed as an argument to one of the following:
\nSystem.Web.HttpServerUtilityBase.MapPath(), System.Web.HttpRequestBase.MapPath(),\n System.Web.HttpResponseBase.ApplyAppPathModifier(), System.Web.Mvc.UrlHelper.Content()System.Web.VirtualPathUtilityMicrosoft.AspNetCore.Mvc.VirtualFileResult, Microsoft.AspNetCore.Routing.VirtualPathData\npublic class Foo {\n public List<User> ListUsers() {\n string userListPath = \"/home/mylogin/Dev/users.txt\"; // Noncompliant\n return ParseUsers(userListPath);\n }\n}\n\n\npublic class Foo {\n // Configuration is a class that returns customizable properties: it can be mocked to be injected during tests.\n private Configuration config;\n public Foo(Configuration myConfig) {\n this.config = myConfig;\n }\n public List<User> ListUsers() {\n // Find here the way to get the correct folder, in this case using the Configuration object\n string listingFolder = config.GetProperty(\"myApplication.listingFolder\");\n // and use this parameter instead of the hard coded path\n string userListPath = Path.Combine(listingFolder, \"users.txt\"); // Compliant\n return ParseUsers(userListPath);\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1075.json",
"content": "{\n \"title\": \"URIs should not be hardcoded\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1075\",\n \"sqKey\": \"S1075\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S108.html",
"content": "An empty code block is confusing. It will require some effort from maintainers to determine if it is intentional or indicates the implementation is\nincomplete.
\n\nfor (int i = 0; i < 42; i++){} // Noncompliant: is the block empty on purpose, or is code missing?\n\nRemoving or filling the empty code blocks takes away ambiguity and generally results in a more straightforward and less surprising code.
\nThe rule ignores code blocks that contain comments.
\n\n" }, { "path": "analyzers/rspec/cs/S108.json", "content": "{\n \"title\": \"Nested blocks of code should not be left empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-108\",\n \"sqKey\": \"S108\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S109.html", "content": "A magic number is a hard-coded numerical value that may lack context or meaning. They should not be used because they can make the code less\nreadable and maintainable.
\nMagic numbers make the code more complex to understand as it requires the reader to have knowledge about the global context to understand the\nnumber itself. Their usage may seem obvious when writing the code, but it may not be the case for another developer or later once the context faded\naway. -1, 0, and 1 are not considered magic numbers.
\nThis rule doesn’t raise an issue when the magic number is used as part of:
\nGetHashCode methodReplacing them with a constant allows us to provide a meaningful name associated with the value. Instead of adding complexity to the code, it\nbrings clarity and helps to understand the context and the global meaning.
\n\npublic void DoSomething()\n{\n for (int i = 0; i < 4; i++) // Noncompliant, 4 is a magic number\n {\n ...\n }\n}\n\n\nprivate const int NUMBER_OF_CYCLES = 4;\n\npublic void DoSomething()\n{\n for (int i = 0; i < NUMBER_OF_CYCLES; i++) // Compliant\n {\n ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S109.json",
"content": "{\n \"title\": \"Magic numbers should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-109\",\n \"sqKey\": \"S109\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S110.html",
"content": "Inheritance is one of the most valuable concepts in object-oriented programming. It’s a way to categorize and reuse code by creating collections of\nattributes and behaviors called classes, which can be based on previously created classes.
\nBut abusing this concept by creating a deep inheritance tree can lead to complex and unmaintainable source code. Often, an inheritance tree\nbecoming too deep is the symptom of systematic use of \"inheritance\" when other approaches like \"composition\" would be better suited.
\nThis rule raises an issue when the inheritance tree, starting from Object, has a greater depth than is allowed.
Public fields in public classes do not respect the encapsulation principle and have three main disadvantages:
\nTo prevent unauthorized modifications, private attributes and accessor methods (set and get) should be used.
\nNote that due to optimizations on simple properties, public fields provide only very little performance gain.
\nPublic fields can be modified by any part of the code and this can lead to unexpected changes and hard-to-trace bugs.
\nPublic fields don’t hide the implementation details. As a consequence, it is no longer possible to change how the data is stored internally without\nimpacting the client code of the class.
\nThe code is harder to maintain.
\nFields marked as readonly or const are ignored by this rule.
Fields inside classes or structs annotated with [StructLayout] are ignored by this rule.
Fields inside classes or structs annotated with [Serializable] are ignored by this rule unless they are annotated with\n[NonSerialized].
Depending on your needs:
\nreadonly or const.\npublic class Foo\n{\n public int InstanceData = 32; // Noncompliant\n public int AnotherInstanceData = 32; // Noncompliant\n\n}\n\n\npublic class Foo\n{\n // using auto-implemented properties\n public int InstanceData { get; set; } = 32;\n\n // using field encapsulation\n private int _anotherInstanceData = 32;\n\n public int AnotherInstanceData\n {\n get { return _anotherInstanceData; }\n set\n {\n // perform validation\n _anotherInstanceData = value;\n }\n }\n\n}\n\nPlease be aware that changing a field by a property in a software that uses serialization could lead to binary incompatibility.
\nShared coding conventions make it possible for a team to efficiently collaborate. This rule makes it mandatory to place a close curly brace at the\nbeginning of a line.
\n\nif(condition)\n{\n doSomething();}\n\n\nif(condition)\n{\n doSomething();\n}\n\nWhen blocks are inlined (open and close curly braces on the same line), no issue is triggered.
\n\nif(condition) {doSomething();}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1109.json",
"content": "{\n \"title\": \"A close curly brace should be located at the beginning of a line\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1109\",\n \"sqKey\": \"S1109\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1110.html",
"content": "Parentheses can disambiguate the order of operations in complex expressions and make the code easier to understand.
\n\na = (b * c) + (d * e); // Compliant: the intent is clear.\n\n
Redundant parentheses are parenthesis that do not change the behavior of the code, and do not clarify the intent. They can mislead and complexify\nthe code. They should be removed.
\n\nint x = ((y / 2 + 1)); // Noncompliant\n\nif (a && ((x + y > 0))) { // Noncompliant\n return ((x + 1)); // Noncompliant\n}\n\n\nint x = (y / 2 + 1);\n\nif (a && (x + y > 0)) {\n return (x + 1);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1110.json",
"content": "{\n \"title\": \"Redundant pairs of parentheses should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1110\",\n \"sqKey\": \"S1110\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1116.html",
"content": "Empty statements represented by a semicolon ; are statements that do not perform any operation. They are often the result of a typo or\na misunderstanding of the language syntax. It is a good practice to remove empty statements since they don’t add value and lead to confusion and\nerrors.
This rule does not raise when an empty statement is the only statement in a loop.
\n\nfor (int i = 0; i < 3; Console.WriteLine(i), i++);\n\n
\nvoid DoSomething()\n{\n ; // Noncompliant - was used as a kind of TODO marker\n}\n\nvoid DoSomethingElse()\n{\n Console.WriteLine(\"Hello, world!\");; // Noncompliant - double ;\n}\n\n\nvoid DoSomething()\n{\n}\n\nvoid DoSomethingElse()\n{\n Console.WriteLine(\"Hello, world!\");\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1116.json",
"content": "{\n \"title\": \"Empty statements should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1116\",\n \"sqKey\": \"S1116\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1117.html",
"content": "Shadowing occurs when a local variable has the same name as a variable, field, or property in an outer scope.
\nThis can lead to three main problems:
\nTo avoid these problems, rename the shadowing, shadowed, or both variables/fields/properties to accurately represent their purpose with unique and\nmeaningful names. It improves clarity and allows reasoning locally about the code without considering other software parts.
\nThis rule focuses on variables shadowing fields or properties.
\n\nclass Foo\n{\n public int myField;\n public int MyProperty { get; set; }\n\n public void DoSomething()\n {\n int myField = 0; // Noncompliant\n int MyProperty = 0; // Noncompliant\n }\n}\n\nWhenever there are portions of code that are duplicated and do not depend on the state of their container class, they can be centralized inside a\n\"utility class\". A utility class is a class that only has static members, hence it should not be instantiated.
\nTo prevent the class from being instantiated, you should define a non-public constructor. This will prevent the compiler from implicitly generating\na public parameterless constructor.
\nAlternatively, adding the static keyword as class modifier will also prevent it from being instantiated.
\npublic class StringUtils // Noncompliant: implicit public constructor\n{\n public static string Concatenate(string s1, string s2)\n {\n return s1 + s2;\n }\n}\n\nor
\n\npublic class StringUtils // Noncompliant: explicit public constructor\n{\n public StringUtils()\n {\n }\n\n public static string Concatenate(string s1, string s2)\n {\n return s1 + s2;\n }\n}\n\n\npublic static class StringUtils // Compliant: the class is static\n{\n public static string Concatenate(string s1, string s2)\n {\n return s1 + s2;\n }\n}\n\nor
\n\npublic class StringUtils // Compliant: the constructor is not public\n{\n private StringUtils()\n {\n }\n\n public static string Concatenate(string s1, string s2)\n {\n return s1 + s2;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1118.json",
"content": "{\n \"title\": \"Utility classes should not have public constructors\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1118\",\n \"sqKey\": \"S1118\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S112.html",
"content": "This rule raises an issue when a general or reserved exception is thrown.
\nThrowing general exceptions such as Exception, SystemException and ApplicationException will have a negative\nimpact on any code trying to catch these exceptions.
From a consumer perspective, it is generally a best practice to only catch exceptions you intend to handle. Other exceptions should ideally be let\nto propagate up the stack trace so that they can be dealt with appropriately. When a general exception is thrown, it forces consumers to catch\nexceptions they do not intend to handle, which they then have to re-throw.
\nBesides, when working with a general type of exception, the only way to distinguish between multiple exceptions is to check their message, which is\nerror-prone and difficult to maintain. Legitimate exceptions may be unintentionally silenced and errors may be hidden.
\nFor instance, if an exception such as StackOverflowException is caught and not re-thrown, it may prevent the program from terminating\ngracefully.
When throwing an exception, it is therefore recommended to throw the most specific exception possible so that it can be handled intentionally by\nconsumers.
\nAdditionally, some reserved exceptions should not be thrown manually. Exceptions such as IndexOutOfRangeException,\nNullReferenceException, OutOfMemoryException or ExecutionEngineException will be thrown automatically by the\nruntime when the corresponding error occurs. Many of them indicate serious errors, which the application may not be able to recover from. It is\ntherefore recommended to avoid throwing them as well as using them as base classes.
To fix this issue, make sure to throw specific exceptions that are relevant to the context in which they arise. It is recommended to either:
\nException when one matches. For instance ArgumentException could be raised when an unexpected\n argument is provided to a function.Exception or one of its subclasses.\npublic void DoSomething(object obj)\n{\n if (obj == null)\n {\n throw new NullReferenceException(\"obj\"); // Noncompliant: This reserved exception should not be thrown manually\n }\n // ...\n}\n\n\npublic void DoSomething(object obj)\n{\n if (obj == null)\n {\n throw new ArgumentNullException(\"obj\"); // Compliant: this is a specific and non-reserved exception type\n }\n // ...\n}\n\nA common code smell that can hinder the clarity of source code is making assignments within sub-expressions. This practice involves assigning a\nvalue to a variable inside a larger expression, such as within a loop or a conditional statement.
\nThis practice essentially gives a side-effect to a larger expression, thus making it less readable. This often leads to confusion and potential\nerrors.
\nAssignments inside lambda and delegate expressions are allowed.
\n\nvar result = Foo(() =>\n{\n int x = 100; // dead store, but ignored\n x = 200;\n return x;\n}\n\nThe rule also ignores the following patterns:
\n\nvar a = b = c = 10;\n\n
if statement or a loop\nwhile ((val = GetNewValue()) > 0)\n{\n...\n}\n\n\nprivate MyClass instance;\npublic MyClass Instance => instance ?? (instance = new MyClass());\n\n
Making assignments within sub-expressions can hinder the clarity of source code.
\nThis practice essentially gives a side-effect to a larger expression, thus making it less readable. This often leads to confusion and potential\nerrors.
\nExtracting assignments into separate statements is encouraged to keep the code clear and straightforward.
\n\nif (string.IsNullOrEmpty(result = str.Substring(index, length))) // Noncompliant\n{\n // do something with \"result\"\n}\n\n\nvar result = str.Substring(index, length);\nif (string.IsNullOrEmpty(result))\n{\n // do something with \"result\"\n}\n\nThe Obsolete attribute can be applied with or without a message argument. Marking something Obsolete without including\nadvice on why it’s obsolete or what to use instead will lead maintainers to waste time trying to figure those things out.
\npublic class Car\n{\n\n [Obsolete] // Noncompliant\n public void CrankEngine(int turnsOfCrank)\n { ... }\n}\n\n\npublic class Car\n{\n\n [Obsolete(\"Replaced by the automatic starter\")]\n public void CrankEngine(int turnsOfCrank)\n { ... }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1123.json",
"content": "{\n \"title\": \"\\\"Obsolete\\\" attributes should include explanations\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"obsolete\",\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1123\",\n \"sqKey\": \"S1123\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1125.html",
"content": "A boolean literal can be represented in two different ways: true or false. They can be combined with logical operators\n(!, &&, ||, ==, !=) to produce logical expressions that represent truth values. However, comparing a boolean literal to a\nvariable or expression that evaluates to a boolean value is unnecessary and can make the code harder to read and understand. The more complex a\nboolean expression is, the harder it will be for developers to understand its meaning and expected behavior, and it will favour the introduction of\nnew bugs.
Remove redundant boolean literals from expressions to improve readability and make the code more maintainable.
\n\nif (booleanMethod() == true) { /* ... */ }\nif (booleanMethod() == false) { /* ... */ }\nif (booleanMethod() || false) { /* ... */ }\ndoSomething(!false);\ndoSomething(booleanMethod() == true);\n\nbooleanVariable = booleanMethod() ? true : false;\nbooleanVariable = booleanMethod() ? true : exp;\nbooleanVariable = booleanMethod() ? false : exp;\nbooleanVariable = booleanMethod() ? exp : true;\nbooleanVariable = booleanMethod() ? exp : false;\n\nfor (var x = 0; true; x++)\n{\n ...\n}\n\n\nif (booleanMethod()) { /* ... */ }\nif (!booleanMethod()) { /* ... */ }\nif (booleanMethod()) { /* ... */ }\ndoSomething(true);\ndoSomething(booleanMethod());\n\nbooleanVariable = booleanMethod();\nbooleanVariable = booleanMethod() || exp;\nbooleanVariable = !booleanMethod() && exp;\nbooleanVariable = !booleanMethod() || exp;\nbooleanVariable = booleanMethod() && exp;\n\nfor (var x = 0; ; x++)\n{\n ...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1125.json",
"content": "{\n \"title\": \"Boolean literals should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1125\",\n \"sqKey\": \"S1125\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1128.html",
"content": "Unnecessary using directives refer to importing namespaces, types or creating aliases that are not used or referenced anywhere in the\ncode.
Although they don’t affect the runtime behavior of the application after compilation, removing them will:
\nStarting with C# 10, it’s possible to define
The rule will not raise a warning for global using directives, even if none of the types of that namespace are used in the\nproject:
\nglobal using System.Net.Sockets; // Compliant by exception\n\n
Unnecessary using directives are ignored in ASP.NET Core projects in the following files:
_Imports.razor_ViewImports.cshtmlWhile it’s not difficult to remove these unneeded lines manually, modern code editors support the removal of every unnecessary using\ndirective with a single click from every file of the project.
\nusing System.IO;\nusing System.Linq;\nusing System.Collections.Generic; // Noncompliant - no types are used from this namespace\nusing MyApp.Helpers; // Noncompliant - FileHelper is in the same namespace\nusing MyCustomNamespace; // Noncompliant - no types are used from this namespace\n\nnamespace MyApp.Helpers\n{\n public class FileHelper\n {\n public static string ReadFirstLine(string filePath) =>\n File.ReadAllLines(filePath).First();\n }\n}\n\n\nusing System.IO;\nusing System.Linq;\n\nnamespace MyApp.Helpers\n{\n public class FileHelper\n {\n public static string ReadFirstLine(string filePath) =>\n File.ReadAllLines(filePath).First();\n }\n}\n\nSome tools work better when files end with an empty line.
\nThis rule simply generates an issue if it is missing.
\nFor example, a Git diff looks like this if the empty line is missing at the end of the file:
\n\n+class Test\n+{\n+}\n\\ No newline at end of file\n\n\n"
},
{
"path": "analyzers/rspec/cs/S113.json",
"content": "{\n \"title\": \"Files should end with a newline\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-113\",\n \"sqKey\": \"S113\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1133.html",
"content": "This rule is meant to be used as a way to track code which is marked as being deprecated. Deprecated code should eventually be removed.
\n\n[Obsolete] // Noncompliant\nvoid Method()\n{\n // ..\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1133.json",
"content": "{\n \"title\": \"Deprecated code should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"INFO\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"obsolete\"\n ],\n \"defaultSeverity\": \"Info\",\n \"ruleSpecification\": \"RSPEC-1133\",\n \"sqKey\": \"S1133\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1134.html",
"content": "FIXME tags are commonly used to mark places where a bug is suspected, but which the developer wants to deal with later.
Sometimes the developer will not have the time or will simply forget to get back to that tag.
\nThis rule is meant to track those tags and to ensure that they do not go unnoticed.
\n\nprivate int Divide(int numerator, int denominator)\n{\n return numerator / denominator; // FIXME denominator value might be 0\n}\n\nDevelopers often use TODO tags to mark areas in the code where additional work or improvements are needed but are not implemented\nimmediately. However, these TODO tags sometimes get overlooked or forgotten, leading to incomplete or unfinished code. This rule aims to\nidentify and address unattended TODO tags to ensure a clean and maintainable codebase. This description explores why this is a problem\nand how it can be fixed to improve the overall code quality.
Unattended TODO tags in code can have significant implications for the development process and the overall codebase.
Incomplete Functionality: When developers leave TODO tags without implementing the corresponding code, it results in incomplete\nfunctionality within the software. This can lead to unexpected behavior or missing features, adversely affecting the end-user experience.
Missed Bug Fixes: If developers do not promptly address TODO tags, they might overlook critical bug fixes and security updates.\nDelayed bug fixes can result in more severe issues and increase the effort required to resolve them later.
Impact on Collaboration: In team-based development environments, unattended TODO tags can hinder collaboration. Other team members\nmight not be aware of the intended changes, leading to conflicts or redundant efforts in the codebase.
Codebase Bloat: The accumulation of unattended TODO tags over time can clutter the codebase and make it difficult to distinguish\nbetween work in progress and completed code. This bloat can make it challenging to maintain an organized and efficient codebase.
Addressing this code smell is essential to ensure a maintainable, readable, reliable codebase and promote effective collaboration among\ndevelopers.
\n\nprivate void DoSomething()\n{\n // TODO\n}\n\nThis rule raises an issue when a private/internal type or member is never referenced in the code.
\nA type or member that is never called is dead code, and should be removed. Cleaning out dead code decreases the size of the maintained codebase,\nmaking it easier to understand the program and preventing bugs from being introduced.
\nThis rule detects type or members that are never referenced from inside a translation unit, and cannot be referenced from the outside.
\nThis rule doesn’t raise issues on:
\nMain method of the applicationvoid methods with two parameters when the second parameter type derives from DynamicallyAccessedMembersAttribute.\npublic class Foo\n{\n private void UnusedPrivateMethod(){...} // Noncompliant, this private method is unused and can be removed.\n\n private class UnusedClass {...} // Noncompliant, unused private class that can be removed.\n}\n\n\npublic class Foo\n{\n public Foo()\n {\n UsedPrivateMethod();\n }\n\n private void UsedPrivateMethod()\n {\n var c = new UsedClass();\n }\n\n private class UsedClass {...}\n}\n\nCalling Environment.Exit(exitCode) or Application.Exit() terminates the process and returns an exit code to the operating\nsystem..
Each of these methods should be used with extreme care, and only when the intent is to stop the whole application.
\n\nEnvironment.Exit(0);\nApplication.Exit();\n\n
These methods are ignored inside Main.
The switch statement should be used only to clearly define some new branches in the control flow. As soon as a case\nclause contains too many statements this highly decreases the readability of the overall control flow statement. In such case, the content of the\ncase clause should be extracted into a dedicated method.
With the default threshold of 8:
\n\nswitch (myVariable)\n{\n case 0: // Noncompliant: 9 statements in the case\n methodCall1(\"\");\n methodCall2(\"\");\n methodCall3(\"\");\n methodCall4(\"\");\n methodCall5(\"\");\n methodCall6(\"\");\n methodCall7(\"\");\n methodCall8(\"\");\n methodCall9(\"\");\n break;\n case 1:\n ...\n}\n\n\nswitch (myVariable)\n{\n case 0:\n DoSomething()\n break;\n case 1:\n ...\n}\n...\nprivate void DoSomething()\n{\n methodCall1(\"\");\n methodCall2(\"\");\n methodCall3(\"\");\n methodCall4(\"\");\n methodCall5(\"\");\n methodCall6(\"\");\n methodCall7(\"\");\n methodCall8(\"\");\n methodCall9(\"\");\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1151.json",
"content": "{\n \"title\": \"\\\"switch case\\\" clauses should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1151\",\n \"sqKey\": \"S1151\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1155.html",
"content": "When you call Any(), it clearly communicates the code’s intention, which is to check if the collection is empty. Using Count()\n== 0 for this purpose is less direct and makes the code slightly more complex. However, there are some cases where special attention should be\npaid:
EntityFramework or other ORM query, calling Count() will cause executing a potentially massive\n SQL query and could put a large overhead on the application database. Calling Any() will also connect to the database, but will\n generate much more efficient SQL.Select() statements that create objects, a large amount of memory could be\n unnecessarily allocated. Calling Any() will be much more efficient because it will execute fewer iterations of the enumerable.Prefer using Any() to test for emptiness over Count().
\nprivate static bool HasContent(IEnumerable<string> strings)\n{\n return strings.Count() > 0; // Noncompliant\n}\n\nprivate static bool HasContent2(IEnumerable<string> strings)\n{\n return strings.Count() >= 1; // Noncompliant\n}\n\nprivate static bool IsEmpty(IEnumerable<string> strings)\n{\n return strings.Count() == 0; // Noncompliant\n}\n\n\nprivate static bool HasContent(IEnumerable<string> strings)\n{\n return strings.Any();\n}\n\nprivate static bool HasContent2(IEnumerable<string> strings)\n{\n return strings.Any();\n}\n\nprivate static bool IsEmpty(IEnumerable<string> strings)\n{\n return !strings.Any();\n}\n\n| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n Count \n | \n \n .NET 9.0 \n | \n \n 2,841.003 ns \n | \n \n 266.0238 ns \n | \n
| \n Any \n | \n \n .NET 9.0 \n | \n \n 1.749 ns \n | \n \n 0.1242 ns \n | \n
| \n Count \n | \n \n .NET Framework 4.8.1 \n | \n \n 71,125.275 ns \n | \n \n 731.0382 ns \n | \n
| \n Any \n | \n \n .NET Framework 4.8.1 \n | \n \n 31.774 ns \n | \n \n 0.3196 ns \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate IEnumerable<int> collection;\n\npublic const int N = 10_000;\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n collection = Enumerable.Range(0, N).Select(x => N - x);\n}\n\n[Benchmark(Baseline = true)]\npublic bool Count() =>\n collection.Count() > 0;\n\n[Benchmark]\npublic bool Any() =>\n collection.Any();\n\nHardware Configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S1155.json", "content": "{\n \"title\": \"\\\"Any()\\\" should be used to test for emptiness\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1155\",\n \"sqKey\": \"S1155\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S1163.html", "content": "
If an exception is already being thrown within the try block or caught in a catch block, throwing another exception in\nthe finally block will override the original exception. This means that the original exception’s message and stack trace will be lost,\npotentially making it challenging to diagnose and troubleshoot the root cause of the problem.
\ntry\n{\n // Some work which end up throwing an exception\n throw new ArgumentException();\n}\nfinally\n{\n // Cleanup\n throw new InvalidOperationException(); // Noncompliant: will mask the ArgumentException\n}\n\n\ntry\n{\n // Some work which end up throwing an exception\n throw new ArgumentException();\n}\nfinally\n{\n // Cleanup without throwing\n}\n\nReturning null or default instead of an actual collection forces the method callers to explicitly test for null, making\nthe code more complex and less readable.
Moreover, in many cases, null or default is used as a synonym for empty.
\npublic Result[] GetResults()\n{\n return null; // Noncompliant\n}\n\npublic IEnumerable<Result> GetResults(bool condition)\n{\n var results = GenerateResults();\n return condition\n ? results\n : null; // Noncompliant\n}\n\npublic IEnumerable<Result> GetResults() => null; // Noncompliant\n\npublic IEnumerable<Result> Results\n{\n get\n {\n return default(IEnumerable<Result>); // Noncompliant\n }\n}\n\npublic IEnumerable<Result> Results => default; // Noncompliant\n\n\npublic Result[] GetResults()\n{\n return new Result[0];\n}\n\npublic IEnumerable<Result> GetResults(bool condition)\n{\n var results = GenerateResults();\n return condition\n ? results\n : Enumerable.Empty<Result>();\n}\n\npublic IEnumerable<Result> GetResults() => Enumerable.Empty<Result>();\n\npublic IEnumerable<Result> Results\n{\n get\n {\n return Enumerable.Empty<Result>();\n }\n}\n\npublic IEnumerable<Result> Results => Enumerable.Empty<Result>();\n\nAlthough string is a collection, the rule won’t report on it.
A typical code smell known as unused function parameters refers to parameters declared in a function but not used anywhere within the function’s\nbody. While this might seem harmless at first glance, it can lead to confusion and potential errors in your code. Disregarding the values passed to\nsuch parameters, the function’s behavior will be the same, but the programmer’s intention won’t be clearly expressed anymore. Therefore, removing\nfunction parameters that are not being utilized is considered best practice.
\nThis rule raises an issue when a private method or constructor of a class/struct takes a parameter without using it.
This rule doesn’t raise any issue in the following contexts:
\nthis parameter of extension methods.NotImplementedException.virtual, override methods.Having unused function parameters in your code can lead to confusion and misunderstanding of a developer’s intention. They reduce code readability\nand introduce the potential for errors. To avoid these problems, developers should remove unused parameters from function declarations.
\n\nprivate void DoSomething(int a, int b) // Noncompliant, \"b\" is unused\n{\n Compute(a);\n}\n\nprivate void DoSomething2(int a) // Noncompliant, the value of \"a\" is unused\n{\n a = 10;\n Compute(a);\n}\n\n\nprivate void DoSomething(int a)\n{\n Compute(a);\n}\n\nprivate void DoSomething2()\n{\n var a = 10;\n Compute(a);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1172.json",
"content": "{\n \"title\": \"Unused method parameters should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1172\",\n \"sqKey\": \"S1172\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1185.html",
"content": "Overriding a method just to call the same method from the base class without performing any other actions is useless and misleading. The only time\nthis is justified is in sealed overriding methods, where the effect is to lock in the parent class behavior. This rule ignores overrides\nof Equals and GetHashCode.
NOTE: In some cases it might be dangerous to add or remove empty overrides, as they might be breaking changes.
\n\npublic override void Method() // Noncompliant\n{\n base.Method();\n}\n\n\npublic override void Method()\n{\n //do something else\n}\n\nIf there is an attribute in any level of the overriding chain, then the overridden member is ignored.
\n\npublic class Base\n{\n [Required]\n public virtual string Name { get; set; }\n}\n\npublic class Derived : Base\n{\n public override string Name\n {\n get\n {\n return base.Name;\n }\n set\n {\n base.Name = value;\n }\n }\n}\n\nIf there is a documentation comment on the overriding method, it will be ignored:
\n\npublic class Foo : Bar\n{\n /// <summary>\n /// Keep this method for backwards compatibility.\n /// </summary>\n public override void DoSomething()\n {\n base.DoSomething();\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1185.json",
"content": "{\n \"title\": \"Overriding members should do more than simply call the same member in the base class\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"redundant\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1185\",\n \"sqKey\": \"S1185\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1186.html",
"content": "An empty method is generally considered bad practice and can lead to confusion, readability, and maintenance issues. Empty methods bring no\nfunctionality and are misleading to others as they might think the method implementation fulfills a specific and identified requirement.
\nThere are several reasons for a method not to have a body:
\nThe following empty methods are considered compliant:
\nvirtual methods as the implementation might not be required in the base classabstract method as the implementation is mandatory for child class\npublic void ShouldNotBeEmpty() { // Noncompliant - method is empty\n}\n\npublic void NotImplementedYet() { // Noncompliant - method is empty\n}\n\npublic void WillNeverBeImplemented() { // Noncompliant - method is empty\n}\n\npublic void EmptyOnPurpose() { // Noncompliant - method is empty\n}\n\n\npublic void ShouldNotBeEmpty() {\n DoSomething();\n}\n\npublic void NotImplementedYet() {\n throw new NotImplementedException();\n}\n\npublic void WillNeverBeImplemented() {\n throw new NotSupportedException();\n}\n\npublic void EmptyOnPurpose() {\n // comment explaining why the method is empty\n}\n\nDuplicated string literals make the process of refactoring complex and error-prone, as any change would need to be propagated on all\noccurrences.
\nThe following are ignored:
\nUse constants to replace the duplicated string literals. Constants can be referenced from many places, but only need to be updated in a single\nplace.
\n\npublic class Foo\n{\n private string name = \"foobar\"; // Noncompliant\n\n public string DefaultName { get; } = \"foobar\"; // Noncompliant\n\n public Foo(string value = \"foobar\") // Noncompliant\n {\n var something = value ?? \"foobar\"; // Noncompliant\n }\n}\n\n\npublic class Foo\n{\n private const string Foobar = \"foobar\";\n\n private string name = Foobar;\n\n public string DefaultName { get; } = Foobar;\n\n public Foo(string value = Foobar)\n {\n var something = value ?? Foobar;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1192.json",
"content": "{\n \"title\": \"String literals should not be duplicated\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"DISTINCT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Linear with offset\",\n \"linearDesc\": \"per duplicate instance\",\n \"linearOffset\": \"2min\",\n \"linearFactor\": \"2min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1192\",\n \"sqKey\": \"S1192\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1199.html",
"content": "Nested code blocks create new scopes where variables declared within are inaccessible from the outside, and their lifespan ends with the block.
\nAlthough this may appear beneficial, their usage within a function often suggests that the function is overloaded. Thus, it may violate the Single\nResponsibility Principle, and the function needs to be broken down into smaller functions.
\nThe presence of nested blocks that don’t affect the control flow might suggest possible mistakes in the code.
\nThe usage of a code block after a case is allowed.
The nested code blocks should be extracted into separate methods.
\n\npublic void Evaluate()\n{\n /* ... */\n { // Noncompliant - nested code block '{' ... '}'\n int a = stack.pop();\n int b = stack.pop();\n int result = a + b;\n stack.push(result);\n }\n /* ... */\n}\n\n\npublic void Evaluate()\n{\n /* ... */\n StackAdd();\n /* ... */\n}\n\nprivate void StackAdd()\n{\n int a = stack.pop();\n int b = stack.pop();\n int result = a + b;\n stack.push(result);\n}\n\nAccording to the Single Responsibility Principle, introduced by Robert C. Martin in his book \"Principles of Object Oriented Design\", a class should\nhave only one responsibility:
\n\n\nIf a class has more than one responsibility, then the responsibilities become coupled.
\nChanges to one responsibility may impair or inhibit the class' ability to meet the others.
\nThis kind of coupling leads to fragile designs that break in unexpected ways when changed.
\n
Classes which rely on many other classes tend to aggregate too many responsibilities and should be split into several smaller ones.
\nNested classes dependencies are not counted as dependencies of the outer class.
\nWith a threshold of 5:
\n\npublic class Foo // Noncompliant - Foo depends on too many classes: T1, T2, T3, T4, T5, T6 and T7\n{\n private T1 a1; // Foo is coupled to T1\n private T2 a2; // Foo is coupled to T2\n private T3 a3; // Foo is coupled to T3\n\n public T4 Compute(T5 a, T6 b) // Foo is coupled to T4, T5 and T6\n {\n T7 result = a.Process(b); // Foo is coupled to T7\n return result;\n }\n\n public static class Bar // Compliant - Bar depends on 2 classes: T8 and T9\n {\n public T8 a8;\n public T9 a9;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1200.json",
"content": "{\n \"title\": \"Classes should not be coupled to too many other classes\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2h\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1200\",\n \"sqKey\": \"S1200\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1206.html",
"content": "Suppose you override Object.Equals in a type, you must also\noverride Object.GetHashCode. If two objects are equal according\nto the Equals method, then calling GetHashCode on each of them must yield the same integer. If this is not the case, many\ncollections, such as a Hashtable or a
In order to not have unpredictable behavior, Equals and GetHashCode should be either both inherited, or both\noverridden.
When you override Equals then you have to also override GetHashCode. You have to override both of them, or simply inherit\nthem.
\nclass MyClass // Noncompliant: should also override GetHashCode\n{\n public override bool Equals(object obj)\n {\n // ...\n }\n}\n\n\nclass MyClass\n{\n public override bool Equals(object obj)\n {\n // ...\n }\n\n public override int GetHashCode()\n {\n // ...\n }\n}\n\nControl structures are code statements that impact the program’s control flow (e.g., if statements, for loops, etc.)
\nWhile not technically incorrect, the omission of curly braces can be misleading and may lead to the introduction of errors during maintenance.
\nIn the following example, the two calls seem to be attached to the if statement, but only the first one is, and\nCheckSomething will always be executed:
\nif (condition) // Noncompliant\n ExecuteSomething();\n CheckSomething();\n\n
Adding curly braces improves the code readability and its robustness:
\n\nif (condition)\n{\n ExecuteSomething();\n CheckSomething();\n}\n\nThe rule raises an issue when a control structure has no curly braces.
\n\n" }, { "path": "analyzers/rspec/cs/S121.json", "content": "{\n \"title\": \"Control structures should use curly braces\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-121\",\n \"sqKey\": \"S121\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1210.html", "content": "When you implement IComparable or IComparable<T> on a class you should also override Equals(object)\nand overload the comparison operators (==, !=, <, <=, >,\n>=). That’s because the CLR cannot automatically call your CompareTo implementation from Equals(object) or\nfrom the base comparison operator implementations. Additionally, it is best practice to override GetHashCode along with\nEquals.
This rule raises an issue when a class implements IComparable without also overriding Equals(object) and the comparison\noperators.
\npublic class Foo: IComparable // Noncompliant\n{\n public int CompareTo(object obj) { /* ... */ }\n}\n\n\npublic class Foo: IComparable\n{\n public int CompareTo(object obj) { /* ... */ }\n public override bool Equals(object obj)\n {\n var other = obj as Foo;\n if (object.ReferenceEquals(other, null))\n {\n return false;\n }\n return this.CompareTo(other) == 0;\n }\n public int GetHashCode() { /* ... */ }\n public static bool operator == (Foo left, Foo right)\n {\n if (object.ReferenceEquals(left, null))\n {\n return object.ReferenceEquals(right, null);\n }\n return left.Equals(right);\n }\n public static bool operator > (Foo left, Foo right)\n {\n return Compare(left, right) > 0;\n }\n public static bool operator < (Foo left, Foo right)\n {\n return Compare(left, right) < 0;\n }\n public static bool operator != (Foo left, Foo right)\n {\n return !(left == right);\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1210.json",
"content": "{\n \"title\": \"\\\"Equals\\\" and the comparison operators should be overridden when implementing \\\"IComparable\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1210\",\n \"sqKey\": \"S1210\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1215.html",
"content": "GC.Collect is a method that forces or suggests to the
Calling GC.Collect is rarely necessary and can significantly affect application performance. That’s because it is a
To perform tracing and memory releasing correctly, the garbage collection GC.Collect far outweigh the benefits.
This rule raises an issue when any overload of Collect is invoked.
\nstatic void Main(string[] args)\n{\n // ...\n GC.Collect(); // Noncompliant\n GC.Collect(2, GCCollectionMode.Optimized); // Noncompliant\n}\n\nThere may be exceptions to this rule: for example, you’ve just triggered some event that is unique in the run of your program that caused a lot of\nlong-lived objects to die, and you want to release their memory.
\nThis rule also raises on GC.GetTotalMemory when forceFullCollection is true as it directly invokes\nGC.Collect.
Each .NET runtime features distinct implementations, modes, and configurations for its garbage collector. The benchmark below illustrates how\ninvoking GC.Collect() can have opposite effects across different runtimes.
| Runtime | \nCollect | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n .NET 9.0 \n | \n \n False \n | \n \n 659.2 ms \n | \n \n 15.69 ms \n | \n \n 205.95 MB \n | \n
| \n .NET 9.0 \n | \n \n True \n | \n \n 888.8 ms \n | \n \n 15.34 ms \n | \n \n 205.95 MB \n | \n
| \n | \n | \n | \n | \n |
| \n .NET Framework 4.8.1 \n | \n \n False \n | \n \n 545.7 ms \n | \n \n 19.49 ms \n | \n \n 228.8 MB \n | \n
| \n .NET Framework 4.8.1 \n | \n \n True \n | \n \n 484.8 ms \n | \n \n 11.79 ms \n | \n \n 228.8 MB \n | \n
True, GC.Collect() is called in the middle of the allocation heavy Benchmark() methodThe results were generated by running the following snippet with BenchmarkDotNet:
\n\nclass Tree\n{\n public List<Tree> Children = new();\n}\n\nprivate void AppendToTree(Tree tree, int childsPerTree, int depth)\n{\n if (depth == 0)\n {\n return;\n }\n for (int i = 0; i < childsPerTree; i++)\n {\n var child = new Tree();\n tree.Children.Add(child);\n AppendToTree(child, childsPerTree, depth - 1);\n }\n}\n\n[Benchmark]\n[Arguments(true)]\n[Arguments(false)]\npublic void Benchmark(bool collect)\n{\n var tree = new Tree();\n AppendToTree(tree, 8, 7); // Create 8^7 Tree objects (2.097.152 objects) linked via List<Tree> Children\n GC.Collect();\n GC.Collect(); // Move the objects to generation 2\n AppendToTree(new Tree(), 8, 6); // Add some more memory preasure (8^6 262.144 objects) which can be collected right after this call\n tree = null; // Remove all references to the tree and its content. This freees up 8^7 Tree objects (2.097.152 objects)\n if (collect)\n {\n GC.Collect(); // Force GC to run and block until it finishes\n }\n AppendToTree(new Tree(), 3, 10); // Do some more allocations (3^10 = 59.049)\n AppendToTree(new Tree(), 4, 7); // 4^10 = 1.048.576\n AppendToTree(new Tree(), 5, 7); // 5^7 = 78.125\n GC.Collect(); // Collect all the memory allocated in this method\n}\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\nIntel Core Ultra 7 165H, 1 CPU, 22 logical and 16 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S1215.json", "content": "{\n \"title\": \"\\\"GC.Collect\\\" should not be called\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"30min\"\n },\n \"tags\": [\n \"performance\",\n \"unpredictable\",\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1215\",\n \"sqKey\": \"S1215\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S122.html", "content": "
Putting multiple statements on a single line lowers the code readability and makes debugging the code more complex.
\n\nif (someCondition) { DoSomething(); } // Noncompliant\n\nDoSomething(); DoSomethingElse(); // Noncompliant\n\nWrite one statement per line to improve readability.
\n\nif (someCondition)\n{\n DoSomething();\n}\n\nDoSomething();\nDoSomethingElse();\n\nThe rule ignores:
\n\nFunc<object, bool> item1 = o => { return true; }; // Compliant by exception\nFunc<object, bool> item1 = o => { var r = false; return r; }; // Noncompliant\n\nWhile it is technically correct to assign to parameters from within method bodies, doing so before the parameter value is read is likely a bug.\nInstead, initial values of parameters, caught exceptions, and foreach parameters should be, if not treated as final, then at least read\nbefore reassignment.
\npublic void DoTheThing(string str, int i, List<string> strings)\n{\n str = i.ToString(i); // Noncompliant\n\n foreach (var s in strings)\n {\n s = \"hello world\"; // Noncompliant\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1226.json",
"content": "{\n \"title\": \"Method parameters, caught exceptions and foreach variables\\u0027 initial values should not be ignored\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1226\",\n \"sqKey\": \"S1226\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1227.html",
"content": "This rule is deprecated, and will eventually be removed.
\nbreak; is an unstructured control flow statement which makes code harder to read.
Ideally, every loop should have a single termination condition.
\n\nint i = 0;\nwhile (true)\n{\n if (i == 10)\n {\n break; // Non-Compliant\n }\n\n Console.WriteLine(i);\n i++;\n}\n\n\nint i = 0;\nwhile (i != 10) // Compliant\n{\n Console.WriteLine(i);\n i++;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1227.json",
"content": "{\n \"title\": \"break statements should not be used except for switch cases\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"deprecated\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1227\",\n \"sqKey\": \"S1227\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1244.html",
"content": "Floating point numbers in C# (and in most other programming languages) are not precise. They are a binary approximation of the actual value. This\nmeans that even if two floating point numbers appear to be equal, they might not be due to the tiny differences in their binary representation.
\nEven simple floating point assignments are not simple:
\n\nfloat f = 0.100000001f; // 0.1\ndouble d = 0.10000000000000001; // 0.1\n\n
(Note: Results may vary based on the compiler and its settings)
\nThis issue is further compounded by the non-associative nature of floating point\narithmetic. The order in which operations are performed can affect the outcome due to the rounding that occurs at each step. Consequently, the outcome\nof a series of mathematical operations can vary based on the order of operations.
\nAs a result, using the equality (==) or inequality (!=) operators with float or double values\nis typically a mistake, as it can lead to unexpected behavior.
Consider using a small tolerance value to check if the numbers are \"close enough\" to be considered equal. This tolerance value, often called\nepsilon, should be chosen based on the specifics of your program.
\nfloat myNumber = 3.146f;\n\nif (myNumber == 3.146f) // Noncompliant: due to floating point imprecision, this will likely be false\n{\n // ...\n}\n\nif (myNumber < 4 || myNumber > 4) // Noncompliant: indirect inequality test\n{\n // ...\n}\n\n\nfloat myNumber = 3.146f;\nfloat epsilon = 0.0001f; // or some other small value\n\nif (Math.Abs(myNumber - 3.146f) < epsilon)\n{\n // ...\n}\n\nif (myNumber <= 4 - epsilon || myNumber >= 4 + epsilon)\n{\n // ...\n}\n\nCommented-out code distracts the focus from the actual executed code. It creates a noise that increases maintenance code. And because it is never\nexecuted, it quickly becomes out of date and invalid.
\nCommented-out code should be deleted and can be retrieved from source control history if required.
\nDelete the commented out code.
\n\nvoid Method(string s)\n{\n // if (s.StartsWith('A'))\n // {\n // s = s.Substring(1);\n // }\n\n // Do something...\n}\n\n\nvoid Method(string s)\n{\n // Do something...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S125.json",
"content": "{\n \"title\": \"Sections of code should not be commented out\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-125\",\n \"sqKey\": \"S125\",\n \"scope\": \"All\",\n \"quickfix\": \"partial\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S126.html",
"content": "This rule applies whenever an if statement is followed by one or more else if statements; the final else if\nshould be followed by an else statement.
The requirement for a final else statement is defensive programming.
The else statement should either take appropriate action or contain a suitable comment as to why no action is taken. This is\nconsistent with the requirement to have a final default clause in a switch statement.
\nif (x == 0)\n{\n DoSomething();\n}\nelse if (x == 1)\n{\n DoSomethingElse();\n}\n\n\nif (x == 0)\n{\n DoSomething();\n}\nelse if (x == 1)\n{\n DoSomethingElse();\n}\nelse\n{\n throw new InvalidOperationException();\n}\n\nNone
\n\n" }, { "path": "analyzers/rspec/cs/S126.json", "content": "{\n \"title\": \"\\\"if ... else if\\\" constructs should end with \\\"else\\\" clauses\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-126\",\n \"sqKey\": \"S126\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1264.html", "content": "Using a for loop without its typical structure (initialization, condition, increment) can be confusing. In those cases, it is better\nto use a while loop as it is more readable.
The initializer section should contain a variable declaration to be considered as a valid initialization.
\nReplace the for loop with a while loop.
\nfor (;condition;) // Noncompliant; both the initializer and increment sections are missing\n{\n // Do something\n}\n\n\nwhile (condition)\n{\n // Do something\n}\n\n\nint i;\n\nfor (i = 0; i < 10;) // Noncompliant; the initializer section should contain a variable declaration\n{\n // Do something\n i++;\n}\n\n\nint i = 0;\n\nwhile (i < 10)\n{\n // Do something\n i++;\n}\n\nfor\n statementA for loop stop condition should test the loop counter against an invariant value, one that is true at both the beginning and ending\nof every loop iteration. Ideally, this means that the stop condition is set to a local variable just before the loop begins.
This rule tracks when incremented counters used in the stop condition are updated in the body of the for loop.
Non-invariant stop conditions can lead to unexpected loop behavior, making the code harder to debug and maintain. If the stop condition changes\nunexpectedly during iteration, it may cause:
\nIt is generally recommended to only update the loop counter in the loop declaration. If skipping elements or iterating at a different pace based on\na condition is needed, consider using a while loop or a different structure that better fits the needs.
\n\nfor (int i = 1; i <= 5; i++)\n{\n Console.WriteLine(i);\n if (condition)\n {\n i = 20;\n }\n}\n\n\nint i = 1;\nwhile (i <= 5)\n{\n Console.WriteLine(i);\n if (condition)\n {\n i = 20;\n }\n else\n {\n i++;\n }\n}\n\nA while loop signals that the iteration logic may be more complex, so readers will naturally look for control flow changes within the\nloop body. This makes the code’s intent clearer and easier to reason about.
switch statements and expressions are useful when there are many different cases depending on the value of the same expression.
When a switch statement or expression is simple enough, the code will be more readable with a single if,\nif-else or ternary conditional operator.
\nswitch (variable)\n{\n case 0:\n doSomething();\n break;\n default:\n doSomethingElse();\n break;\n}\n\nvar foo = variable switch\n{\n 0 => doSomething(),\n _ => doSomethingElse(),\n}\n\n\nif (variable == 0)\n{\n doSomething();\n}\nelse\n{\n doSomethingElse();\n}\n\nvar foo = variable == 0\n ? doSomething()\n : doSomethingElse();\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1301.json",
"content": "{\n \"title\": \"\\\"switch\\\" statements should have at least 3 \\\"case\\\" clauses\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1301\",\n \"sqKey\": \"S1301\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1309.html",
"content": "This rule allows you to track the usage of the SuppressMessage attributes and #pragma warning disable mechanism.
\n[SuppressMessage(\"\", \"S100\")]\n...\n\n#pragma warning disable S100\n...\n#pragma warning restore S100\n\n\n" }, { "path": "analyzers/rspec/cs/S1309.json", "content": "{\n \"title\": \"Track uses of in-source issue suppressions\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"INFO\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Info\",\n \"ruleSpecification\": \"RSPEC-1309\",\n \"sqKey\": \"S1309\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S131.html", "content": "
The requirement for a final default clause is defensive programming. The clause should either take appropriate action, or contain a\nsuitable comment as to why no action is taken. Even when the switch covers all current values of an enum, a\ndefault case should still be used because there is no guarantee that the enum won’t be extended.
\nint foo = 42;\nswitch (foo) // Noncompliant\n{\n case 0:\n Console.WriteLine(\"foo = 0\");\n break;\n case 42:\n Console.WriteLine(\"foo = 42\");\n break;\n}\n\n\nint foo = 42;\nswitch (foo) // Compliant\n{\n case 0:\n Console.WriteLine(\"foo = 0\");\n break;\n case 42:\n Console.WriteLine(\"foo = 42\");\n break;\n default:\n throw new InvalidOperationException(\"Unexpected value foo = \" + foo);\n}\n\nRegardless of the logging framework in use (Microsoft.Extension.Logging, Serilog, Log4net, NLog, …), logger fields should be:
\nstatic will ensure that the lifetime of the object doesn’t depend on the lifetime\n of the instance of the enclosing type.readonly will prevent modifications to the reference of the logger. This ensures\n that the reference to the logger remains consistent and doesn’t get accidentally reassigned during the lifetime of the enclosing type.This rule should be activated when Service Locator Design pattern is followed\nin place of Dependency Injection for logging.
\nThe rule supports the most popular logging frameworks:
\nMake the logging field {private static readonly}.
\npublic Logger logger;\n\n
\nprivate static readonly Logger logger;\n\n
static class membersreadonly\n keywordHardcoding IP addresses is security-sensitive. It has led in the past to the following vulnerabilities:
\nToday’s services have an ever-changing architecture due to their scaling and redundancy needs. It is a mistake to think that a service will always\nhave the same IP address. When it does change, the hardcoded IP will have to be modified too. This will have an impact on the product development,\ndelivery, and deployment:
\nLast but not least it has an effect on application security. Attackers might be able to decompile the code and thereby discover a potentially\nsensitive address. They can perform a Denial of Service attack on the service, try to get access to the system, or try to spoof the IP address to\nbypass security checks. Such attacks can always be possible, but in the case of a hardcoded IP address solving the issue will take more time, which\nwill increase an attack’s impact.
\nThe disclosed IP address is sensitive, e.g.:
\nThere is a risk if you answered yes to any of these questions.
\nDon’t hard-code the IP address in the source code, instead make it configurable with environment variables, configuration files, or a similar\napproach. Alternatively, if confidentially is not required a domain name can be used since it allows to change the destination quickly without having\nto rebuild the software.
\n\nvar ip = \"192.168.12.42\";\nvar address = IPAddress.Parse(ip);\n\n
\nvar ip = ConfigurationManager.AppSettings[\"myapplication.ip\"];\nvar address = IPAddress.Parse(ip);\n\n
No issue is reported for the following cases because they are not considered sensitive:
\n2.5.<number>.<number> as they often match\n Object Identifiers (OID)Nested control flow statements if, switch, for, foreach, while, do,\nand try are often key ingredients in creating what’s known as \"Spaghetti code\". This code smell can make your program difficult to\nunderstand and maintain.
When numerous control structures are placed inside one another, the code becomes a tangled, complex web. This significantly reduces the code’s\nreadability and maintainability, and it also complicates the testing process.
\nThe following example demonstrates the behavior of the rule with the default threshold of 3 levels of nesting and one of the potential ways to fix\nthe code smell by introducing guard clauses:
\n\nif (condition1) // Compliant - depth = 1\n{\n /* ... */\n if (condition2) // Compliant - depth = 2\n {\n /* ... */\n for (int i = 0; i < 10; i++) // Compliant - depth = 3\n {\n /* ... */\n if (condition4) // Noncompliant - depth = 4, which exceeds the limit\n {\n if (condition5) // Depth = 5, exceeding the limit, but issues are only reported on depth = 4\n {\n /* ... */\n }\n return;\n }\n }\n }\n}\n\n\nif (!condition1)\n{\n return;\n}\n/* ... */\nif (!condition2)\n{\n return;\n}\nfor (int i = 0; i < 10; i++)\n{\n /* ... */\n if (condition4)\n {\n if (condition5)\n {\n /* ... */\n }\n return;\n }\n}\n\nA function that grows too large tends to aggregate too many responsibilities.
\nSuch functions inevitably become harder to understand and therefore harder to maintain.
\nAbove a specific threshold, it is strongly advised to refactor into smaller functions which focus on well-defined tasks.
\nThose smaller functions will not only be easier to understand, but also probably easier to test.
\n\n" }, { "path": "analyzers/rspec/cs/S138.json", "content": "{\n \"title\": \"Functions should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-138\",\n \"sqKey\": \"S138\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1449.html", "content": "string.ToLower(), ToUpper, IndexOf, LastIndexOf, and Compare are all\nculture-dependent, as are some (floating point number and DateTime-related) calls to ToString. Fortunately, all have\nvariants which accept an argument specifying the culture or formatter to use. Leave that argument off and the call will use the system default\nculture, possibly creating problems with international characters.
string.CompareTo() is also culture specific, but has no overload that takes a culture information, so instead it’s better to use\nCompareOrdinal, or Compare with culture.
Calls without a culture may work fine in the system’s \"home\" environment, but break in ways that are extremely difficult to diagnose for customers\nwho use different encodings. Such bugs can be nearly, if not completely, impossible to reproduce when it’s time to fix them.
\n\nvar lowered = someString.ToLower(); //Noncompliant\n\n
\nvar lowered = someString.ToLower(CultureInfo.InvariantCulture);\n\n
or
\n\nvar lowered = someString.ToLowerInvariant();\n\n\n" }, { "path": "analyzers/rspec/cs/S1449.json", "content": "{\n \"title\": \"Culture should be specified for \\\"string\\\" operations\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unpredictable\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1449\",\n \"sqKey\": \"S1449\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1450.html", "content": "
When the value of a private field is always assigned to in a class' methods before being read, then it is not being used to store class\ninformation. Therefore, it should become a local variable in the relevant methods to prevent any misunderstanding.
\n\npublic class Foo\n{\n private int singularField;\n\n public void DoSomething(int x)\n {\n singularField = x + 5;\n\n if (singularField == 0) { /* ... */ }\n }\n}\n\n\npublic class Foo\n{\n public void DoSomething(int x)\n {\n int localVariable = x + 5;\n\n if (localVariable == 0) { /* ... */ }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1450.json",
"content": "{\n \"title\": \"Private fields only used as local variables in methods should become local variables\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1450\",\n \"sqKey\": \"S1450\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1451.html",
"content": "Each source file should start with a header stating file ownership and the license which must be used to distribute the application.
\nThis rule must be fed with the header text that is expected at the beginning of every file.
\nThe headerFormat must end with an empty line if you want to have an empty line between the file header and the first line for your\nsource file (using, namespace…).
For example, if you want the source file to look like this
\n\n// Copyright (c) SonarSource. All Rights Reserved. Licensed under the LGPL License. See License.txt in the project root for license information.\n\nnamespace Foo\n{\n}\n\nthen the headerFormat parameter should end with an empty line like this
\n// Copyright (c) SonarSource. All Rights Reserved. Licensed under the LGPL License. See License.txt in the project root for license information.\n\n
\n/*\n * SonarQube, open source software quality management tool.\n * Copyright (C) 2008-2013 SonarSource\n * mailto:contact AT sonarsource DOT com\n *\n * SonarQube is free software; you can redistribute it and/or\n * modify it under the terms of the GNU Lesser General Public\n * License as published by the Free Software Foundation; either\n * version 3 of the License, or (at your option) any later version.\n *\n * SonarQube is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program; if not, write to the Free Software Foundation,\n * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n\n" }, { "path": "analyzers/rspec/cs/S1451.json", "content": "{\n \"title\": \"Track lack of copyright and license headers\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"LAWFUL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-1451\",\n \"sqKey\": \"S1451\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S1479.html", "content": "
When switch\nstatements have large sets of multi-line case clauses, the code becomes hard to read and maintain.
For example, the Cognitive Complexity is going to be particularly high.
\nIn such scenarios, it’s better to refactor the switch to only have single-line case clauses.
When all the case clauses of a switch statement are single-line, the readability of the code is not affected. Moreover,\nswitch statements with single-line case clauses can easily be converted into switch expressions, which are\nmore concise for assignment and avoid the need for break statements.
This rule ignores:
\nswitch statements over Enum argumentsreturn, break and throw statements in case clausesExtract the logic of multi-line case clauses into separate methods.
The examples below use the \"Maximum number of case\" property set to 4.
Note that from C# 8, you can use switch expression.
\npublic int MapChar(char ch, int value)\n{\n switch(ch) // Noncompliant\n {\n case 'a':\n return 1;\n case 'b':\n return 2;\n case 'c':\n return 3;\n // ...\n case '-':\n if (value > 10)\n {\n return 42;\n }\n else if (value < 5 && value > 1)\n {\n return 21;\n }\n return 99;\n default:\n return 1000;\n }\n}\n\n\npublic int MapChar(char ch, int value)\n{\n switch(ch) // Compliant: All 5 cases are single line statements\n {\n case 'a':\n return 1;\n case 'b':\n return 2;\n case 'c':\n return 3;\n // ...\n case '-':\n return HandleDash(value);\n default:\n return 1000;\n }\n}\n\nprivate int HandleDash(int value)\n{\n if (value > 10)\n {\n return 42;\n }\n else if (value < 5 && value > 1)\n {\n return 21;\n }\n return 99;\n}\n\nFor this example, a switch expression is more concise and clear:
\npublic int MapChar(char ch, int value) =>\n ch switch // Compliant\n {\n 'a' => 1,\n 'b' => 2,\n 'c' => 3,\n // ...\n '-' => HandleDash(value),\n _ => 1000,\n };\n\nprivate int HandleDash(int value)\n{\n if (value > 10)\n {\n return 42;\n }\n else if (value < 5 && value > 1)\n {\n return 21;\n }\n return 99;\n}\n\nswitch statementAn unused local variable is a variable that has been declared but is not used anywhere in the block of code where it is defined. It is dead code,\ncontributing to unnecessary complexity and leading to confusion when reading the code. Therefore, it should be removed from your code to maintain\nclarity and efficiency.
\nHaving unused local variables in your code can lead to several issues:
\nIn summary, unused local variables can make your code less readable, more confusing, and harder to maintain, and they can potentially lead to bugs\nor inefficient memory use. Therefore, it is best to remove them.
\nUnused locally created resources in a using statement are not reported.
\nusing(var t = new TestTimer()) // t never used, but compliant.\n{\n //...\n}\n\nThe fix for this issue is straightforward. Once you ensure the unused variable is not part of an incomplete implementation leading to bugs, you\njust need to remove it.
\n\npublic int NumberOfMinutes(int hours)\n{\n int seconds = 0; // Noncompliant - seconds is unused\n return hours * 60;\n}\n\n\npublic int NumberOfMinutes(int hours)\n{\n return hours * 60;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1481.json",
"content": "{\n \"title\": \"Unused local variables should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1481\",\n \"sqKey\": \"S1481\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1541.html",
"content": "The cyclomatic complexity of methods and properties should not exceed a defined threshold. Complex code can perform poorly and will in any case be\ndifficult to understand and therefore to maintain.
\n\n" }, { "path": "analyzers/rspec/cs/S1541.json", "content": "{\n \"title\": \"Methods and properties should not be too complex\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1541\",\n \"sqKey\": \"S1541\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1607.html", "content": "When a test fails due, for example, to infrastructure issues, you might want to ignore it temporarily. But without some kind of notation about why\nthe test is being ignored, it may never be reactivated. Such tests are difficult to address without comprehensive knowledge of the project, and end up\npolluting their projects.
\nThis rule raises an issue for each ignored test that does not have a WorkItem attribute nor a comment about why it is being skipped on\nthe right side of the Ignore attribute.
\n[TestMethod]\n[Ignore]\npublic void Test_DoTheThing()\n{\n // ...\n}\n\n\n[TestMethod]\n[Ignore] // renable when TCKT-1234 is fixed\npublic void Test_DoTheThing()\n{\n // ...\n}\n\nor
\n\n[TestMethod]\n[Ignore]\n[WorkItem(1234)]\npublic void Test_DoTheThing()\n{\n // ...\n}\n\nThe rule doesn’t raise an issue if:
\nWorkItem attributeIgnore attributeConcatenating multiple string literals or strings using the + operator creates a new string object for each concatenation. This can\nlead to a large number of intermediate string objects and can be inefficient. The StringBuilder class is more efficient than string\nconcatenation, especially when the operator is repeated over and over as in loops.
Replace string concatenation with StringBuilder.
\nstring str = \"\";\nfor (int i = 0; i < arrayOfStrings.Length ; ++i)\n{\n str = str + arrayOfStrings[i];\n}\n\n\nStringBuilder bld = new StringBuilder();\nfor (int i = 0; i < arrayOfStrings.Length; ++i)\n{\n bld.Append(arrayOfStrings[i]);\n}\nstring str = bld.ToString();\n\n| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n StringConcatenation \n | \n \n .NET 9.0 \n | \n \n 50,530.75 us \n | \n \n 2,699.189 us \n | \n \n 586280.70 KB \n | \n
| \n StringBuilder \n | \n \n .NET 9.0 \n | \n \n 82.31 us \n | \n \n 3.387 us \n | \n \n 243.79 KB \n | \n
| \n StringConcatenation \n | \n \n .NET Framework 4.8.1 \n | \n \n 37,453.72 us \n | \n \n 1,543.051 us \n | \n \n 586450.38 KB \n | \n
| \n StringBuilder \n | \n \n .NET Framework 4.8.1 \n | \n \n 178.32 us \n | \n \n 6.148 us \n | \n \n 244.15 KB \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n[Params(10_000)]\npublic int Iterations;\n\n[Benchmark]\npublic void StringConcatenation()\n{\n string str = \"\";\n for (int i = 0; i < Iterations; i++)\n {\n str = str + \"append\";\n }\n}\n\n[Benchmark]\npublic void StringBuilder()\n{\n StringBuilder builder = new StringBuilder();\n for (int i = 0; i < Iterations; i++)\n {\n builder.Append(\"append\");\n }\n _ = builder.ToString();\n}\n\nHardware Configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S1643.json", "content": "{\n \"title\": \"Strings should not be concatenated using \\u0027+\\u0027 in a loop\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1643\",\n \"sqKey\": \"S1643\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S1656.html", "content": "
Re-assigning a variable to itself is a defect as it has no actual effect and indicates meaning to do something else. It usually means that:
\n\npublic class Choice {\n private bool selected;\n\n public void MakeChoice(bool selected)\n {\n selected = selected; // Noncompliant\n }\n}\n\n\npublic class Choice {\n private bool selected;\n\n public void MakeChoice(bool selected)\n {\n this.selected = selected; // Compliant\n }\n}\n\nDeclaring multiple variable on one line is difficult to read.
\n\nclass MyClass\n{\n private int a, b; // Noncompliant\n\n public void Method()\n {\n int c, d; // Noncompliant\n }\n}\n\n\nclass MyClass\n{\n private int a;\n private int b;\n\n public void Method()\n {\n int c;\n int d;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1659.json",
"content": "{\n \"title\": \"Multiple variables should not be declared on the same line\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1659\",\n \"sqKey\": \"S1659\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1694.html",
"content": "A class with only abstract methods and no inheritable behavior should be converted to an interface.
The purpose of an abstract\nclass is to provide some overridable behaviors while also defining methods that are required to be implemented by sub-classes.
A class that contains only abstract methods, often called pure abstract class, is effectively an interface, but with the disadvantage\nof not being able to be implemented by multiple classes.
Using interfaces over pure abstract classes presents multiple advantages:
\nabstract classes that contain non-abstract methods, in addition to abstract ones, cannot easily be converted to\ninterfaces, and are not the subject of this rule:
\npublic abstract class Lamp // Compliant: Glow is abstract, but FlipSwitch is not\n{\n private bool switchLamp = false;\n\n public abstract void Glow();\n\n public void FlipSwitch()\n {\n switchLamp = !switchLamp;\n if (switchLamp)\n {\n Glow();\n }\n }\n}\n\nNotice that, since C# 8.0, you can also define
However, interfaces cannot have fields (such as switchLamp in the example above), and that remains true even in C# 8.0 and upwards.\nThis can be a valid reason to still prefer an abstract class over an interface.
Convert the abstract class to an interface with the same methods.
\npublic abstract class Animal // Noncompliant: should be an interface\n{\n public abstract void Move();\n public abstract void Feed();\n}\n\n\npublic interface Animal\n{\n void Move();\n void Feed();\n}\n\nCatching NullReferenceException is generally considered a bad practice because it can hide bugs in your code. Instead of catching this\nexception, you should aim to prevent it. This makes your code more robust and easier to understand. In addition, constantly catching and handling\nNullReferenceException can lead to performance issues. Exceptions are expensive in terms of system resources, so they should be used\ncautiously and only for exceptional conditions, not for regular control flow.
Instead of catching NullReferenceException, it’s better to prevent it from happening in the first place. You can do this by using null checks or\nnull conditional operators (?.) before accessing members of an object.
\npublic int GetLengthPlusTwo(string str)\n{\n try\n {\n return str.Length + 2;\n }\n catch (NullReferenceException e)\n {\n return 2;\n }\n}\n\n\npublic int GetLengthPlusTwo(string str)\n{\n if (str is null)\n {\n return 2;\n }\n return str.Length + 2;\n}\n\nUsing the equality == and inequality != operators to compare two objects generally works. The operators can be\noverloaded, and therefore the comparison can resolve to the appropriate method. However, when the operators are used on interface instances, then\n== resolves to reference equality, which may result in unexpected behavior if implementing classes override Equals.\nSimilarly, when a class overrides Equals, but instances are compared with non-overloaded ==, there is a high chance that\nvalue comparison was meant instead of the reference one.
\npublic interface IMyInterface\n{\n}\n\npublic class MyClass : IMyInterface\n{\n public override bool Equals(object obj)\n {\n //...\n }\n}\n\npublic class Program\n{\n public static void Method(IMyInterface instance1, IMyInterface instance2)\n {\n if (instance1 == instance2) // Noncompliant, will do reference equality check, but was that intended? MyClass overrides Equals.\n {\n Console.WriteLine(\"Equal\");\n }\n }\n}\n\n\npublic interface IMyInterface\n{\n}\n\npublic class MyClass : IMyInterface\n{\n public override bool Equals(object obj)\n {\n //...\n }\n}\n\npublic class Program\n{\n public static void Method(IMyInterface instance1, IMyInterface instance2)\n {\n if (object.Equals(instance1, instance2)) // object.Equals checks for null and then calls the instance based Equals, so MyClass.Equals\n {\n Console.WriteLine(\"Equal\");\n }\n }\n}\n\nThe rule does not report on comparisons of System.Type instances and on comparisons inside Equals overrides.
It also does not raise an issue when one of the operands is null nor when one of the operand is cast to object (because\nin this case we want to ensure reference equality even if some == overload is present).
Calling an overridable method from a constructor could result in failures or strange behaviors when instantiating a subclass which overrides the\nmethod.
\nWhen constructing an object of a derived class, the constructor of the parent class is invoked first, and only then the constructor of the derived\nclass is called. This sequential construction process applies to multiple levels of inheritance as well, starting from the base class and progressing\nto the most derived class.
\nIf an overridable method is called within the constructor of the parent class, it may inadvertently invoke an overridden implementation in the\nderived class. This can lead to unexpected failures or strange behaviors because the object’s construction is still in progress and may not have\nreached a fully initialized state. Consequently, the overridden method may rely on uninitialized members or have assumptions about the object’s state\nthat are not yet valid.
\nFor example:
\n\npublic class Parent\n{\n public Parent()\n {\n DoSomething(); // Noncompliant\n }\n\n public virtual void DoSomething() // can be overridden\n {\n // ...\n }\n}\n\npublic class Child : Parent\n{\n private string foo;\n\n public Child(string foo) // leads to call DoSomething() in Parent constructor which triggers a NullReferenceException as foo has not yet been initialized\n {\n this.foo = foo;\n }\n\n public override void DoSomething()\n {\n Console.WriteLine(this.foo.Length);\n }\n}\n\nChild class constructor starts by calling the Parent class constructor.Parent class constructor calls the method DoSomething, which has been overridden in the Child\n class.Child class overridden DoSomething method depends on fields that are initialized in the\n Child class constructor, unexpected behavior (such as a NullReferenceException) can result, because the fields aren’t\n initialized yet.Depending on the context, you can either:
\nsealed in the current\n classsealed\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\nclass Child : Parent\n{\n public Child()\n {\n DoSomething(); // Noncompliant\n }\n}\n\n\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\nclass Child : Parent\n{\n public Child()\n {\n DoSomething(); // Noncompliant\n }\n}\n\n\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\nclass Child : Parent\n{\n public Child()\n {\n DoSomething(); // Noncompliant\n }\n}\n\n\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\nclass Child : Parent\n{\n public Child()\n {\n // Call removed\n }\n}\n\n\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\nclass Child : Parent\n{\n public Child()\n {\n DoSomething();\n }\n\n // Method sealed to prevent overriding\n public sealed override void DoSomething()\n {\n base.DoSomething();\n }\n}\n\n\nclass Parent\n{\n public virtual void DoSomething() { }\n}\n\n// Class sealed to prevent inheritance\nsealed class Child : Parent\n{\n public Child()\n {\n DoSomething();\n }\n}\n\nA loop statement with at most one\niteration is equivalent to an if statement; the following block is executed only once.
If the initial intention was to conditionally execute the block only once, an if statement should be used instead. If that was not the\ninitial intention, the block of the loop should be fixed so the block is executed multiple times.
A loop statement with at most one iteration can happen when a statement unconditionally transfers control, such as a
This rule raises when the following statements are misplaced:
\nbreakcontinuereturnthrow\npublic object Method(IEnumerable<object> items)\n{\n for (int i = 0; i < 10; i++)\n {\n Console.WriteLine(i);\n break; // Noncompliant: loop only executes once\n }\n\n foreach (object item in items)\n {\n return item; // Noncompliant: loop only executes once\n }\n return null;\n}\n\n\npublic object Method(IEnumerable<object> items)\n{\n for (int i = 0; i < 10; i++)\n {\n Console.WriteLine(i);\n }\n\n var item = items.FirstOrDefault();\n if (item != null)\n {\n return item;\n }\n return null;\n}\n\nfor, foreach, do, and whilebreak, continue, return, and gotothrow statementUsing the same value on both sides of certain operators is a code defect. In the case of logical operators, it is either a copy/paste error and,\ntherefore, a bug, or it is simply duplicated code and should be simplified. For bitwise operators and most binary mathematical operators, having the\nsame value on both sides of an operator yields predictable results and should be simplified as well to avoid further code defects.
\nThis rule raises for the following operators.
\n== and !=)<\n =, <, >, >=)| )||)&)&&)^)-)\\)%)-=)\\=)This rule ignores the following operators:
\n\nif ( a == a ) // always true\n{\n doZ();\n}\nif ( a != a ) // always false\n{\n doY();\n}\nif ( a == b && a == b ) // if the first one is true, the second one is too\n{\n doX();\n}\nif ( a == b || a == b ) // if the first one is true, the second one is too\n{\n doW();\n}\n\nint j = 5 / 5; // always 1\nint k = 5 - 5; // always 0\n\nc.Equals(c); // always true\nObject.Equals(c, c); // always true\n\nNested switch structures are difficult to understand because you can easily confuse the cases of an inner switch as\nbelonging to an outer statement. Therefore nested switch statements should be avoided.
Specifically, you should structure your code to avoid the need for nested switch statements, but if you cannot, then consider moving\nthe inner switch to another function.
Creating objects that are not used is a vulnerability that can lead to unexpected behavior.
\nIf this was done intentionally due to side effects in the object’s constructor, the code should be moved to a dedicated method.
\n\npublic void Method(MyObject myObject)\n{\n if (myObject is null)\n {\n new MyObject(); // Noncompliant\n }\n\n if (myObject.IsCorrupted)\n {\n new ArgumentException($\"{nameof(myObject)} is corrupted\"); // Noncompliant\n }\n\n // ...\n}\n\n\npublic void Method(MyObject myObject)\n{\n if (myObject is null)\n {\n myObject = new MyObject(); // Compliant\n }\n\n if (myObject.IsCorrupted)\n {\n throw new ArgumentException($\"{nameof(myObject)} is corrupted\"); // Compliant\n }\n\n // ...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1848.json",
"content": "{\n \"title\": \"Objects should not be created to be dropped immediately without being used\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1848\",\n \"sqKey\": \"S1848\",\n \"scope\": \"Main\",\n \"quickfix\": \"infeasible\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1854.html",
"content": "Dead stores refer to assignments made to local variables that are subsequently never used or immediately overwritten. Such assignments are\nunnecessary and don’t contribute to the functionality or clarity of the code. They may even negatively impact performance. Removing them enhances code\ncleanliness and readability. Even if the unnecessary operations do not do any harm in terms of the program’s correctness, they are - at best - a waste\nof computing resources.
\nNo issue is reported when
\ntry blocks-1, 0, 1, null, true, false,\n \"\" or string.EmptyRemove the unnecessary assignment, then test the code to make sure that the right-hand side of a given assignment had no side effects (e.g. a\nmethod that writes certain data to a file and returns the number of written bytes).
\nYou can also use discards (rather than a variable)\nto express that result of a method call is ignored on purpose.
\n\nint Foo(int y)\n{\n int x = 100; // Noncompliant: dead store\n x = 150; // Noncompliant: dead store\n x = 200;\n return x + y;\n}\n\n\nint Foo(int y)\n{\n int x = 200; // Compliant: no unnecessary assignment\n return x + y;\n}\n\nInvoking a method designed to return a string representation of an object which is already a string is a waste of keystrokes. Similarly, explicitly\ninvoking ToString() when the compiler would do it implicitly is also needless code-bloat.
This rule raises an issue when ToString() is invoked:
stringstring operand to concatenationstring.Format\nvar s = \"foo\";\nvar t = \"fee fie foe \" + s.ToString(); // Noncompliant\nvar someObject = new object();\nvar u = \"\" + someObject.ToString(); // Noncompliant\nvar v = string.Format(\"{0}\", someObject.ToString()); // Noncompliant\n\n\nvar s = \"foo\";\nvar t = \"fee fie foe \" + s;\nvar someObject = new object();\nvar u = \"\" + someObject;\nvar v = string.Format(\"{0}\", someObject);\n\nThe rule does not report on value types, where leaving off the ToString() call would result in automatic boxing.
\nvar v = string.Format(\"{0}\", 1.ToString());\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1858.json",
"content": "{\n \"title\": \"\\\"ToString()\\\" calls should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1858\",\n \"sqKey\": \"S1858\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1862.html",
"content": "A chain of if/else\nif statements is evaluated from top to bottom. At most, only one branch will be executed: the first statement with a condition that evaluates to\ntrue. Therefore, duplicating a condition leads to unreachable code inside the duplicated condition block. Usually, this is due to a\ncopy/paste error.
The result of such duplication can lead to unreachable code or even to unexpected behavior.
\n\nif (param == 1)\n{\n OpenWindow();\n}\nelse if (param == 2)\n{\n CloseWindow();\n}\nelse if (param == 1) // Noncompliant: condition has already been checked\n{\n MoveWindowToTheBackground(); // unreachable code\n}\n\n\nif (param == 1)\n{\n OpenWindow();\n}\nelse if (param == 2)\n{\n CloseWindow();\n}\nelse if (param == 3)\n{\n MoveWindowToTheBackground();\n}\n\nWhen the same code is duplicated in two or more separate branches of a conditional, it can make the code harder to understand, maintain, and can\npotentially introduce bugs if one instance of the code is changed but others are not.
\nHaving two cases in a switch statement or two branches in an if chain with the same implementation is at\nbest duplicate code, and at worst a coding error.
\nif (a >= 0 && a < 10)\n{\n DoFirst();\n DoTheThing();\n}\nelse if (a >= 10 && a < 20)\n{\n DoTheOtherThing();\n}\nelse if (a >= 20 && a < 50) // Noncompliant; duplicates first condition\n{\n DoFirst();\n DoTheThing();\n}\n\n\nswitch (i)\n{\n case 1:\n DoFirst();\n DoSomething();\n break;\n case 2:\n DoSomethingDifferent();\n break;\n case 3: // Noncompliant; duplicates case 1's implementation\n DoFirst();\n DoSomething();\n break;\n default:\n DoTheRest();\n}\n\nIf the same logic is truly needed for both instances, then:
\nif chain they should be combined\nif ((a >= 0 && a < 10) || (a >= 20 && a < 50))\n{\n DoFirst();\n DoTheThing();\n}\nelse if (a >= 10 && a < 20)\n{\n DoTheOtherThing();\n}\n\nswitch, one should fall through to the other\nswitch (i)\n{\n case 1:\n case 3:\n DoFirst();\n DoSomething();\n break;\n case 2:\n DoSomethingDifferent();\n break;\n default:\n DoTheRest();\n}\n\nThe rule does not raise an issue for blocks in an if chain that contain a single line of code. The same applies to blocks in a\nswitch statement that contain a single line of code with or without a following break.
\nif (a >= 0 && a < 10)\n{\n DoTheThing();\n}\nelse if (a >= 10 && a < 20)\n{\n DoTheOtherThing();\n}\nelse if (a >= 20 && a < 50) //no issue, usually this is done on purpose to increase the readability\n{\n DoTheThing();\n}\n\nHowever, this exception does not apply to if chains without an else statement or to a switch statement\nwithout a default clause when all branches have the same single line of code.
\nif (a == 1)\n{\n DoSomething(); // Noncompliant, this might have been done on purpose but probably not\n}\nelse if (a == 2)\n{\n DoSomething();\n}\n\nCasting expressions are utilized to convert one data type to another, such as transforming an integer into a string. This is especially crucial in\nstrongly typed languages like C, C++, C#, Java, Python, and others.
\nHowever, there are instances where casting expressions are not needed. These include situations like:
\nThese scenarios are considered unnecessary casting expressions. They can complicate the code and make it more difficult to understand, without\noffering any advantages.
\nAs a result, it’s generally advised to avoid unnecessary casting expressions. Instead, rely on the language’s type system to ensure type safety and\ncode clarity.
\nIssues are not raised against the
To fix your code remove the unnecessary casting expression.
\n\npublic int Example(int i)\n{\n return (int) (i + 42); // Noncompliant\n}\n\npublic IEnumerable<int> ExampleCollection(IEnumerable<int> coll)\n{\n return coll.Reverse().OfType<int>(); // Noncompliant\n}\n\n\npublic int Example(int i)\n{\n return i + 42;\n}\n\npublic IEnumerable<int> ExampleCollection(IEnumerable<int> coll)\n{\n return coll.Reverse();\n}\n\n\nbool b = (bool)default; // Doesn't raise an issue\n\n
An inheritance list entry is redundant if:
\nObject - all classes extend Object implicitly.int for an enumSuch redundant declarations should be removed because they needlessly clutter the code and can be confusing.
\n\npublic class MyClass : Object // Noncompliant\n\nenum MyEnum : int // Noncompliant\n\n
\npublic class MyClass\n\nenum MyEnum\n\n\n" }, { "path": "analyzers/rspec/cs/S1939.json", "content": "{\n \"title\": \"Inheritance list should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1939\",\n \"sqKey\": \"S1939\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S1940.html", "content": "
It is needlessly complex to invert the result of a boolean comparison. The opposite comparison should be made instead.
\n\nif ( !(a == 2)) { ...} // Noncompliant\nbool b = !(i < 10); // Noncompliant\n\n\nif (a != 2) { ...}\nbool b = (i >= 10);\n\n\n"
},
{
"path": "analyzers/rspec/cs/S1940.json",
"content": "{\n \"title\": \"Boolean checks should not be inverted\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1940\",\n \"sqKey\": \"S1940\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S1944.html",
"content": "A cast is an
\nvoid Method(object value)\n{\n int i;\n i = (int)value; // Casting (explicit conversion) from float to int\n}\n\nIn most cases, the compiler will be able to catch invalid casts between incompatible value types or reference types.
\nHowever, the compiler will not be able to detect invalid casts to
Invalid casts will lead to unexpected behaviors or runtime errors such as
No issue is reported if the interface has no implementing class in the assembly.
\nTo prevent an InvalidCastException from raising during an explicit conversion, it is recommended to use the as operator.\nWhen the conversion is not possible, the as operator returns null and will never raise an exception.
\npublic interface IMyInterface\n{ /* ... */ }\n\npublic class Implementer : IMyInterface\n{ /* ... */ }\n\npublic class AnotherClass\n{ /* ... */ }\n\npublic static class Program\n{\n public static void Main()\n {\n var another = new AnotherClass();\n var x = (IMyInterface)another; // Noncompliant: InvalidCastException is being thrown\n }\n}\n\n\npublic interface IMyInterface\n{ /* ... */ }\n\npublic class Implementer : IMyInterface\n{ /* ... */ }\n\npublic class AnotherClass\n{ /* ... */ }\n\npublic static class Program\n{\n public static void Main()\n {\n var another = new AnotherClass();\n var x = another as IMyInterface; // Compliant: but will always be null\n }\n}\n\nis\n operatoras\n operatorThe for loop is designed to iterate over a range using a counter variable, with the counter being updated in the loop’s increment\nsection. Misusing this structure can lead to issues such as infinite loops if the counter is not updated correctly. If this is intentional, use a\nwhile or do while loop instead of a for loop.
Using a for loop for purposes other than its intended use can lead to confusion and potential bugs. If the for loop structure does not\nfit your needs, consider using an alternative
Move the counter variable update to the loop’s increment section. If this is impossible, consider using another iteration statement instead.
\n\nint sum = 0;\nfor (int i = 0; i < 10; sum++) // Noncompliant: `i` is not updated in the increment section\n{\n // ...\n i++;\n}\n\n\nfor (int i = 0;; i++) // Noncompliant: the loop condition is empty although incrementing `i`\n{\n // ...\n}\n\n\nint sum = 0;\nfor (int i = 0; i < 10; i++)\n{\n // ...\n sum++;\n}\n\n\nint i = 0;\nwhile (true)\n{\n // ...\n i++;\n}\n\nfor\n statementfor, foreach, do, and whileThis vulnerability increases the likelihood that attackers are able to compute the cleartext of password hashes.
\nDuring the process of password hashing, an additional component, known as a \"salt,\" is often integrated to bolster the overall security. This salt,\nacting as a defensive measure, primarily wards off certain types of attacks that leverage pre-computed tables to crack passwords.
\nHowever, potential risks emerge when the salt is deemed insecure. This can occur when the salt is consistently the same across all users or when it\nis too short or predictable. In scenarios where users share the same password and salt, their password hashes will inevitably mirror each other.\nSimilarly, a short salt heightens the probability of multiple users unintentionally having identical salts, which can potentially lead to identical\npassword hashes. These identical hashes streamline the process for potential attackers to recover clear-text passwords. Thus, the emphasis on\nimplementing secure, unique, and sufficiently lengthy salts in password-hashing functions is vital.
\nDespite best efforts, even well-guarded systems might have vulnerabilities that could allow an attacker to gain access to the hashed passwords.\nThis could be due to software vulnerabilities, insider threats, or even successful phishing attempts that give attackers the access they need.
\nOnce the attacker has these hashes, they will likely attempt to crack them using a couple of methods. One is brute force, which entails trying\nevery possible combination until the correct password is found. While this can be time-consuming, having the same salt for all users or a short salt\ncan make the task significantly easier and faster.
\nIf multiple users have the same password and the same salt, their password hashes would be identical. This means that if an attacker successfully\ncracks one hash, they have effectively cracked all identical ones, granting them access to multiple accounts at once.
\nA short salt, while less critical than a shared one, still increases the odds of different users having the same salt. This might create clusters\nof password hashes with identical salt that can then be attacked as explained before.
\nWith short salts, the probability of a collision between two users' passwords and salts couple might be low depending on the salt size. The shorter\nthe salt, the higher the collision probability. In any case, using longer, cryptographically secure salt should be preferred.
\nTo securely store password hashes, it is a recommended to rely on key derivation functions that are computationally intensive. Examples of such\nfunctions are:
\nWhen they are used for password storage, using a secure, random salt is required.
\nHowever, those functions can also be used for other purposes such as master key derivation or password-based pre-shared key generation. In those\ncases, the implemented cryptographic protocol might require using a fixed salt to derive keys in a deterministic way. In such cases, using a fixed\nsalt is safe and accepted.
\nThe following code contains examples of hard-coded salts.
\n\nusing System.Security.Cryptography;\n\npublic static void hash(string password)\n{\n var salt = Encoding.UTF8.GetBytes(\"salty\");\n var hashed = new Rfc2898DeriveBytes(password, salt); // Noncompliant\n}\n\n\nusing System.Security.Cryptography;\n\npublic static void hash(string password)\n{\n var saltSize = 16;\n var iterations = 100_000;\n var hashed = new Rfc2898DeriveBytes(password, saltSize, iterations, HashAlgorithmName.SHA512);\n}\n\nThis code ensures that each user’s password has a unique salt value associated with it. It generates a salt randomly and with a length that\nprovides the required security level. It uses a salt length of at least 16 bytes (128 bits), as recommended by industry standards.
\nIn the case of the code sample, the class automatically takes care of generating a secure salt if none is specified.
\nHard-coding credentials in source code or binaries makes it easy for attackers to extract sensitive information, especially in distributed or\nopen-source applications. This practice exposes your application to significant security risks.
\nThis rule flags instances of hard-coded credentials used in database and LDAP connections. It looks for hard-coded credentials in connection\nstrings, and for variable names that match any of the patterns from the provided list.
\nIn the past, it has led to the following vulnerabilities:
\nCredentials should be stored in a configuration file that is not committed to the code repository, in a database, or managed by your cloud\nprovider’s secrets management service. If a password is exposed in the source code, it must be changed immediately.
\n\nstring username = \"admin\";\nstring password = \"Admin123\"; // Noncompliant\nstring usernamePassword = \"user=admin&password=Admin123\"; // Noncompliant\nstring url = \"scheme://user:Admin123@domain.com\"; // Noncompliant\n\n
\nstring username = \"admin\";\nstring password = GetEncryptedPassword();\nstring usernamePassword = string.Format(\"user={0}&password={1}\", GetEncryptedUsername(), GetEncryptedPassword());\nstring url = $\"scheme://{username}:{password}@domain.com\";\n\nstring url2 = \"http://guest:guest@domain.com\"; // Compliant\nconst string Password_Property = \"custom.password\"; // Compliant\n\nFormatted SQL queries can be difficult to maintain, debug and can increase the risk of SQL injection when concatenating untrusted values into the\nquery. However, this rule doesn’t detect SQL injections (unlike rule {rule:csharpsquid:S3649}), the goal is only to highlight complex/formatted\nqueries.
\nThere is a risk if you answered yes to any of those questions.
\n\npublic void Foo(DbContext context, string query, string param)\n{\n string sensitiveQuery = string.Concat(query, param);\n context.Database.ExecuteSqlCommand(sensitiveQuery); // Sensitive\n context.Query<User>().FromSql(sensitiveQuery); // Sensitive\n\n context.Database.ExecuteSqlCommand($\"SELECT * FROM mytable WHERE mycol={value}\", param); // Sensitive, the FormattableString is evaluated and converted to RawSqlString\n string query = $\"SELECT * FROM mytable WHERE mycol={param}\";\n context.Database.ExecuteSqlCommand(query); // Sensitive, the FormattableString has already been evaluated, it won't be converted to a parametrized query.\n}\n\npublic void Bar(SqlConnection connection, string param)\n{\n SqlCommand command;\n string sensitiveQuery = string.Format(\"INSERT INTO Users (name) VALUES (\\\"{0}\\\")\", param);\n command = new SqlCommand(sensitiveQuery); // Sensitive\n\n command.CommandText = sensitiveQuery; // Sensitive\n\n SqlDataAdapter adapter;\n adapter = new SqlDataAdapter(sensitiveQuery, connection); // Sensitive\n}\n\n\npublic void Foo(DbContext context, string query, string param)\n{\n context.Database.ExecuteSqlCommand(\"SELECT * FROM mytable WHERE mycol=@p0\", param); // Compliant, it's a parametrized safe query\n}\n\nWhen a cookie is protected with the secure attribute set to true it will not be send by the browser over an unencrypted HTTP\nrequest and thus cannot be observed by an unauthorized person during a man-in-the-middle attack.
There is a risk if you answered yes to any of those questions.
\nHTTPs everywhere so setting the secure flag to true should be the default behaviour\n when creating cookies.secure flag to true for session-cookies.When the HttpCookie.Secure property is set to false then the cookie will be send during an unencrypted HTTP request:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\nmyCookie.Secure = false; // Sensitive: a security-sensitive cookie is created with the secure flag set to false\n\n
The default value of\nSecure flag is false, unless overwritten by an application’s configuration file:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\n// Sensitive: a security-sensitive cookie is created with the secure flag not defined (by default set to false)\n\n
Set the HttpCookie.Secure property to true:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\nmyCookie.Secure = true; // Compliant\n\n
Or change the default flag values for the whole application by editing the
\n<httpCookies httpOnlyCookies=\"true\" requireSSL=\"true\" />\n\n
requireSSL attribute corresponds programmatically to the Secure field.httpOnlyCookies attribute corresponds programmatically to the httpOnly field.There is no good excuse for an empty class. If it’s being used simply as a common extension point, it should be replaced with an\ninterface. If it was stubbed in as a placeholder for future development it should be fleshed-out. In any other case, it should be\neliminated.
\npublic class Empty // Noncompliant\n{\n}\n\n\npublic interface IEmpty\n{\n}\n\nCommand, Message, Event, or Query are ignored as messaging\n libraries often use them.System.Exception are ignored; even an empty Exception class can provide helpful information by its type name\n alone.System.Attribute and classes annotated with attributes are ignored.PageModel class used in ASP.NET Core Razor Pages — are ignored.\nusing Microsoft.AspNetCore.Mvc.RazorPages;\n\npublic class EmptyPageModel: PageModel // Compliant - an empty PageModel can be fully functional, the C# code can be in the cshtml file\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2094.json",
"content": "{\n \"title\": \"Classes should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2094\",\n \"sqKey\": \"S2094\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2114.html",
"content": "Passing a collection as an argument to the collection’s own method is a code defect. Doing so might either have unexpected side effects or always\nhave the same result.
\nAnother case is using set-like operations. For example, using
Exceptions to this rule are the methods AddRange and Concat, since the developer can use them to\nmultiply the list elements or the list itself respectively.
\nvar list = new List<int>();\n\nlist.Union(list); // Noncompliant: always returns list\nlist.Intersect(list); // Noncompliant: always returns list\nlist.Except(list); // Noncompliant: always returns empty\nlist.SequenceEqual(list); // Noncompliant: always returns true\n\nvar set = new HashSet<int>();\nset.UnionWith(set); // Noncompliant: no changes\nset.IntersectWith(set); // Noncompliant: no changes\nset.ExceptWith(set); // Noncompliant: always returns empty\nset.SymmetricExceptWith(set); // Noncompliant: always returns empty\nset.IsProperSubsetOf(set); // Noncompliant: always returns false\nset.IsProperSupersetOf(set); // Noncompliant: always returns false\nset.IsSubsetOf(set); // Noncompliant: always returns true\nset.IsSupersetOf(set); // Noncompliant: always returns true\nset.Overlaps(set); // Noncompliant: always returns true\nset.SetEquals(set); // Noncompliant: always returns true\n\nlist.AddRange(list); // Compliant\nlist.Concat(list); // Compliant\n\n
When accessing a database, an empty password should be avoided as it introduces a weakness.
\nWhen a database does not require a password for authentication, it allows anyone to access and manipulate the data stored within it. Exploiting\nthis vulnerability typically involves identifying the target database and establishing a connection to it without the need for any authentication\ncredentials.
\nOnce connected, an attacker can perform various malicious actions, such as viewing, modifying, or deleting sensitive information, potentially\nleading to data breaches or unauthorized access to critical systems. It is crucial to address this vulnerability promptly to ensure the security and\nintegrity of the database and the data it contains.
\nWhen a database lacks a password for authentication, it opens the door for unauthorized individuals to gain access to sensitive data. This can\ninclude personally identifiable information (PII), financial records, intellectual property, or any other confidential information stored in the\ndatabase. Without proper access controls in place, malicious actors can exploit this vulnerability to retrieve sensitive data, potentially leading to\nidentity theft, financial loss, or reputational damage.
\nWithout a password requirement, unauthorized individuals can gain unrestricted access to a database, potentially compromising the integrity of the\nentire system. Attackers can inject malicious code, alter configurations, or manipulate data within the database, leading to system malfunctions,\nunauthorized system access, or even complete system compromise. This can disrupt business operations, cause financial losses, and expose the\norganization to further security risks.
\nThe absence of a password for database access allows anyone to make modifications or deletions to the data stored within it. This poses a\nsignificant risk, as unauthorized changes can lead to data corruption, loss of critical information, or the introduction of malicious content. For\nexample, an attacker could modify financial records, tamper with customer orders, or delete important files, causing severe disruptions to business\nprocesses and potentially leading to financial and legal consequences.
\nOverall, the lack of a password configured to access a database poses a serious security risk, enabling unauthorized access, data breaches, system\ncompromise, and unwanted modifications or deletions. It is essential to address this vulnerability promptly to safeguard sensitive data, maintain\nsystem integrity, and protect the organization from potential harm.
\nThe following code uses an empty password to connect to a SQL Server database.
\nThe vulnerability can be fixed by using Windows authentication (sometimes referred to as integrated security).
\n\nprotected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)\n{\n optionsBuilder.UseSqlServer(\"Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=\"); // Noncompliant\n}\n\n\nprotected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)\n{\n optionsBuilder.UseSqlServer(\"Server=myServerAddress;Database=myDataBase;Integrated Security=True\");\n}\n\nWhen the connection string includes the Integrated Security=true parameter, it enables Windows authentication (sometimes called\nintegrated security) for the database connection. With integrated security, the user’s Windows credentials are used to authenticate and authorize\naccess to the database. It eliminates the need for a separate username and password for the database connection. Integrated security simplifies\nauthentication and leverages the existing Windows authentication infrastructure for secure database access in your C# application.
It’s important to note that when using integrated security, the user running the application must have the necessary permissions to access the\ndatabase. Ensure that the user account running the application has the appropriate privileges and is granted access to the database.
\nThe syntax employed in connection strings varies by provider:
\n| \n Syntax \n | \n \n Supported by \n | \n
| \n
| \n \n SQL Server, Oracle, Postgres \n | \n
| \n
| \n \n SQL Server, OLE DB \n | \n
| \n
| \n \n MySQL \n | \n
| \n
| \n \n SQL Server \n | \n
| \n
| \n \n ODBC \n | \n
Note: Some providers such as MySQL do not support Windows authentication with .NET Core.
\nIt could be tempting to replace the empty password with a hard-coded one. Hard-coding passwords in the code can pose significant security risks.\nHere are a few reasons why it is not recommended:
\nTo mitigate these risks, it is recommended to use secure methods for storing and retrieving passwords, such as using environment variables,\nconfiguration files, or secure key management systems. These methods allow for better security, flexibility, and separation of sensitive information\nfrom the codebase.
\nThe following configuration file uses an empty password to connect to a database.
\nThe vulnerability can be fixed by using Windows authentication (sometimes referred to as integrated security)
\n\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<configuration>\n <connectionStrings>\n <add name=\"myConnection\" connectionString=\"Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=\" /> <!-- Noncompliant -->\n </connectionStrings>\n</configuration>\n\n
\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<configuration>\n <connectionStrings>\n <add name=\"myConnection\" connectionString=\"Server=myServerAddress;Database=myDataBase;Integrated Security=True\" />\n </connectionStrings>\n</configuration>\n\n
When the connection string includes the Integrated Security=true parameter, it enables Windows authentication (sometimes called\nintegrated security) for the database connection. With integrated security, the user’s Windows credentials are used to authenticate and authorize\naccess to the database. It eliminates the need for a separate username and password for the database connection. Integrated security simplifies\nauthentication and leverages the existing Windows authentication infrastructure for secure database access in your C# application.
It’s important to note that when using integrated security, the user running the application must have the necessary permissions to access the\ndatabase. Ensure that the user account running the application has the appropriate privileges and is granted access to the database.
\nThe syntax employed in connection strings varies by provider:
\n| \n Syntax \n | \n \n Supported by \n | \n
| \n
| \n \n SQL Server, Oracle, Postgres \n | \n
| \n
| \n \n SQL Server, OLE DB \n | \n
| \n
| \n \n MySQL \n | \n
| \n
| \n \n SQL Server \n | \n
| \n
| \n \n ODBC \n | \n
Note: Some providers such as MySQL do not support Windows authentication with .NET Core.
\nIt could be tempting to replace the empty password with a hard-coded one. Hard-coding passwords in the code can pose significant security risks.\nHere are a few reasons why it is not recommended:
\nTo mitigate these risks, it is recommended to use secure methods for storing and retrieving passwords, such as using environment variables,\nconfiguration files, or secure key management systems. These methods allow for better security, flexibility, and separation of sensitive information\nfrom the codebase.
\nWhen using the x++ is the value before the operation\nx.
This means that in some cases, the result might not be what you expect:
\nx++ to x, it’s the same as assigning x to itself, since the value is assigned before the\n increment takes placex++, the returning value is x, not x+1The same applies to the postfix and prefix
To solve the issue in assignments, eliminate the assignment, since x\\++ mutates x anyways.
To solve the issue in return statements, consider using the ++x is the value after the operation,\nwhich is x+1, as one might expect.
The same applies to the postfix and prefix
\nint PickNumber()\n{\n int i = 0;\n int j = 0;\n\n i = i++; // Noncompliant: i is still 0\n return j--; // Noncompliant: returns 0\n}\n\n\nint PickNumber()\n{\n int i = 0;\n int j = 0;\n\n i++; // Compliant: i is incremented to 1\n return --j; // Compliant: returns -1\n}\n\nWhen an exception is logged and rethrown, the upstream code may not be aware that the exception has already been logged. As a result, the same\nexception gets logged multiple times, making it difficult to identify the root cause of the issue. This can be particularly problematic in\nmulti-threaded applications where messages from other threads can be interwoven with the repeated log entries.
\nThis rule will not generate issues if, within the catch block, one of the following conditions are met:
\nTo address this issue, it is recommended to modify the code to log exceptions only when they are handled locally. In all other cases, simply\nrethrow the exception and allow the higher-level layers of the application to handle the logging and appropriate actions.
\n\ntry {}\ncatch (Exception ex)\n{\n logger.LogError(ex.Message);\n throw;\n}\n\n\ntry {}\ncatch (Exception ex)\n{\n logger.LogError(ex.Message);\n // Handle exception\n}\n\nor
\n\ntry {}\ncatch (Exception ex)\n{\n // ...\n throw;\n}\n\nBeginning with C# 7, it is possible to add underscores ('_') to numeric literals to enhance readability. The addition of underscores in this manner\nhas no semantic meaning, but makes it easier for maintainers to understand the code.
\nThe number of digits to the left of a decimal point needed to trigger this rule varies by base.
\n| Base | \nMinimum digits | \n
|---|---|
| \n binary \n | \n \n 9 \n | \n
| \n decimal \n | \n \n 6 \n | \n
| \n hexadecimal \n | \n \n 9 \n | \n
It is only the presence of underscores, not their spacing that is scrutinized by this rule.
\nNote that this rule is automatically disabled when the project’s C# version is lower than 7.
\nint i = 10000000; // Noncompliant; is this 10 million or 100 million?\nint j = 0b01101001010011011110010101011110; // Noncompliant\nlong l = 0x7fffffffffffffffL; // Noncompliant\n\n
\nint i = 10_000_000;\nint j = 0b01101001_01001101_11100101_01011110;\nlong l = 0x7fff_ffff_ffff_ffffL;\n\n\n" }, { "path": "analyzers/rspec/cs/S2148.json", "content": "{\n \"title\": \"Underscores should be used to make large numbers readable\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2148\",\n \"sqKey\": \"S2148\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S2156.html", "content": "
The difference between private and protected visibility is that child classes can see and use protected\nmembers, but they cannot see private ones. Since a sealed class cannot have children, marking its members\nprotected is confusingly pointless.
\npublic sealed class MySealedClass\n{\n protected string name = \"Fred\"; // Noncompliant\n protected void SetName(string name) // Noncompliant\n {\n // ...\n }\n}\n\n\npublic sealed class MySealedClass\n{\n private string name = \"Fred\";\n public void SetName(string name)\n {\n // ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2156.json",
"content": "{\n \"title\": \"\\\"sealed\\\" classes should not have \\\"protected\\\" members\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2156\",\n \"sqKey\": \"S2156\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2166.html",
"content": "Clear, communicative naming is important in code. It helps maintainers and API users understand the intentions for and uses of a unit of code.\nUsing \"exception\" in the name of a class that does not extend Exception or one of its subclasses is a clear violation of the expectation\nthat a class' name will indicate what it is and/or does.
\npublic class FruitException // Noncompliant - this has nothing to do with Exception\n{\n private Fruit expected;\n private string unusualCharacteristics;\n private bool appropriateForCommercialExploitation;\n // ...\n}\n\npublic class CarException // Noncompliant - does not derive from any Exception-based class\n{\n public CarException(string message, Exception inner)\n {\n // ...\n }\n}\n\n\npublic class FruitSport // Compliant - class name does not end with 'Exception'\n{\n private Fruit expected;\n private string unusualCharacteristics;\n private bool appropriateForCommercialExploitation;\n // ...\n}\n\npublic class CarException: Exception // Compliant - correctly extends System.Exception\n{\n public CarException(string message, Exception inner): base(message, inner)\n {\n // ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2166.json",
"content": "{\n \"title\": \"Classes named like \\\"Exception\\\" should extend \\\"Exception\\\" or a subclass\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\",\n \"error-handling\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2166\",\n \"sqKey\": \"S2166\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2178.html",
"content": "Short-circuit evaluation is an evaluation strategy for
C# provides logical operators that implement short-circuit evaluation: && and ||, as well as non-short-circuit\nversions: & and |. Unlike short-circuit operators, non-short-circuit ones evaluate both operands and afterwards perform\nthe logical operation.
For example false && FunctionCall() always results in false, even when FunctionCall invocation would\nraise an exception. Instead, false & FunctionCall() also evaluates FunctionCall(), and results in an exception if\nFunctionCall() invocation raises an exception.
Similarly, true || FunctionCall() always results in true, no matter what the return value of FunctionCall()\nwould be.
The use of non-short-circuit logic in a boolean context is likely a mistake - one that could cause serious program errors as conditions are\nevaluated under the wrong circumstances.
\n\nif (GetTrue() | GetFalse()) // Noncompliant: both sides evaluated\n{\n}\n\n\nif (GetTrue() || GetFalse()) // Compliant: short-circuit logic used\n{\n}\n\nThe
\nvar number = 14; // ...01110 (14)\nvar left = number << 1; // ...11100 (28)\nvar right = number >> 1; // ...00111 (7)\n\n
Therefore, shifting an integral number by 0 is equivalent to doing nothing, since the bits do not move any positions to the left or the right.
\nOn the other hand, shifting an integral number by a value greater than their count of bits minus one (n_bits-1) is equivalent to\nshifting by the value modulo the bit count of the number (value % n_bits).
In the case of int and uint, which take 32 bits in the memory, the shift count is given by the five low-order bits of the\nsecond operand, which can represent numbers from 0 to 31. This means that numbers having the same five low-order bits are treated the same by the\nshift operators.
\nvar one = 0b0_00001;\nvar thirtyThree = 0b1_00001; // Same five low-order bits, 33 % 32 = 1\n\nvar shifted1 = 42 << one; // Results in 84\nvar shifted2 = 42 << thirtyThree; // Results in 84\n\n
Note that integral number with a less than 32-bit quantity (e.g. short, ushort) are implicitly converted to\nint before the shifting operation and so the rule for int/uint applies.
If the first operand is a long or ulong (64-bit quantity), the shift count is given by the six low-order bits of the\nsecond operand. That is, the actual shift count is 0 to 63 bits.
This rule doesn’t raise an issue when the shift by zero is obviously for cosmetic reasons:
\n\nbytes[loc+0] = (byte)(value >> 8);\nbytes[loc+1] = (byte)(value >> 0);\n\n
\nshort s = 1;\nshort shortShift1 = (short)(s << 0); // Noncompliant: the value does not change\nshort shortShift2 = (short)(s << 33); // Noncompliant: this is equivalent to shifting by 1\n\nint i = 1;\nint intShift = i << 33; // Noncompliant: this is equivalent to shifting by 1\n\nlong lg = 1;\nlong longShift1 = lg << 0; // Noncompliant: the value does not change\nlong longShift2 = lg << 65; // Noncompliant: this is equivalent to shifting by 1\n\n
\nshort s = 1;\nshort shortShift1 = s;\nshort shortShift2 = (short)(s << 1);\n\nint i = 1;\nvar intShift = i << 1;\n\nlong lg = 1;\nvar longShift1 = lg;\nvar longShift2 = lg << 1;\n\n
When division is performed on ints, the result will always be an int. You can assign that result to a\ndouble, float or decimal with automatic type conversion, but having started as an int, the result\nwill likely not be what you expect. If the result of int division is assigned to a floating-point variable, precision will have been lost\nbefore the assignment. Instead, at least one operand should be cast or promoted to the final type before the operation takes place.
\nstatic void Main()\n{\n decimal dec = 3/2; // Noncompliant\n Method(3/2); // Noncompliant\n}\n\nstatic void Method(float f) { }\n\n\nstatic void Main()\n{\n decimal dec = (decimal)3/2;\n Method(3.0F/2);\n}\n\nstatic void Method(float f) { }\n\nTo ensure proper testing, it is important to include test cases in a test class. If a test class does not have any test cases, it can give the\nwrong impression that the class being tested has been thoroughly tested, when in reality, it has not.
\nThis rule will raise an issue when any of these conditions are met:
\nNUnit, a class is marked with TestFixture but does not contain any method marked with Test,\n TestCase, TestCaseSource, or Theory.MSTest, a class is marked with TestClass but does not contain any method marked with TestMethod or\n DataTestMethod.It does not apply to xUnit since xUnit does not require a test\nclass attribute.
There are scenarios where not having any test cases within a test class is perfectly acceptable and not seen as a problem.
\nTo facilitate the creation of common test cases, test logic, or test infrastructure, it is advisable to use a base class.
\nAdditionally, in both NUnit and MSTest, abstract classes that are annotated with their respective attributes\n(TestFixture in NUnit and TestClass in MSTest) are automatically ignored.
Therefore, there is no need to raise an issue in this particular scenario.
\nMore information here:
\nTestFixture documentation in\n NUnitTypeValidator class in MSTest (GitHub)A base class containing one or more test cases to provide generic test cases is also considered a compliant scenario.
\nAssemblyInitialize or AssemblyCleanup methodsThis particular exception scenario only applies to the MSTest test framework.
\nThe AssemblyInitialize and AssemblyCleanup attributes are used to annotate methods that are executed only once at the\nbeginning and at the end of a test run. These attributes can only be applied once per assembly.
It is logical to have a dedicated class for these methods, and this scenario is also considered compliant.
\nFurthermore, it is important to note that the test engine will execute a method annotated with either the AssemblyInitialize or\nAssemblyCleanup attribute only if that method is part of a class annotated with the TestClass attribute.
More information here:
\n\nTo fix this issue in MSTest, it is important that all test classes annotated with the [TestClass] attribute contain at\nleast one test case.
To achieve this, at least one method needs to be annotated with one of the following method attributes:
\nTestMethodDataTestMethod\n[TestClass]\npublic class SomeOtherClassTest { } // Noncompliant: no test\n\n\n[TestClass]\npublic class SomeOtherClassTest\n{\n [TestMethod]\n public void SomeMethodShouldReturnTrue() { }\n}\n\nTo fix this issue in NUnit, it is important that all test classes annotated with the [TestFixture] attribute contain at\nleast one test case.
To achieve this, at least one method needs to be annotated with one of the following method attributes:
\nTestTestCaseTestCaseSourceTheory\n[TestFixture]\npublic class SomeClassTest { } // Noncompliant: no test\n\n\n[TestFixture]\npublic class SomeClassTest\n{\n [Test]\n public void SomeMethodShouldReturnTrue() { }\n}\n\nNUnit documentation\n MSTest documentationxUnit to other frameworks - AttributesHaving an infinite loop or recursion will lead to a program failure or a program never finishing the execution.
\n\npublic int Sum()\n{\n var i = 0;\n var result = 0;\n while (true) // Noncompliant: the program will never stop\n {\n result += i;\n i++;\n }\n return result;\n}\n\nThis can happen in multiple scenarios.
\nwhile and for loops with no break or return statements that have exit conditions which are\nalways false will be indefinitely executed.
goto statement with nothing that stops it from being executed over and over again will prevent the program from the completion.
When a recursive method call chain lacks an exit condition, the
\nint Pow(int num, int exponent)\n{\n return num * Pow(num, exponent - 1); // Noncompliant: no condition under which Pow isn't re-called\n}\n\nIn this example, Pow will keep calling Pow with exponent - 1 forever, until the program crashes with a\nStackOverflowException.
Recursion provides some benefits.
\nHowever, it has disadvantages as well.
\nThe program’s logic should incorporate a mechanism to break out of the control flow loop. Here are some examples.
\nfalse\npublic int Sum()\n{\n var i = 0;\n var result = 0;\n while (true) // Noncompliant: the program will never stop\n {\n result += i;\n i++;\n }\n return result;\n}\n\n\npublic int Sum()\n{\n var i = 0;\n var result = 0;\n while (result < 1000)\n {\n result += i;\n i++;\n }\n return result;\n}\n\ngoto statements. Instead, you can use a loop statement or explicit\n recursion.\npublic int Sum()\n{\n var result = 0;\n var i = 0;\niteration:\n // Noncompliant: program never ends\n result += i;\n i++;\n goto iteration;\n return result;\n}\n\n\npublic int Sum()\n{\n var i = 0;\n var result = 0;\n while (result < 1000)\n {\n result += i;\n i++;\n }\n return result;\n}\n\n\nint Pow(int num, int exponent)\n{\n return num * Pow(num, exponent - 1); // Noncompliant: no condition under which Pow isn't re-called\n}\n\n\nint Pow(int num, int exponent)\n{\n if (exponent > 1) // recursion is now conditional and stoppable\n {\n num = num * Pow(num, exponent - 1);\n }\n return num;\n}\n\nWhen the modulus of a negative number is calculated, the result will either be negative or zero. Thus, comparing the modulus of a variable for\nequality with a positive number (or a negative one) could result in unexpected results.
\n\npublic bool IsOdd(int x)\n{\n return x % 2 == 1; // Noncompliant; if x is an odd negative, x % 2 == -1\n}\n\n\npublic bool IsOdd(int x)\n{\n return x % 2 != 0;\n}\n\nor
\n\npublic bool IsOdd(uint x)\n{\n return x % 2 == 1;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2197.json",
"content": "{\n \"title\": \"Modulus results should not be checked for direct equality\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2197\",\n \"sqKey\": \"S2197\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2198.html",
"content": "Certain mathematical comparisons\nwill always return the same value, and should not be performed.
\nSpecifically, the following comparisons will return either always true or always false depending on the kind of\ncomparison:
char with a numeric constant that is outside of the range of charfloat with a numeric constant that is outside of the range of floatlong with a numeric constant that is outside of the range of longulong with a numeric constant that is outside of the range of ulong\nfloat f = 42.0f;\nif (f <= double.MaxValue) { } // Noncompliant: always true\nif (f > double.MaxValue) { } // Noncompliant: always false\n\nWhen you do not use the return value of a method with no side effects, it indicates that something is wrong. Either this method is unnecessary, or\nthe source code does not behave as expected and could lead to code defects. For example, there are methods, such as
This rule raises an issue when the results of the following methods are ignored:
\nPure methodsSpecial cases:
\nstring.Intern has a side effect, ignoring\n its return value is still suspicious as it is the only reference ensured to point to the intern pool.\ndata.All(x =>\n{\n x.Property = \"foo\";\n return true;\n});\n\nSuch code should be rewritten as a loop because Enumerable.All<TSource> method should be used to\ndetermine if all elements satisfy a condition and not to change their state.
This rule doesn’t report issues on invocations with out or ref arguments.
\ndata.Where(x => x > 5).Select(x => x * x); // Noncompliant\n\"this string\".Equals(\"other string\"); // Noncompliant\n\ndata.All(x => // Noncompliant\n{\n x.Property = \"foo\";\n return true;\n});\n\n\nvar res = data.Where(x => x > 5).Select(x => x * x);\nvar isEqual = \"this string\".Equals(\"other string\");\n\nforeach (var x in data)\n{\n x.Property = \"foo\";\n}\n\nPureAttribute\n Classout\n parameter modifierref keywordString.Intern(String) MethodTo check the type of an object there are several options:
\nexpr is SomeType or expr.GetType() == typeof(SomeType) if the type is known at compile time,typeInstance.IsInstanceOfType(expr) if the type is calculated during runtime.If runtime calculated Types need to be compared:
typeInstance1.IsAssignableFrom(typeInstance2).Depending on whether the type is returned by a GetType() or typeof() call, the IsAssignableFrom() and\nIsInstanceOfType() might be simplified. Similarly, if the type is sealed, the type comparison with == can be\nconverted to an is call. Simplifying the calls also make null checking unnecessary because both is and\nIsInstanceOfType performs it already.
Finally, utilizing the most concise language constructs for type checking makes the code more readable, so
\nexpr as T != null checks should be simplified to expr is T, andexpr is T should be converted to expr != null, when expr is of type T.\nclass Fruit { }\nsealed class Apple : Fruit { }\n\nclass Program\n{\n static void Main()\n {\n var apple = new Apple();\n var b = apple != null && apple.GetType() == typeof (Apple); // Noncompliant\n b = typeof(Apple).IsInstanceOfType(apple); // Noncompliant\n if (apple != null)\n {\n b = typeof(Apple).IsAssignableFrom(apple.GetType()); // Noncompliant\n }\n var appleType = typeof (Apple);\n if (apple != null)\n {\n b = appleType.IsAssignableFrom(apple.GetType()); // Noncompliant\n }\n\n Fruit f = apple;\n if (f as Apple != null) // Noncompliant\n {\n }\n if (apple is Apple) // Noncompliant\n {\n }\n }\n}\n\n\nclass Fruit { }\nsealed class Apple : Fruit { }\n\nclass Program\n{\n static void Main()\n {\n var apple = new Apple();\n var b = apple is Apple;\n b = apple is Apple;\n b = apple is Apple;\n var appleType = typeof(Apple);\n b = appleType.IsInstanceOfType(apple);\n\n Fruit f = apple;\n if (f is Apple)\n {\n }\n if (apple != null)\n {\n }\n }\n}\n\nCalling GetType on an object of Nullable<T> type returns the underlying generic type parameter T, thus\na comparison with typeof(Nullable<T>) can’t be simplified to use the is operator, which doesn’t make difference\nbetween T and T?.
\nint? i = 42;\nbool condition = i.GetType() == typeof(int?); // false;\ncondition = i is int?; // true\n\n
No issue is reported on the following expressions:
\nexpr is T when either operand of the is operator is a value type. In that case CS0183 or CS0184 reportsexpr is object, as this is a common and efficient pattern to do null checksCatching System.Exception seems like an efficient way to handle multiple possible exceptions. Unfortunately, it traps all exception\ntypes, including the ones that were not intended to be caught. To prevent any misunderstandings, exception filters should be used. Alternatively, each\nexception type should be in a separate catch block.
\ntry\n{\n // do something that might throw a FileNotFoundException or IOException\n}\ncatch (Exception e) // Noncompliant\n{\n // log exception ...\n}\n\n\ntry\n{\n // do something\n}\ncatch (Exception e) when (e is FileNotFoundException or IOException)\n{\n // do something\n}\n\nThe final option is to catch System.Exception and throw it in the last statement in the catch block. This is\nthe least-preferred option, as it is an old-style code, which also suffers from performance penalties compared to exception filters.
\ntry\n{\n // do something\n}\ncatch (Exception e)\n{\n if (e is FileNotFoundException or IOException)\n {\n // do something\n }\n else\n {\n throw;\n }\n}\n\nTo prevent potential deadlocks in an application, it is crucial to release any locks that are\nacquired within a method along all possible execution paths.
\nFailing to release locks properly can lead to potential deadlocks, where the lock might not be released, causing issues in the application.
\nThis rule specifically focuses on tracking the following types from the System.Threading namespace:
MonitorMutexReaderWriterLockReaderWriterLockSlimSpinLock An issue is reported when a lock is acquired within a method but not released on all paths.
\nIf the lock is never released within the method, no issue is raised, assuming that the callers will handle the release.
\nTo make sure that a lock is always released correctly, you can follow one of these two methods:
\nlock statement with your\n lock object.try-finally statement and put the release of your lock object within the finally block.\nclass MyClass\n{\n private object obj = new object();\n\n public void DoSomethingWithMonitor()\n {\n Monitor.Enter(obj); // Noncompliant: not all paths release the lock\n if (IsInitialized())\n {\n // ...\n Monitor.Exit(obj);\n }\n }\n}\n\n\nclass MyClass\n{\n private ReaderWriterLockSlim lockObj = new ReaderWriterLockSlim();\n\n public void DoSomethingWithReaderWriteLockSlim()\n {\n lockObj.EnterReadLock(); // Noncompliant: not all paths release the lock\n if (IsInitialized())\n {\n // ...\n lockObj.ExitReadLock();\n }\n }\n}\n\n\nclass MyClass\n{\n private object obj = new object();\n\n public void DoSomethingWithMonitor()\n {\n lock(obj) // Compliant: the lock will be released at the end of the lock block\n {\n if (IsInitialized())\n {\n // ...\n }\n }\n }\n}\n\n\nclass MyClass\n{\n private ReaderWriterLockSlim lockObj = new ReaderWriterLockSlim();\n\n public void DoSomethingWithReaderWriteLockSlim()\n {\n lockObj.EnterReadLock(); // Compliant: the lock will be released in the finally block\n try\n {\n if (IsInitialized())\n {\n // ...\n }\n }\n finally\n {\n lockObj.ExitReadLock();\n }\n }\n}\n\nlock statementtry-finally statementUnlike instance fields, which can only be accessed by code having a hold on the instance, static fields can be accessed by any code\nhaving visibility of the field and its type.
\npublic class Math\n{\n public static double Pi = 3.14; // Noncompliant\n}\n\n// Somewhere else, where Math and Math.Pi are visible\nvar pi = Math.Pi; // Reading the value\nMath.Pi = 3.1416; // Mutating the value\n\nAnother typical scenario of the use of a non-private mutable static field is the following:
\npublic class Shape\n{\n public static Shape Empty = new EmptyShape(); // Noncompliant\n\n private class EmptyShape : Shape\n {\n }\n}\n\nNon-private static fields that are neither const nor readonly, like the ones in the examples above, can lead\nto errors and unpredictable behavior.
This can happen because:
\n\nclass Counters\n{\n public static int ErrorCounter = 0;\n}\n\nclass Program\n{\n public static void Thread1()\n {\n // ...\n Counters.ErrorCounter = 0; // Error counter reset\n // ...\n }\n\n public static void Thread2()\n {\n // ...\n if (Counters.ErrorCounter > 0)\n {\n Trace.TraceError($\"There are {Counters.ErrorCounter} errors\"); // It may print \"There are 0 errors\"\n }\n // ...\n }\n}\nlock or equivalent mechanisms. Improper\n synchronization may lead to unexpected results.\n \nclass Counters\n{\n public static volatile int ErrorCounter;\n}\n\nclass Program\n{\n public static void ImproperSynchronization()\n {\n Counters.ErrorCounter = 0;\n Parallel.ForEach(Enumerable.Range(0, 1000), _ => Counters.ErrorCounter++); // Volatile is not enough\n Console.WriteLine(Counters.ErrorCounter); // May print less than 1000\n }\n\n public static void ProperSynchronization()\n {\n Counters.ErrorCounter = 0;\n Parallel.ForEach(Enumerable.Range(0, 1000), _ => Interlocked.Increment(ref Counters.ErrorCounter));\n Console.WriteLine(Counters.ErrorCounter); // Always prints 1000\n }\n}\nPublicly visible static fields should only be used to store shared data that does not change. To enforce this intent, these fields\nshould be marked readonly or converted to const.
\npublic class Math\n{\n public const double Pi = 3.14;\n}\n\n\npublic class Shape\n{\n public static readonly Shape Empty = new EmptyShape();\n\n private class EmptyShape : Shape\n {\n }\n}\n\nCalling ToString() on an object should always return a\nstring. Thus, null, as it breaks the method’s implicit contract, and as a result the consumer’s\nexpectations.
\npublic override string ToString ()\n{\n if (this.collection.Count == 0)\n {\n return null; // Noncompliant\n }\n else\n {\n // ...\n }\n}\n\nA better alternative is to use the String.Empty built-in field.
\n\npublic override string ToString ()\n{\n if (this.collection.Count == 0)\n {\n return string.Empty;\n }\n else\n {\n // ...\n }\n}\n\nCalling a method with argument variables whose names match the method parameter names but in a different order can cause confusion. It could\nindicate a mistake in the arguments' order, leading to unexpected results.
\n\npublic double Divide(int divisor, int dividend)\n{\n return divisor / dividend;\n}\n\npublic void DoTheThing()\n{\n int divisor = 15;\n int dividend = 5;\n\n double result = Divide(dividend, divisor); // Noncompliant: arguments' order doesn't match their respective parameter names\n // ...\n}\n\nHowever, matching the method parameters' order contributes to clearer and more readable code:
\n\npublic double Divide(int divisor, int dividend)\n{\n return divisor / dividend;\n}\n\npublic void DoTheThing()\n{\n int divisor = 15;\n int dividend = 5;\n\n double result = Divide(divisor, dividend); // Compliant\n // ...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2234.json",
"content": "{\n \"title\": \"Arguments should be passed in the same order as the method parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2234\",\n \"sqKey\": \"S2234\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2245.html",
"content": "PRNGs are algorithms that produce sequences of numbers that only approximate true randomness. While they are suitable for applications like\nsimulations or modeling, they are not appropriate for security-sensitive contexts because their outputs can be predictable if the internal state is\nknown.
\nIn contrast, cryptographically secure pseudorandom number generators (CSPRNGs) are designed to be secure against prediction attacks. CSPRNGs use\ncryptographic algorithms to ensure that the generated sequences are not only random but also unpredictable, even if part of the sequence or the\ninternal state becomes known. This unpredictability is crucial for security-related tasks such as generating encryption keys, tokens, or any other\nvalues that must remain confidential and resistant to guessing attacks.
\nFor example, the use of non-cryptographic PRNGs has led to vulnerabilities such as:
\nWhen software generates predictable values in a context requiring unpredictability, it may be possible for an attacker to guess the next value that\nwill be generated, and use this guess to impersonate another user or access sensitive information. Therefore, it is critical to use CSPRNGs in any\nsecurity-sensitive application to ensure the robustness and security of the system.
\nAs the System.Random class relies on a non-cryptographic pseudorandom number generator, it should not be used for security-critical\napplications or for protecting sensitive data. In such context, the System.Cryptography.RandomNumberGenerator class which relies on a\nCSPRNG should be used in place.
There is a risk if you answered yes to any of those questions.
\n\nvar random = new Random(); // Sensitive use of Random\nbyte[] data = new byte[16];\nrandom.NextBytes(data);\nreturn BitConverter.ToString(data); // Check if this value is used for hashing or encryption\n\n
\nusing System.Security.Cryptography;\n...\nvar randomGenerator = RandomNumberGenerator.Create();\nbyte[] data = new byte[16];\nrandomGenerator.GetBytes(data);\nreturn BitConverter.ToString(data);\n\n
A for loop with a counter that moves in the wrong direction, away from the stop condition, is not an infinite loop. Because of
If your
\nfor (int i = 0; i < maximum; i--) // Noncompliant: runs until it underflows to int.MaxValue\n{\n // ...\n}\n\nfor (int i = maximum; i >= maximum; i++) // Noncompliant: runs until it overflows to int.MinValue\n{\n // ...\n}\n\n\nfor (int i = 0; i < maximum; i++) // Compliant: Increment towards the maximum value\n{\n}\n\nfor (int i = maximum; i >= 0; i--) // Compliant: Decrement towards the minimum value\n{\n // ...\n}\n\nA for loop\nis a fundamental programming construct used to execute a block of code repeatedly. However, if the loop’s condition is false before the first\niteration, the loop will never execute.
\nfor (int i = 0; i < 0; i++) // Noncompliant: the condition is always false, the loop will never execute\n{\n // ...\n}\n\nRewrite the loop to ensure the condition evaluates to true at least once.
\nfor (int i = 0; i < 10; i++) // Compliant: the condition is true at least once, the loop will execute\n{\n // ...\n}\n\nThis bug has the potential to cause unexpected outcomes as the loop might contain critical code that needs to be executed.
\nfor\n statementThe use of a non-standard algorithm is dangerous because a determined attacker may be able to break the algorithm and compromise whatever data has\nbeen protected. Standard algorithms like AES, RSA, SHA, … should be used instead.
This rule tracks custom implementation of these types from System.Security.Cryptography namespace:
AsymmetricAlgorithmAsymmetricKeyExchangeDeformatterAsymmetricKeyExchangeFormatterAsymmetricSignatureDeformatterAsymmetricSignatureFormatterDeriveBytesHashAlgorithmICryptoTransformSymmetricAlgorithm\npublic class CustomHash : HashAlgorithm // Noncompliant\n{\n private byte[] result;\n\n public override void Initialize() => result = null;\n protected override byte[] HashFinal() => result;\n\n protected override void HashCore(byte[] array, int ibStart, int cbSize) =>\n result ??= array.Take(8).ToArray();\n}\n\n\nSHA256 mySHA256 = SHA256.Create()\n\n
Accessing a null value will always throw a
Such termination might expose sensitive information that a malicious third party could exploit to, for instance, bypass security measures.
\nIn the following cases, the rule does not raise:
\nCalls to extension methods can still operate on null values.
\nusing System;\nusing System.Text.RegularExpressions;\n\npublic static class Program\n{\n public static string RemoveVowels(this string value)\n {\n if (value == null)\n {\n return null;\n }\n return Regex.Replace(value, \"[aeoui]*\",\"\", RegexOptions.IgnoreCase);\n }\n\n public static void Main()\n {\n Console.WriteLine(((string?)null).RemoveVowels()); // Compliant: 'RemoveVowels' is an extension method\n }\n}\n\nUnreachable code is not executed, thus null values will never be accessed.
\npublic void Method()\n{\n object o = null;\n if (false)\n {\n o.ToString(); // Compliant: code is unreachable\n }\n}\n\nNullable analysis attributes enable\nthe developer to annotate methods with information about the null-state of its arguments. Thus, potential null values validated by one of\nthe following attributes will not raise:
It is important to note those attributes are only available starting .NET Core 3. As a workaround, it is possible to define those attributes\nmanually in a custom class:
\n\nusing System;\n\npublic sealed class NotNullAttribute : Attribute { } // The alternative name 'ValidatedNotNullAttribute' is also supported\n\npublic static class Guard\n{\n public static void NotNull<T>([NotNull] T value, string name) where T : class\n {\n if (value == null)\n {\n throw new ArgumentNullException(name);\n }\n }\n}\n\npublic static class Utils\n{\n public static string Normalize(string value)\n {\n Guard.NotNull(value, nameof(value)); // Will throw if value is null\n return value.ToUpper(); // Compliant: value is known to be not null here.\n }\n}\n\nA value validated with Debug.Assert to not be\nnull is safe to access.
\nusing System.Diagnostics;\n\npublic void Method(object myObject)\n{\n Debug.Assert(myObject != null);\n myObject.ToString(); // Compliant: 'myObject' is known to be not null here.\n}\n\nLike with null-analysis-attribute, potential null values validated by one of the following IDE-specific attributes will not raise
\nusing System;\nusing JetBrains.Annotations;\n\npublic class Utils\n{\n [TerminatesProgram]\n public void TerminateProgram()\n {\n Environment.FailFast(\"A catastrophic failure has occurred.\")\n }\n\n public void TerminatesProgramIsRespected()\n {\n object myObject = null;\n TerminateProgram();\n myObject.ToString(); // Compliant: unreachable\n }\n}\nExpression marked with the null forgiving\noperator
\n\npublic void Method()\n{\n object o = null;\n o!.ToString(); // Compliant: the null forgiving operator suppresses the nullable warning\n}\n\nTo fix the issue, the access of the null value needs to be prevented by either:
nullThe variable myObject is equal to null, meaning it has no value:
\npublic void Method()\n{\n object myObject = null;\n Console.WriteLine(o.ToString()); // Noncompliant: 'myObject' is always null\n}\n\nThe parameter input might be null as suggested by the if condition:
\npublic void Method(object input)\n{\n if (input is null)\n {\n // ...\n }\n Console.WriteLine(input.ToString()); // Noncompliant: the if condition suggests 'input' might be null\n}\n\nEnsuring the variable myObject has a value resolves the issue:
\npublic void Method()\n{\n var myObject = new object();\n Console.WriteLine(myObject.ToString()); // Compliant: 'myObject' is not null\n}\n\nPreventing the non-compliant code to be executed by returning early:
\n\npublic void Method(object input)\n{\n if (input is null)\n {\n return;\n }\n Console.WriteLine(input.ToString()); // Compliant: if 'input' is null, this is unreachable\n}\n\nComposite format strings in C# are evaluated at runtime, which means they are not verified by the compiler. Introducing an ill-formed format item,\nor indexing mismatch can lead to unexpected behaviors or runtime errors. The purpose of this rule is to perform static validation on composite format\nstrings used in various string formatting functions to ensure their correct usage. This rule validates the proper behavior of composite formats when\ninvoking the following methods:
\nString.FormatStringBuilder.AppendFormatConsole.WriteConsole.WriteLineTextWriter.WriteTextWriter.WriteLineDebug.WriteLine(String, Object[])Trace.TraceError(String, Object[])Trace.TraceInformation(String, Object[])Trace.TraceWarning(String, Object[])TraceSource.TraceInformation(String, Object[])\ns = string.Format(\"[0}\", arg0); // Noncompliant: square bracket '[' instead of curly bracket '{'\ns = string.Format(\"{{0}\", arg0); // Noncompliant: double starting curly brackets '{{'\ns = string.Format(\"{0}}\", arg0); // Noncompliant: double ending curly brackets '}}'\ns = string.Format(\"{-1}\", arg0); // Noncompliant: invalid index for the format item, must be >= 0\ns = string.Format(\"{0} {1}\", arg0); // Noncompliant: two format items in the string but only one argument provided\n\n\ns = string.Format(\"{0}\", 42); // Compliant\ns = string.Format(\"{0,10}\", 42); // Compliant\ns = string.Format(\"{0,-10}\", 42); // Compliant\ns = string.Format(\"{0:0000}\", 42); // Compliant\ns = string.Format(\"{2}-{0}-{1}\", 1, 2, 3); // Compliant\ns = string.Format(\"no format\"); // Compliant\n\nThe rule does not perform any checks on the format specifier, if present (defined after the :). Moreover, no issues are raised in the\nfollowing cases:
const.\n \nvar pattern = \"{0} {1} {2}\";\nvar res = string.Format(pattern, 1, 2); // Compliant, non-constant string are not recognized\n\nvar array = new int[] {};\nvar res = string.Format(\"{0} {1}\", array); // Compliant the rule does not check the size of the array\nField-like events are events that do\nnot have explicit add and remove accessors.
\npublic event EventHandler MyEvent; // No add and remove accessors\n\n
The compiler generates a private delegate field to back the event, as well as generating the implicit add\nand remove accessors.
When a virtual field-like event is overridden by another field-like event, the behavior of the C# compiler\nis to generate a new private delegate field in the derived class, separate from the parent’s field. This results in multiple\nand separate events being created, which is rarely what’s actually intended.
\nabstract class Car\n{\n public virtual event EventHandler OnRefuel; // Noncompliant\n\n public void Refuel()\n {\n // This OnRefuel will always be null\n if (OnRefuel != null)\n {\n OnRefuel(this, EventArgs.Empty);\n }\n }\n}\n\nclass R2 : Car\n{\n public override event EventHandler OnRefuel;\n}\n\nclass Program\n{\n static void Main(string[] args)\n {\n var r2 = new R2();\n r2.OnRefuel += (o, a) =>\n {\n Console.WriteLine(\"This event will be called\");\n };\n r2.Refuel();\n }\n}\n\nTo prevent this, remove the virtual designation from the parent class event.
\nabstract class Car\n{\n public event EventHandler OnRefuel; // Compliant\n\n public void Refuel()\n {\n if (OnRefuel != null)\n {\n OnRefuel(this, EventArgs.Empty);\n }\n }\n}\n\nclass R2 : Car\n{\n\n}\n\nclass Program\n{\n static void Main(string[] args)\n {\n var r2 = new R2();\n r2.OnRefuel += (o, a) =>\n {\n Console.WriteLine(\"This event will be called\");\n };\n r2.Refuel();\n }\n}\n\nEnumerable.Sum() always executes addition in a\nchecked context, so an OverflowException will be\nthrown if the value exceeds MaxValue, even if an unchecked context was specified. Therefore, using this method inside an\nunchecked context will only make the code more confusing, since the behavior will still be checked.
This rule raises an issue when an unchecked context is specified for a Sum on integer types.
When the Sum call is inside a try-catch block,\nno issues are reported, since the exception is properly handled.
\nvoid Add(List<int> list)\n{\n unchecked\n {\n try\n {\n int total = list.Sum();\n }\n catch (System.OverflowException e)\n {\n // Exception handling\n }\n }\n}\n\nRemove the unchecked operator/statement, and optionally add some exception handling for the OverflowException.
\nvoid Add(List<int> list)\n{\n int total1 = unchecked(list.Sum()); // Noncompliant\n\n unchecked\n {\n int total2 = list.Sum(); // Noncompliant\n }\n}\n\n\nvoid Add(List<int> list)\n{\n int total1 = list.Sum();\n\n try\n {\n int total2 = list.Sum();\n }\n catch (System.OverflowException e)\n {\n // Exception handling\n }\n}\n\nEnumerable.Sum MethodEnumerable.Sum implementationchecked and\n unchecked statementschecked and unchecked operatorsOverflowException ClassTrivial properties, which include no logic but setting and getting a backing field should be converted to auto-implemented properties, yielding\ncleaner and more readable code.
\n\npublic class Car\n{\n private string _make;\n public string Make // Noncompliant\n {\n get { return _make; }\n set { _make = value; }\n }\n}\n\n\npublic class Car\n{\n public string Make { get; set; }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2292.json",
"content": "{\n \"title\": \"Trivial properties should be auto-implemented\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2292\",\n \"sqKey\": \"S2292\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2302.html",
"content": "Because parameter names could be changed during refactoring, they should not be spelled out literally in strings. Instead, use\nnameof(), and the string that’s output will always be correct.
This rule raises an issue when a string in the throw statement contains the name of one of the method parameters.
\nvoid DoSomething(int someParameter, string anotherParam)\n{\n if (someParameter < 0)\n {\n throw new ArgumentException(\"Bad argument\", \"someParameter\"); // Noncompliant\n }\n if (anotherParam == null)\n {\n throw new Exception(\"anotherParam should not be null\"); // Noncompliant\n }\n}\n\n\nvoid DoSomething(int someParameter)\n{\n if (someParameter < 0)\n {\n throw new ArgumentException(\"Bad argument\", nameof(someParameter));\n }\n if (anotherParam == null)\n {\n throw new Exception($\"{nameof(anotherParam)} should not be null\");\n }\n}\n\nthrow statement string, the rule will raise an issue only if the\n parameter name is at least 5 characters long. This is to avoid false positives.Since C# 5.0, async and await are
\nint await = 42; // Noncompliant, but compiles\nint async = 42; // Noncompliant, but compiles\n\n
Keywords, on the other hand, are always reserved and\ntherefore are not valid variable names.
\n\nint abstract = 42; // Error CS1585: Member modifier 'abstract' must precede the member type and name\nint foreach = 42; // Error CS1519: Invalid token 'foreach' in class, struct, or interface member declaration\n\n
To avoid any confusion, it is best to not use async and await as identifiers.
\nint someVariableName = 42;\nint someOtherVariableName = 42;\n\n
Methods and properties that don’t access instance data should be marked as static for the following reasons:
Methods with the following names are excluded because they can’t be made static:
Event handler methods part of a Windows Forms or static.
\npublic class Utilities\n{\n public int MagicNum // Noncompliant - only returns a constant value\n {\n get\n {\n return 42;\n }\n }\n\n private static string magicWord = \"please\";\n public string MagicWord // Noncompliant - only accesses a static field\n {\n get\n {\n return magicWord;\n }\n set\n {\n magicWord = value;\n }\n }\n\n public int Sum(int a, int b) // Noncompliant - doesn't access instance data, only the method parameters\n {\n return a + b;\n }\n}\n\n\npublic class Utilities\n{\n public static int MagicNum\n {\n get\n {\n return 42;\n }\n }\n\n private static string magicWord = \"please\";\n public static string MagicWord\n {\n get\n {\n return magicWord;\n }\n set\n {\n magicWord = value;\n }\n }\n\n public static int Sum(int a, int b)\n {\n return a + b;\n }\n}\n\nType parameters that aren’t used are dead code, which can only distract and possibly confuse developers during maintenance. Therefore, unused type\nparameters should be removed.
\n\npublic class MoreMath<T> // Noncompliant; <T> is ignored\n{\n public int Add<T>(int a, int b) // Noncompliant; <T> is ignored\n {\n return a + b;\n }\n}\n\n\npublic class MoreMath\n{\n public int Add (int a, int b)\n {\n return a + b;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2326.json",
"content": "{\n \"title\": \"Unused type parameters should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2326\",\n \"sqKey\": \"S2326\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2327.html",
"content": "When multiple, adjacent try statements have duplicate catch and/or finally blocks, they should be merged to\nconsolidate the catch/finally logic for cleaner, more readable code. Note that this applies even when there is intervening code outside\nany try block.
\ntry\n{\n DoTheFirstThing(a, b);\n}\ncatch (InvalidOperationException ex)\n{\n HandleException(ex);\n}\n\nDoSomeOtherStuff();\n\ntry // Noncompliant; catch is identical to previous\n{\n DoTheSecondThing();\n}\ncatch (InvalidOperationException ex)\n{\n HandleException(ex);\n}\n\ntry // Compliant; catch handles exception differently\n{\n DoTheThirdThing(a);\n}\ncatch (InvalidOperationException ex)\n{\n LogAndDie(ex);\n}\n\n\ntry\n{\n DoTheFirstThing(a, b);\n DoSomeOtherStuff();\n DoTheSecondThing();\n}\ncatch (InvalidOperationException ex)\n{\n HandleException(ex);\n}\n\ntry // Compliant; catch handles exception differently\n{\n DoTheThirdThing(a);\n}\ncatch (InvalidOperationException ex)\n{\n LogAndDie(ex);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2327.json",
"content": "{\n \"title\": \"\\\"try\\\" statements with identical \\\"catch\\\" and\\/or \\\"finally\\\" blocks should be merged\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"DISTINCT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2327\",\n \"sqKey\": \"S2327\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2328.html",
"content": "GetHashCode is used to file an object in a Dictionary or Hashtable. If GetHashCode uses\nnon-readonly fields and those fields change after the object is stored, the object immediately becomes mis-filed in the\nHashtable. Any subsequent test to see if the object is in the Hashtable will return a false negative.
This rule does not raise if the type implementing GetHashCode is a value type, for example a struct or a record\nstruct, since when a value type is stored in a Dictionary or Hashtable, a copy of the value is stored, not a\nreference to the value.
\npublic class Person\n{\n public int age;\n public string name;\n\n public override int GetHashCode()\n {\n int hash = 12;\n hash += this.age.GetHashCode(); // Noncompliant\n hash += this.name.GetHashCode(); // Noncompliant\n return hash;\n }\n\n\npublic class Person\n{\n public readonly DateTime birthday;\n public string name;\n\n public override int GetHashCode()\n {\n int hash = 12;\n hash += this.birthday.GetHashCode();\n return hash;\n }\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2328.json",
"content": "{\n \"title\": \"\\\"GetHashCode\\\" should not reference mutable fields\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2328\",\n \"sqKey\": \"S2328\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2330.html",
"content": "Array covariance is the principle that if an implicit or explicit reference conversion exits from type A to B, then the\nsame conversion exists from the array type A[] to B[].
While this array conversion can be useful in readonly situations to pass instances of A[] where B[] is expected, it must\nbe used with care, since assigning an instance of B into an array of A will cause an ArrayTypeMismatchException\nto be thrown at runtime.
\nabstract class Fruit { }\nclass Apple : Fruit { }\nclass Orange : Fruit { }\n\nclass Program\n{\n static void Main(string[] args)\n {\n Fruit[] fruits = new Apple[1]; // Noncompliant - array covariance is used\n FillWithOranges(fruits);\n }\n\n // Just looking at the code doesn't reveal anything suspicious\n static void FillWithOranges(Fruit[] fruits)\n {\n for (int i = 0; i < fruits.Length; i++)\n {\n fruits[i] = new Orange(); // Will throw an ArrayTypeMismatchException\n }\n }\n}\n\n\nabstract class Fruit { }\nclass Apple : Fruit { }\nclass Orange : Fruit { }\n\nclass Program\n{\n static void Main(string[] args)\n {\n Orange[] fruits = new Orange[1]; // Compliant\n FillWithOranges(fruits);\n }\n\n static void FillWithOranges(Orange[] fruits)\n {\n for (int i = 0; i < fruits.Length; i++)\n {\n fruits[i] = new Orange();\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2330.json",
"content": "{\n \"title\": \"Array covariance should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2330\",\n \"sqKey\": \"S2330\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2333.html",
"content": "Unnecessary keywords simply clutter the code and should be removed. Specifically:
\npartial on type declarations that are completely defined in one placesealed on members of sealed classesunsafe method or block inside construct already marked with unsafe, or when there are no unsafe\n constructs in the blockchecked and unchecked blocks with no integral-type arithmetic operations\npublic partial class MyClass // Noncompliant\n{\n public virtual void Method()\n {\n }\n}\n\npublic sealed class MyOtherClass : MyClass\n{\n public sealed override void Method() // Noncompliant\n {\n }\n}\n\n\npublic class MyClass\n{\n public virtual void Method()\n {\n }\n}\n\npublic sealed class MyOtherClass : MyClass\n{\n public override void Method()\n {\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2333.json",
"content": "{\n \"title\": \"Redundant modifiers should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\",\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2333\",\n \"sqKey\": \"S2333\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2339.html",
"content": "Constant members are copied at compile time to the call sites, instead of being fetched at runtime.
\nAs an example, say you have a library with a constant Version member set to 1.0, and a client application linked to it.\nThis library is then updated and Version is set to 2.0. Unfortunately, even after the old DLL is replaced by the new one,\nVersion will still be 1.0 for the client application. In order to see 2.0, the client application would need to\nbe rebuilt against the new version of the library.
This means that you should use constants to hold values that by definition will never change, such as Zero. In practice, those cases\nare uncommon, and therefore it is generally better to avoid constant members.
This rule only reports issues on public constant fields, which can be reached from outside the defining assembly.
\n\npublic class Foo\n{\n public const double Version = 1.0; // Noncompliant\n}\n\n\npublic class Foo\n{\n public static double Version\n {\n get { return 1.0; }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2339.json",
"content": "{\n \"title\": \"Public constant members should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2339\",\n \"sqKey\": \"S2339\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2342.html",
"content": "Shared naming conventions allow teams to collaborate efficiently. This rule checks that all enum names match a provided regular\nexpression.
The default configuration is the one recommended by Microsoft:
\nWith the default regular expression for non-flags enums: ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$
\npublic enum foo // Noncompliant\n{\n FooValue = 0\n}\n\nWith the default regular expression for flags enums: ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?s$
\n[Flags]\npublic enum Option // Noncompliant\n{\n None = 0,\n Option1 = 1,\n Option2 = 2\n}\n\n\npublic enum Foo\n{\n FooValue = 0\n}\n\n\n[Flags]\npublic enum Options\n{\n None = 0,\n Option1 = 1,\n Option2 = 2\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2342.json",
"content": "{\n \"title\": \"Enumeration types should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2342\",\n \"sqKey\": \"S2342\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2344.html",
"content": "The information that an enumeration type is actually an enumeration or a set of flags should not be duplicated in its name.
\n\nenum FooFlags // Noncompliant\n{\n Foo = 1\n Bar = 2\n Baz = 4\n}\n\n\nenum Foo\n{\n Foo = 1\n Bar = 2\n Baz = 4\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2344.json",
"content": "{\n \"title\": \"Enumeration type names should not have \\\"Flags\\\" or \\\"Enum\\\" suffixes\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2344\",\n \"sqKey\": \"S2344\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2345.html",
"content": "When you annotate an Enum with the Enum members, but you should define the enumeration constants in powers of two (1, 2, 4, 8, and so on).\nAutomatic value initialization will set the first member to zero and increment the value by one for each subsequent member. As a result, you won’t be\nable to use the enum members with bitwise operators.
The default initialization of 0, 1, 2, 3, 4, … matches 0, 1, 2, 4, 8 … in the first three values, so no issue is\nreported if the first three members of the enumeration are not initialized.
Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on.
\n\nvar bananaAndStrawberry = FruitType.Banana | FruitType.Strawberry;\nConsole.WriteLine(bananaAndStrawberry.ToString()); // Will display only \"Strawberry\"\n\n[Flags]\nenum FruitType // Noncompliant\n{\n None,\n Banana,\n Orange,\n Strawberry\n}\n\n\nvar bananaAndStrawberry = FruitType.Banana | FruitType.Strawberry;\nConsole.WriteLine(bananaAndStrawberry.ToString()); // Will display \"Banana, Strawberry\"\n\n[Flags]\nenum FruitType\n{\n None = 0,\n Banana = 1,\n Orange = 2,\n Strawberry = 4\n}\n\nAn enumeration can be decorated with the FlagsAttribute to\nindicate that it can be used as a bit field: a set of flags, that can be independently set and\nreset.
\nFor example, the following definition of the day of the week:
\n\n[Flags]\nenum Days\n{\n Monday = 1, // 0b00000001\n Tuesday = 2, // 0b00000010\n Wednesday = 4, // 0b00000100\n Thursday = 8, // 0b00001000\n Friday = 16, // 0b00010000\n Saturday = 32, // 0b00100000\n Sunday = 64 // 0b01000000\n}\n\nallows to define special set of days, such as WeekDays and Weekend using the | operator:
\n[Flags]\nenum Days\n{\n // ...\n None = 0, // 0b00000000\n Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday, // 0b00011111\n Weekend = Saturday | Sunday, // 0b01100000\n All = Weekdays | Weekend // 0b01111111\n}\n\nThese can be used to write more expressive conditions, taking advantage of
\nvar someDays = Days.Wednesday | Days.Weekend; // 0b01100100\nsomeDays.HasFlag(Days.Wednesday); // someDays contains Wednesday\n\nvar mondayAndWednesday = Days.Monday | Days.Wednesday;\nsomeDays.HasFlag(mondayAndWednesday); // someDays contains Monday and Wednesday\nsomeDays.HasFlag(Days.Monday) || someDays.HasFlag(Days.Wednesday); // someDays contains Monday or Wednesday\nsomeDays & Days.Weekend != Days.None; // someDays overlaps with the weekend\nsomeDays & Days.Weekdays == Days.Weekdays; // someDays is only made of weekdays\n\n
Consistent use of None in flag enumerations indicates that all flag values are cleared. The value 0 should not be used to indicate any\nother state since there is no way to check that the bit 0 is set.
\n[Flags]\nenum Days\n{\n Monday = 0, // 0 is used to indicate Monday\n Tuesday = 1,\n Wednesday = 2,\n Thursday = 4,\n Friday = 8,\n Saturday = 16,\n Sunday = 32,\n Weekdays = Monday | Tuesday | Wednesday | Thursday | Friday,\n Weekend = Saturday | Sunday,\n All = Weekdays | Weekend\n}\n\nvar someDays = Days.Wednesday | Days.Thursday;\nsomeDays & Days.Tuesday == Days.Tuesday // False, because someDays doesn't contains Tuesday\nsomeDays & Days.Monday == Days.Monday // True, even though someDays doesn't contains Monday!\nsomeDays.HasFlag(Days.Monday) // Same issue as above\n\n\n[Flags]\nenum FruitType\n{\n Void = 0, // Non-Compliant\n Banana = 1,\n Orange = 2,\n Strawberry = 4\n}\n\n\n[Flags]\nenum FruitType\n{\n None = 0, // Compliant\n Banana = 1,\n Orange = 2,\n Strawberry = 4\n}\n\nFields should not be part of an API, and therefore should always be private. Indeed, they cannot be added to an interface for instance, and\nvalidation cannot be added later on without breaking backward compatibility. Instead, developers should encapsulate their fields into properties.\nExplicit property getters and setters can be introduced for validation purposes or to smooth the transition to a newer system.
\n\npublic class Foo\n{\n public int MagicNumber = 42;\n}\n\n\npublic class Foo\n{\n public int MagicNumber\n {\n get { return 42; }\n }\n}\n\nor
\n\npublic class Foo\n{\n private int MagicNumber = 42;\n}\n\nstructs are ignored, as are static and const fields in classes.
Further, an issue is only raised when the real accessibility is public, taking into account the class accessibility.
The overloading mechanism should be used in place of optional parameters for several reasons:
\n\nvoid Notify(string company, string office = \"QJZ\") // Noncompliant\n{\n}\n\n\nvoid Notify(string company)\n{\n Notify(company, \"QJZ\");\n}\nvoid Notify(string company, string office)\n{\n}\n\nThe rule ignores non externally visible methods.
\n\n" }, { "path": "analyzers/rspec/cs/S2360.json", "content": "{\n \"title\": \"Optional parameters should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2360\",\n \"sqKey\": \"S2360\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S2365.html", "content": "Most developers expect property access to be as efficient as field access. However, if a property returns a copy of an array or collection, it will\nbe much slower than a simple field access, contrary to the caller’s likely expectations. Therefore, such properties should be refactored into methods\nso that callers are not surprised by the unexpectedly poor performance.
\nThis rule tracks calls to the following methods inside properties:
\n\n\nprivate List<string> foo = new List<string> { \"a\", \"b\", \"c\" };\nprivate string[] bar = new string[] { \"a\", \"b\", \"c\" };\n\npublic IEnumerable<string> Foo => foo.ToList(); // Noncompliant: collection foo is copied\n\npublic IEnumerable<string> Bar => (string[])bar.Clone(); // Noncompliant: array bar is copied\n\n\nprivate List<string> foo = new List<string> { \"a\", \"b\", \"c\" };\nprivate string[] bar = new string[] { \"a\", \"b\", \"c\" };\n\npublic IEnumerable<string> GetFoo() => foo.ToList();\n\npublic IEnumerable<string> GetBar() => (string[])bar.Clone();\n\nUsing multidimensional and
When these methods are exposed to external users, it requires advanced language knowledge for effective usage.
\nDetermining the appropriate data to pass to these parameters may not be intuitive.
\n\npublic class Program\n{\n public void WriteMatrix(int[][] matrix) // Noncompliant: data type is not intuitive\n {\n // ...\n }\n}\n\nIn this example, it cannot be inferred easily what the matrix should look like. Is it a 2x2 Matrix or even a triangular Matrix?
\nUsing a collection, data structure, or class that provides a more suitable representation of the required data is recommended instead of a\nmultidimensional array or jagged array to enhance code readability.
\n\npublic class Matrix2x2\n{\n // ...\n}\n\npublic class Program\n{\n public void WriteMatrix(Matrix2x2 matrix) // Compliant: data type is intuitive\n {\n // ...\n }\n}\n\nAs a result, avoiding exposing such methods to external users is recommended.
\nHowever, using multidimensional and jagged array method parameters internally, such as in private or internal methods or\nwithin internal classes, is compliant since they are not publicly exposed.
\npublic class FirstClass\n{\n private void UpdateMatrix(int[][] matrix) // Compliant: method is private\n {\n // ...\n }\n}\n\ninternal class SecondClass\n{\n public void UpdateMatrix(int[][] matrix) // Compliant: class is internal\n {\n // ...\n }\n}\n\nProperty getters should be simple operations that are always safe to call. If exceptions need to be thrown, it is best to convert the property to a\nmethod.
\nIt is valid to throw exceptions from indexed property getters and from property setters, which are not detected by this rule.
\n\npublic int Foo\n{\n get\n {\n throw new Exception(); // Noncompliant\n }\n}\n\n\npublic int Foo\n{\n get\n {\n return 42;\n }\n}\n\nNo issue is raised when the thrown exception derives from or is of type NotImplementedException, NotSupportedException or\nInvalidOperationException.
Properties with only setters are confusing and counterintuitive. Instead, a property getter should be added if possible, or the property should be\nreplaced with a setter method.
\n\nclass Program\n{\n public int Foo //Non-Compliant\n {\n set\n {\n // ... some code ...\n }\n }\n}\n\n\nclass Program\n{\n private int foo;\n\n public void SetFoo(int value)\n {\n // ... some code ...\n foo = value;\n }\n}\n\nor
\n\nclass Program\n{\n public int Foo { get; set; } // Compliant\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2376.json",
"content": "{\n \"title\": \"Write-only properties should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2376\",\n \"sqKey\": \"S2376\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2386.html",
"content": "public static mutable fields of classes which are accessed directly should be protected to the degree possible. This can be done by\nreducing the accessibility of the field or by changing the return type to an immutable type.
This rule raises issues for public static fields with a type inheriting/implementing System.Array or\nSystem.Collections.Generic.ICollection<T>.
\npublic class A\n{\n public static string[] strings1 = {\"first\",\"second\"}; // Noncompliant\n public static List<String> strings3 = new List<String>(); // Noncompliant\n}\n\n\npublic class A\n{\n protected static string[] strings1 = {\"first\",\"second\"};\n protected static List<String> strings3 = new List<String>();\n}\n\nNo issue is reported:
\nSystem.Collections.ObjectModel.ReadOnlyCollection<T>System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue>System.Collections.Frozen.FrozenDictionary<TKey, TValue>System.Collections.Frozen.FrozenSet<T>System.Collections.Immutable.ImmutableArray<T>System.Collections.Immutable.IImmutableDictionary<TKey, TValue>System.Collections.Immutable.IImmutableList<T>System.Collections.Immutable.IImmutableSet<T>System.Collections.Immutable.IImmutableStack<T>System.Collections.Immutable.IImmutableQueue<T>readonly and is initialized inline with an immutable type (i.e. inherits/implements one of the types in the\n previous list) or null.This rule is deprecated, and will eventually be removed.
\nHaving a variable with the same name in two unrelated classes is fine, but do the same thing within a class hierarchy and you’ll get confusion at\nbest, chaos at worst.
\n\npublic class Fruit\n{\n protected Season ripe;\n protected Color flesh;\n\n // ...\n}\n\npublic class Raspberry : Fruit\n{\n private bool ripe; // Noncompliant\n private static Color FLESH; // Noncompliant\n}\n\n\npublic class Fruit\n{\n protected Season ripe;\n protected Color flesh;\n\n // ...\n}\n\npublic class Raspberry : Fruit\n{\n private bool ripened;\n private static Color FLESH_COLOR;\n}\n\nThis rule ignores same-name fields that are static in both the parent and child classes. It also ignores private parent\nclass fields, but in all other such cases, the child class field should be renamed.
\npublic class Fruit\n{\n private Season ripe;\n // ...\n}\n\npublic class Raspberry : Fruit\n{\n private Season ripe; // Compliant as parent field 'ripe' is anyway not visible from Raspberry\n // ...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2387.json",
"content": "{\n \"title\": \"Child class fields should not shadow parent class fields\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"deprecated\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-2387\",\n \"sqKey\": \"S2387\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2436.html",
"content": "A method or class with too many type parameters has likely aggregated too many responsibilities and should be split.
\nWith the default parameter value of 2:
\n\n<S, T, U, V> void foo() {} // Noncompliant; not really readable\n<String, Integer, Object, String>foo(); // especially on invocations\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2436.json",
"content": "{\n \"title\": \"Types and methods should not have too many generic parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2436\",\n \"sqKey\": \"S2436\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2437.html",
"content": "Certain bitwise operations\nare not needed and should not be performed because their results are predictable.
\nSpecifically, using & -1 with any value always results in the original value.
That is because the binary representation of -1 on a int or long, is based on two’s\ncomplement and made of all 1s: 0b111…111.
Performing & between a value and 0b111…111 means applying the & operator to each bit of the value\nand the bit 1, resulting in a value equal to the provided one, bit by bit.
\nanyValue & -1 // Noncompliant\nanyValue // Compliant\n\n
Similarly, anyValue | 0 always results in anyValue, because the binary representation of 0 is always\n0b000…000 and the | operator returns its first input when the second is 0.
\nanyValue | 0 // Noncompliant\nanyValue // Compliant\n\n
The same applies to anyValue ^ 0: the ^ operator returns 1 when its two input bits are different\n(1 and 0 or 0 and 1) and returns 0 when its two input bits are the same (both\n0 or both 1). When ^ is applied with 0, the result would be 1 if the other input is\n1, because the two input bits are different, and 0 if the other input bit is 0, because the two input are the\nsame. That results in returning anyValue.
\nanyValue ^ 0 // Noncompliant\nanyValue // Compliant\n\n
Locking on a class field synchronizes not on the\nfield itself, but on the object assigned to it. Thus, there are some good practices to follow to avoid problems related to
readonly field makes it possible for the field’s value to change while a thread is in the code block, locked on\n the old value. This allows another thread to lock on the new value and access the same block concurrently.\n \nprivate Color color = new Color(\"red\");\nprivate void DoSomething()\n{\n // Synchronizing access via \"color\"\n lock (color) // Noncompliant: lock is actually on object instance \"red\" referred to by the \"color\" field\n {\n //...\n color = new Color(\"green\"); // other threads now allowed into this block\n // ...\n }\n}\n\nprivate void DoSomething()\n{\n lock (new object()) // Noncompliant: every thread locks on a different new instance\n {\n // ...\n }\n}\n\nprivate readonly string colorString = \"red\";\nprivate void DoSomething()\n{\n lock (colorString) // Noncompliant: strings can be interned\n {\n // ...\n }\n}\n\nprivate Color color = new Color(\"red\");\nprivate void DoSomething()\n{\n // Synchronizing access via \"color\"\n lock (color) // Noncompliant: lock is actually on object instance \"red\" referred to by the \"color\" field\n {\n //...\n color = new Color(\"green\"); // other threads now allowed into this block\n // ...\n }\n}\n\n\nprivate Color color = new Color(\"red\");\nprivate readonly object lockObj = new object();\n\nprivate void DoSomething()\n{\n lock (lockObj)\n {\n //...\n color = new Color(\"green\");\n // ...\n }\n}\n\nString.Intern(String) MethodNon-encoded control characters and whitespace characters are often injected in the\nsource code because of a bad manipulation. They are either invisible or difficult to recognize, which can result in bugs when the string is not what\nthe developer expects. If you actually need to use a control character use their encoded version:
\n\nThis rule raises an issue when the following characters are seen in a
U+200B, U+200C, U+200D, U+2060, U+FEFF, U+2028, U+2029U+0020, ASCII 32\nstring tabInside = \"A\tB\"; // Noncompliant: contains a tabulation\nstring zeroWidthSpaceInside = \"foobar\"; // Noncompliant: contains a U+200B character inside\nConsole.WriteLine(zeroWidthSpaceInside); // Prints \"foo?bar\"\n\n
\nstring tabInside = \"A\\tB\"; // Compliant: escaped value\nstring zeroWidthSpaceInside = \"foo\\u200Bbar\"; // Compliant: escaped value\nConsole.WriteLine(zeroWidthSpaceInside); // Prints \"foo?bar\"\n\n
When exceptions occur, it is usually a bad idea to simply ignore them. Instead, it is better to handle them properly, or at least to log them.
\nThis rule only reports on empty catch clauses that catch generic Exceptions.
\nstring text = \"\";\ntry\n{\n text = File.ReadAllText(fileName);\n}\ncatch (Exception exc) // Noncompliant\n{\n}\n\n\nstring text = \"\";\ntry\n{\n text = File.ReadAllText(fileName);\n}\ncatch (Exception exc)\n{\n logger.Log(exc);\n}\n\nWhen a block contains a comment, it is not considered to be empty.
\nThe instance passed to the lock\nstatement should be a dedicated private field.
If the instance representing an exclusively acquired lock is publicly accessible, another thread in another part of the program could accidentally\nattempt to acquire the same lock. This increases the likelihood of deadlocks.
\nFor example, a string should never be used for locking. When a string is
Instead, a dedicated private Lock object\ninstance (or object instance, for frameworks before .Net 9) should be used for locking. This minimizes access to the lock instance and\ntherefore prevents accidential lock sharing.
The following objects are considered potentially prone to accidental lock sharing:
\n\nvoid MyLockingMethod()\n{\n lock (this) // Noncompliant\n {\n // ...\n }\n}\n\n\n#if NET9_0_OR_GREATER\nprivate readonly Lock lockObj = new();\n#else\nprivate readonly object lockObj = new();\n#endif\n\nvoid MyLockingMethod()\n{\n lock (lockObj)\n {\n // ...\n }\n}\n\nConditional expressions which are always true or false can lead to
In the case below, the call of Dispose() never happens.
\nvar a = false;\nif (a)\n{\n Dispose(); // Never reached\n}\n\nThis rule will not raise an issue in either of these cases:
\nconst bool\n \nconst bool debug = false;\n//...\nif (debug)\n{\n // Print something\n}\ntrue or false.In these cases, it is obvious the code is as intended.
\nThe conditions should be reviewed to decide whether:
\n\npublic void Sample(bool b)\n{\n bool a = false;\n if (a) // Noncompliant: The true branch is never reached\n {\n DoSomething(); // Never reached\n }\n\n if (!a || b) // Noncompliant: \"!a\" is always \"true\" and the false branch is never reached\n {\n DoSomething();\n }\n else\n {\n DoSomethingElse(); // Never reached\n }\n\n var c = \"xxx\";\n var res = c ?? \"value\"; // Noncompliant: c is always not null, \"value\" is never used\n}\n\n\npublic void Sample(bool b)\n{\n bool a = false;\n if (Foo(a)) // Condition was updated\n {\n DoSomething();\n }\n\n if (b) // Parts of the condition were removed.\n {\n DoSomething();\n }\n else\n {\n DoSomethingElse();\n }\n\n var c = \"xxx\";\n var res = c; // ?? \"value\" was removed\n}\n\nGratuitous boolean expressions are conditions that do not change the evaluation of a program. This issue can indicate logical errors and affect the\ncorrectness of an application, as well as its maintainability.
\nControl flow constructs like if-statements allow the programmer to direct the flow of a program depending on a boolean expression.\nHowever, if the condition is always true or always false, only one of the branches will ever be executed. In that case, the control flow construct and\nthe condition no longer serve a purpose; they become gratuitous.
The presence of gratuitous conditions can indicate a logical error. For example, the programmer intended to have the program branch into\ndifferent paths but made a mistake when formulating the branching condition. In this case, this issue might result in a bug and thus affect the\nreliability of the application. For instance, it might lead to the computation of incorrect results.
\nAdditionally, gratuitous conditions and control flow constructs introduce unnecessary complexity. The source code becomes harder to understand, and\nthus, the application becomes more difficult to maintain.
\nThis rule looks for operands of a boolean expression never changing the result of the expression. It also applies to the null.
\nstring d = null;\nvar v1 = d ?? \"value\"; // Noncompliant\n\n
This rule will not raise an issue in either of these cases:
\nconst bool\n \nconst bool debug = false;\n//...\nif (debug) // Compliant\n{\n // Print something\n}\ntrue or false.In these cases, it is obvious the code is as intended.
\nGratuitous boolean expressions are suspicious and should be carefully removed from the code.
\nFirst, the boolean expression in question should be closely inspected for logical errors. If a mistake was made, it can be corrected so the\ncondition is no longer gratuitous.
\nIf it becomes apparent that the condition is actually unnecessary, it can be removed. The associated control flow construct (e.g., the\nif-statement containing the condition) will be adapted or even removed, leaving only the necessary branches.
\npublic void Sample(bool b, bool c)\n{\n var a = true;\n if (a) // Noncompliant: \"a\" is always \"true\"\n {\n DoSomething();\n }\n\n if (b && a) // Noncompliant: \"a\" is always \"true\"\n {\n DoSomething();\n }\n\n if (c || !a) // Noncompliant: \"!a\" is always \"false\"\n {\n DoSomething();\n }\n\n string d = null;\n var v1 = d ?? \"value\"; // Noncompliant: \"d\" is always null and v1 is always \"value\".\n var v2 = s ?? d; // Noncompliant: \"d\" is always null and v2 is always equal to s.\n}\n\nThe unnecessary operand is updated:
\n\npublic void Sample(bool b, bool c, string s)\n{\n var a = IsAllowed();\n if (a) // Compliant\n {\n DoSomething();\n }\n\n if (b && a) // Compliant\n {\n DoSomething();\n }\n\n if (c || !a) // Compliant\n {\n DoSomething();\n }\n\n string d = GetStringData();\n var v1 = d ?? \"value\"; // Compliant\n var v2 = s ?? d; // Compliant\n}\n\nThe unnecessary operand is removed:
\n\npublic void Sample(bool b, bool c, string s)\n{\n DoSomething();\n\n if (b) // Compliant\n {\n DoSomething();\n }\n\n if (c) // Compliant\n {\n DoSomething();\n }\n\n var v1 = \"value\"; // Compliant\n var v2 = s; // Compliant\n}\n\nIn Windows, \"Everyone\" group is similar and includes all members of the Authenticated Users group as well as the built-in Guest account, and\nseveral other built-in security accounts.
\nGranting permissions to this category can lead to unintended access to files or directories that could allow attackers to obtain sensitive\ninformation, disrupt services or elevate privileges.
\nWhen file or directory permissions grant access to all users on a system (often represented as \"others\" or \"everyone\" in permission models),\nattackers who gain access to any user account can read sensitive files containing credentials, configuration data, API keys, database passwords,\npersonal information, or proprietary business data. This exposure can lead to data breaches, identity theft, compliance violations, and competitive\ndisadvantage.
\nGranting write permissions to broad user categories allows any user on the system to modify or delete critical files and directories. Attackers or\ncompromised low-privileged accounts can corrupt application data, modify configuration files to alter system behavior or disrupt services, or delete\nimportant resources, leading to service outages, system instability, data loss, and denial of service.
\nWhen executable files or scripts have overly permissive permissions, especially when combined with special permission bits that allow programs to\nexecute with the permissions of the file owner or group rather than the executing user, attackers can replace legitimate executables with malicious\ncode. When these modified files are executed by privileged users or processes, the attacker’s code runs with elevated privileges, potentially enabling\nthem to escalate from a low-privileged account to root or administrator access, install backdoors, or pivot to other systems in the network.
\nInstead of granting access to \"Everyone\", explicitly deny access to this group or grant permissions only to specific users or groups that require\naccess. Use AccessControlType.Deny to prevent the \"Everyone\" group from accessing the file.
\nvar accessRule = new FileSystemAccessRule(\n \"Everyone\",\n FileSystemRights.FullControl,\n AccessControlType.Allow);\n\nvar fileSecurity = File.GetAccessControl(\"path\");\nfileSecurity.AddAccessRule(accessRule); // Noncompliant\nFile.SetAccessControl(\"fileName\", fileSecurity);\n\n
\nvar accessRule = new FileSystemAccessRule(\n \"Everyone\",\n FileSystemRights.FullControl,\n AccessControlType.Deny);\n\nvar fileSecurity = File.GetAccessControl(\"path\");\nfileSecurity.AddAccessRule(accessRule);\nFile.SetAccessControl(\"path\", fileSecurity);\n\n
Use AccessControlType.Deny instead of AccessControlType.Allow when setting access rules for the \"Everyone\" group. This\nprevents the broad group from having write or full control access to files.
\nvar accessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.Write, AccessControlType.Allow);\nvar fileInfo = new FileInfo(\"path\");\nvar fileSecurity = fileInfo.GetAccessControl();\n\nfileSecurity.SetAccessRule(accessRule); // Noncompliant\nfileInfo.SetAccessControl(fileSecurity);\n\n
\nvar accessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.FullControl, AccessControlType.Deny);\nvar fileInfo = new FileInfo(\"path\");\nvar fileSecurity = fileInfo.GetAccessControl();\n\nfileSecurity.SetAccessRule(accessRule);\nfileInfo.SetAccessControl(fileSecurity);\n\n
Avoid setting permissions that grant read, write, or execute access to \"others\" (all users). Instead, restrict permissions to the file owner or\nspecific groups. Use FileAccessPermissions.UserExecute or other restrictive permission flags that limit access to the owner only.
\nvar fsEntry = UnixFileSystemInfo.GetFileSystemEntry(\"path\");\nfsEntry.FileAccessPermissions = FileAccessPermissions.OtherReadWriteExecute; // Noncompliant\n\n
\nvar fsEntry = UnixFileSystemInfo.GetFileSystemEntry(\"path\");\nfsEntry.FileAccessPermissions = FileAccessPermissions.UserExecute;\n\n
Logging arguments should not require evaluation in order to avoid unnecessary performance overhead. When passing concatenated strings or string\ninterpolations directly into a logging method, the evaluation of these expressions occurs every time the logging method is called, regardless of the\nlog level. This can lead to inefficient code execution and increased resource consumption.
\nInstead, it is recommended to use the overload of the logger that accepts a log format and its arguments as separate parameters. By separating the\nlog format from the arguments, the evaluation of expressions can be deferred until it is necessary, based on the log level. This approach improves\nperformance by reducing unnecessary evaluations and ensures that logging statements are only evaluated when needed.
\nFurthermore, using a constant log format enhances observability and facilitates searchability in log aggregation and monitoring software.
\nThe rule covers the following logging frameworks:
\nUse an overload that takes the log format and the parameters as separate arguments. The log format should be a constant string.
\n\nlogger.DebugFormat($\"The value of the parameter is: {parameter}.\");\n\n\nlogger.DebugFormat(\"The value of the parameter is: {Parameter}.\", parameter);\n\n| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n | \n | \n | \n | \n |
| \n CastleCoreLoggingTemplateNotConstant \n | \n \n .NET 9.0 \n | \n \n 230.306 us \n | \n \n 2.7116 us \n | \n \n 479200 B \n | \n
| \n CastleCoreLoggingTemplateConstant \n | \n \n .NET 9.0 \n | \n \n 46.827 us \n | \n \n 1.4743 us \n | \n \n 560000 B \n | \n
| \n CastleCoreLoggingTemplateNotConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 1,060.413 us \n | \n \n 32.3559 us \n | \n \n 1115276 B \n | \n
| \n CastleCoreLoggingTemplateConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 93.697 us \n | \n \n 1.8201 us \n | \n \n 561650 B \n | \n
| \n | \n | \n | \n | \n |
| \n MSLoggingTemplateNotConstant \n | \n \n .NET 9.0 \n | \n \n 333.246 us \n | \n \n 12.9214 us \n | \n \n 479200 B \n | \n
| \n MSLoggingTemplateConstant \n | \n \n .NET 9.0 \n | \n \n 441.118 us \n | \n \n 68.7999 us \n | \n \n 560000 B \n | \n
| \n MSLoggingTemplateNotConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 1,542.076 us \n | \n \n 99.3423 us \n | \n \n 1115276 B \n | \n
| \n MSLoggingTemplateConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 698.071 us \n | \n \n 18.6319 us \n | \n \n 561653 B \n | \n
| \n | \n | \n | \n | \n |
| \n NLogLoggingTemplateNotConstant \n | \n \n .NET 9.0 \n | \n \n 178.789 us \n | \n \n 9.2528 us \n | \n \n 479200 B \n | \n
| \n NLogLoggingTemplateConstant \n | \n \n .NET 9.0 \n | \n \n 6.009 us \n | \n \n 1.3303 us \n | \n \n - \n | \n
| \n NLogLoggingTemplateNotConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 1,086.260 us \n | \n \n 44.1670 us \n | \n \n 1115276 B \n | \n
| \n NLogLoggingTemplateConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 25.132 us \n | \n \n 0.5666 us \n | \n \n - \n | \n
| \n | \n | \n | \n | \n |
| \n SerilogLoggingTemplateNotConstant \n | \n \n .NET 9.0 \n | \n \n 234.460 us \n | \n \n 7.4831 us \n | \n \n 479200 B \n | \n
| \n SerilogLoggingTemplateConstant \n | \n \n .NET 9.0 \n | \n \n 49.854 us \n | \n \n 1.8232 us \n | \n \n - \n | \n
| \n SerilogLoggingTemplateNotConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 1,103.939 us \n | \n \n 47.0203 us \n | \n \n 1115276 B \n | \n
| \n SerilogLoggingTemplateConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 35.752 us \n | \n \n 0.6022 us \n | \n \n - \n | \n
| \n | \n | \n | \n | \n |
| \n Log4NetLoggingTemplateNotConstant \n | \n \n .NET 9.0 \n | \n \n 255.754 us \n | \n \n 5.6046 us \n | \n \n 479200 B \n | \n
| \n Log4NetLoggingTemplateConstant \n | \n \n .NET 9.0 \n | \n \n 46.425 us \n | \n \n 1.7087 us \n | \n \n 240000 B \n | \n
| \n Log4NetLoggingTemplateNotConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 1,109.874 us \n | \n \n 23.4388 us \n | \n \n 1115276 B \n | \n
| \n Log4NetLoggingTemplateConstant \n | \n \n .NET Framework 4.8.1 \n | \n \n 92.305 us \n | \n \n 2.4161 us \n | \n \n 240707 B \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nusing Microsoft.Extensions.Logging;\nusing ILogger = Microsoft.Extensions.Logging.ILogger;\n\n[Params(10_000)]\npublic int Iterations;\n\nprivate ILogger ms_logger;\nprivate Castle.Core.Logging.ILogger cc_logger;\nprivate log4net.ILog l4n_logger;\nprivate Serilog.ILogger se_logger;\nprivate NLog.ILogger nl_logger;\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n ms_logger = new LoggerFactory().CreateLogger<LoggingTemplates>();\n cc_logger = new Castle.Core.Logging.NullLogFactory().Create(\"Castle.Core.Logging\");\n l4n_logger = log4net.LogManager.GetLogger(typeof(LoggingTemplates));\n se_logger = Serilog.Log.Logger;\n nl_logger = NLog.LogManager.GetLogger(\"NLog\");\n}\n\n[BenchmarkCategory(\"Microsoft.Extensions.Logging\")]\n[Benchmark]\npublic void MSLoggingTemplateNotConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n ms_logger.LogInformation($\"Param: {i}\");\n }\n}\n\n[BenchmarkCategory(\"Microsoft.Extensions.Logging\")]\n[Benchmark]\npublic void MSLoggingTemplateConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n ms_logger.LogInformation(\"Param: {Parameter}\", i);\n }\n}\n\n[BenchmarkCategory(\"Castle.Core.Logging\")]\n[Benchmark]\npublic void CastleCoreLoggingTemplateNotConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n cc_logger.Info($\"Param: {i}\");\n }\n}\n\n[BenchmarkCategory(\"Castle.Core.Logging\")]\n[Benchmark]\npublic void CastleCoreLoggingTemplateConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n cc_logger.InfoFormat(\"Param: {Parameter}\", i);\n }\n}\n\n[BenchmarkCategory(\"log4net\")]\n[Benchmark]\npublic void Log4NetLoggingTemplateNotConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n l4n_logger.Info($\"Param: {i}\");\n }\n}\n\n[BenchmarkCategory(\"log4net\")]\n[Benchmark]\npublic void Log4NetLoggingTemplateConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n l4n_logger.InfoFormat(\"Param: {Parameter}\", i);\n }\n}\n\n[BenchmarkCategory(\"Serilog\")]\n[Benchmark]\npublic void SerilogLoggingTemplateNotConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n se_logger.Information($\"Param: {i}\");\n }\n}\n\n[BenchmarkCategory(\"Serilog\")]\n[Benchmark]\npublic void SerilogLoggingTemplateConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n se_logger.Information(\"Param: {Parameter}\", i);\n }\n}\n\n[BenchmarkCategory(\"NLog\")]\n[Benchmark]\npublic void NLogLoggingTemplateNotConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n nl_logger.Info($\"Param: {i}\");\n }\n}\n\n[BenchmarkCategory(\"NLog\")]\n[Benchmark]\npublic void NLogLoggingTemplateConstant()\n{\n for (int i = 0; i < Iterations; i++)\n {\n nl_logger.Info(\"Param: {Parameter}\", i);\n }\n}\n\nHardware Configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S2629.json", "content": "{\n \"title\": \"Logging templates should be constant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\",\n \"logging\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2629\",\n \"sqKey\": \"S2629\",\n \"scope\": \"Main\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/cs/S2674.html", "content": "
Invoking a stream reading method without verifying the number of bytes read can lead to erroneous assumptions. A Stream can represent any I/O\noperation, such as reading a file, network communication, or inter-process communication. As such, it is not guaranteed that the byte[]\npassed into the method will be filled with the requested number of bytes. Therefore, inspecting the value returned by the reading method is important\nto ensure the number of bytes read.
Neglecting the returned length read can result in a bug that is difficult to reproduce.
\nThis rule raises an issue when the returned value is ignored for the following methods:
\n\nCheck the return value of stream reading methods to verify the actual number of bytes read, and use this value when processing the data to avoid\npotential bugs.
\n\npublic byte[] ReadFile(string fileName)\n{\n using var stream = File.Open(fileName, FileMode.Open);\n var result = new byte[stream.Length];\n\n stream.Read(result, 0, (int)stream.Length); // Noncompliant\n\n return result;\n}\n\n\npublic byte[] ReadFile(string fileName)\n{\n using var stream = File.Open(fileName, FileMode.Open);\n using var ms = new MemoryStream();\n var buffer = new byte[1024];\n int read;\n\n while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)\n {\n ms.Write(buffer, 0, read);\n }\n\n return ms.ToArray();\n}\n\nHaving inconsistent indentation and omitting curly braces from a control structure, such as an if statement or for loop,\nis misleading and can induce bugs.
This rule raises an issue when the indentation of the lines after a control structure indicates an intent to include those lines in the block, but\nthe omission of curly braces means the lines will be unconditionally executed once.
\nThe following patterns are recognized:
\n\nif (condition)\n FirstActionInBlock();\n SecondAction(); // Noncompliant: SecondAction is executed unconditionally\nThirdAction();\n\n
\nif(condition) FirstActionInBlock(); SecondAction(); // Noncompliant: SecondAction is executed unconditionally\n\n
\nif (condition) FirstActionInBlock();\n SecondAction(); // Noncompliant: SecondAction is executed unconditionally\n\n
\nstring str = null;\nfor (int i = 0; i < array.Length; i++)\n str = array[i];\n DoTheThing(str); // Noncompliant: executed only on the last element\n\n
Note that this rule considers tab characters to be equivalent to 1 space. When mixing spaces and tabs, a code may look fine in one editor but be\nconfusing in another configured differently.
\ndouble.NaN and
When anything is compared with NaN using one of the >,\n>=, <, ⇐ or the ==, the result will always be false. In contrast, when anything is compared with NaN using the !=, the result will always be true.
Instead, the best way to see whether a variable is equal to NaN is to use the
\nvar a = double.NaN;\n\nif (a == double.NaN) // Noncompliant: always false\n{\n Console.WriteLine(\"a is not a number\");\n}\nif (a != double.NaN) // Noncompliant: always true\n{\n Console.WriteLine(\"a is not NaN\");\n}\n\n\nvar a = double.NaN;\n\nif (double.IsNaN(a))\n{\n Console.WriteLine(\"a is not a number\");\n}\nif (!double.IsNaN(a))\n{\n Console.WriteLine(\"a is not NaN\");\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2688.json",
"content": "{\n \"title\": \"\\\"NaN\\\" should not be used in comparisons\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2688\",\n \"sqKey\": \"S2688\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2692.html",
"content": "Most checks against an IndexOf value compare it with -1 because\n0 is a valid index.
\n\nstrings.IndexOf(someString) == -1 // Test for \"index not found\"\nstrings.IndexOf(someString) < 0 // Test for \"index not found\"\nstrings.IndexOf(someString) >= 0 // Test for \"index found\"\n\n
Any checks which look for values > 0 ignore the first element, which is likely a bug. If the intent is merely to check the\ninclusion of a value in a string, List, or array, consider using the
\nstrings.Contains(someString) // bool result\n\n
This rule raises an issue when the output value of any of the following methods is tested against > 0:
string, list or\n arraystringstring, list or\n arraystring\nsomeArray.IndexOf(someItem) > 0 // Noncompliant: index 0 missing\nsomeString.IndexOfAny(charsArray) > 0 // Noncompliant: index 0 missing\nsomeList.LastIndexOf(someItem) > 0 // Noncompliant: index 0 missing\nsomeString.LastIndexOf(charsArray) > 0 // Noncompliant: index 0 missing\n\n
\nstring color = \"blue\";\nstring name = \"ishmael\";\n\nList<string> strings = new List<string>();\nstrings.Add(color);\nstrings.Add(name);\nstring[] stringArray = strings.ToArray();\n\nif (strings.IndexOf(color) > 0) // Noncompliant\n{\n // ...\n}\n\nif (name.IndexOf(\"ish\") > 0) // Noncompliant\n{\n // ...\n}\n\nif (name.IndexOf(\"ae\") > 0) // Noncompliant\n{\n // ...\n}\n\nif (Array.IndexOf(stringArray, color) > 0) // Noncompliant\n{\n // ...\n}\n\n\nstring color = \"blue\";\nstring name = \"ishmael\";\n\nList<string> strings = new List<string>();\nstrings.Add(color);\nstrings.Add(name);\nstring[] stringArray = strings.ToArray();\n\nif (strings.IndexOf(color) > -1)\n{\n // ...\n}\n\nif (name.IndexOf(\"ish\") >= 0)\n{\n // ...\n}\n\nif (name.Contains(\"ae\"))\n{\n // ...\n}\n\nif (Array.IndexOf(stringArray, color) >= 0)\n{\n // ...\n}\n\nThis rule raises an issue each time a static field is updated from a non-static method or property.
Updating a static field from a non-static method introduces significant challenges and potential bugs. Multiple class\ninstances and threads can access and modify the static field concurrently, leading to unintended consequences for other instances or\nthreads (unexpected behavior, race conditions and\nsynchronization problems).
\nclass MyClass\n{\n private static int count = 0;\n\n public void DoSomething()\n {\n //...\n count++; // Noncompliant: make the enclosing instance property 'static' or remove this set on the 'static' field.\n }\n}\n\ninterface MyInterface\n{\n private static int count = 0;\n\n public void DoSomething()\n {\n //...\n count++; // Noncompliant: remove this set, which updates a 'static' field from an instance method.\n }\n}\n\nThe rule targets test methods that lack an assertion and consist solely of an action and, optionally, a setup.
\n\n[TestMethod]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n}\n\nSuch tests only verify that the system under test does not throw any exceptions without providing any guarantees regarding the code’s behavior\nunder test. Those tests increase the coverage without enforcing anything on the covered code, resulting in a false sense of security.
\nThe rule identifies a potential issue when no assertions are present in tests utilizing the following frameworks:
\nMSTestNUnitxUnitFluentAssertions (4.x and 5.x)NFluentNSubstituteMoqShoudlyBy enforcing the presence of assertions, this rule aims to enhance the reliability and comprehensiveness of tests by ensuring that they provide\nmeaningful validation of the expected behavior.
\nTest methods that include a call to a custom assertion method will not raise any issues.
\nTo address this issue, you should include assertions to validate the expected behavior. Choose an appropriate assertion method provided by your\ntesting framework (such as MSTest, NUnit, xUnit) or select a suitable assertion library like FluentAssertions, NFluent, NSubstitute, Moq, or\nShouldly.
\nIn addition to using built-in assertion methods, you also have the option to create custom assertion methods. To do this, declare an attribute\nnamed [AssertionMethodAttribute] and apply it to the respective method. This allows you to encapsulate specific validation logic within\nyour custom assertion methods without raising the issue. Here’s an example:
\nusing System;\nusing Microsoft.VisualStudio.TestTools.UnitTesting;\n\n[TestClass]\npublic class CustomTestExample\n{\n [TestMethod]\n public void Add_SingleNumber_ReturnsSameNumber()\n {\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n Validator.AssertCustomEquality(0, actual); // Compliant\n }\n}\n\npublic static class Validator\n{\n [AssertionMethod]\n public static void AssertCustomEquality(int expected, int actual)\n {\n // ...\n }\n}\n\npublic class AssertionMethodAttribute : Attribute { }\n\n\n[TestMethod]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n}\n\n\n[TestMethod]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n Assert.AreEqual(0, actual);\n}\n\n\n[Test]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n}\n\n\n[Test]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n Assert.That(0, Is.EqualTo(actual));\n}\n\n\n[Fact]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n}\n\n\n[Fact]\npublic void Add_SingleNumber_ReturnsSameNumber()\n{\n var stringCalculator = new StringCalculator();\n var actual = stringCalculator.Add(\"0\");\n Assert.Equal(0, actual);\n}\n\nUsing literal boolean values in assertions can lead to less readable and less informative unit tests. When a test fails, it’s important to have a\nclear understanding of what the test was checking and why it failed. Most of the testing frameworks provide more explicit assertion methods that will\nprovide a more helpful error message if the test fails.
\nIn the context of xUnit, Assert.True and Assert.False are not flagged by this rule. This is because\nAssert.Fail was only introduced in 2020 with version 2.4.2. Prior to this, developers used Assert.True(false,\nmessage) and Assert.False(true, message) as workarounds to simulate the functionality of Assert.Fail().
\nbool someResult;\n\nAssert.AreEqual(false, someResult); // Noncompliant: use Assert.IsFalse\nAssert.AreEqual(true, someResult); // Noncompliant: use Assert.IsTrue\nAssert.AreNotEqual(false, someResult); // Noncompliant: use Assert.IsTrue\nAssert.AreNotEqual(true, someResult); // Noncompliant: use Assert.IsFalse\nAssert.IsFalse(true, \"Should not reach this line!\"); // Noncompliant: use Assert.Fail\nAssert.IsTrue(false, \"Should not reach this line!\"); // Noncompliant: use Assert.Fail\nAssert.IsFalse(false); // Noncompliant: remove it\n\n
\nbool someResult;\n\nAssert.IsFalse(someResult);\nAssert.IsTrue(someResult);\nAssert.IsTrue(someResult);\nAssert.IsFalse(someResult);\nAssert.Fail(\"Should not reach this line!\");\nAssert.Fail(\"Should not reach this line!\");\n// Removed\n\n
\nbool someResult;\n\nAssert.AreEqual(false, someResult); // Noncompliant: use Assert.False\nAssert.AreEqual(true, someResult); // Noncompliant: use Assert.True\nAssert.AreNotEqual(false, someResult); // Noncompliant: use Assert.True\nAssert.AreNotEqual(true, someResult); // Noncompliant: use Assert.False\nAssert.False(true, \"Should not reach this line!\"); // Noncompliant: use Assert.Fail\nAssert.True(false, \"Should not reach this line!\"); // Noncompliant: use Assert.Fail\nAssert.False(false); // Noncompliant: remove it\n\n
\nbool someResult;\n\nAssert.False(someResult);\nAssert.True(someResult);\nAssert.True(someResult);\nAssert.False(someResult);\nAssert.Fail(\"Should not reach this line!\");\nAssert.Fail(\"Should not reach this line!\");\n// Removed\n\n
\nbool someResult;\n\nAssert.Equal(false, someResult); // Noncompliant: use Assert.False\nAssert.Equal(true, someResult); // Noncompliant: use Assert.True\nAssert.NotEqual(false, someResult); // Noncompliant: use Assert.True\nAssert.NotEqual(true, someResult); // Noncompliant: use Assert.False\n\n
\nbool someResult;\n\nAssert.False(someResult);\nAssert.True(someResult);\nAssert.True(someResult);\nAssert.False(someResult);\n\n
A catch clause that only rethrows the caught exception has the same effect as omitting the catch altogether and letting\nit bubble up automatically.
\nstring s = \"\";\ntry\n{\n s = File.ReadAllText(fileName);\n}\ncatch (Exception e) // Noncompliant\n{\n throw;\n}\n\nSuch clauses should either be removed or populated with the appropriate logic.
\n\nstring s = File.ReadAllText(fileName);\n\n
or
\n\nstring s = \"\";\ntry\n{\n s = File.ReadAllText(fileName);\n}\ncatch (Exception e)\n{\n logger.LogError(e);\n throw;\n}\n\nThis rule will not generate issues for catch blocks if they are followed by a catch block for a more general exception\ntype that does more than just rethrowing the exception.
\nvar s = \"\"\ntry\n{\n s = File.ReadAllText(fileName);\n}\ncatch (IOException) // Compliant by exception: removing it would change the logic\n{\n throw;\n}\ncatch (Exception) // Compliant: does more than just rethrow\n{\n logger.LogError(e);\n throw;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2737.json",
"content": "{\n \"title\": \"\\\"catch\\\" clauses should do more than rethrow\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"error-handling\",\n \"unused\",\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2737\",\n \"sqKey\": \"S2737\",\n \"scope\": \"Main\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2743.html",
"content": "A static field in a generic type is not shared among instances of different closed constructed types, thus\nLengthLimitedSingletonCollection<int>.instances and LengthLimitedSingletonCollection<string>.instances will\npoint to different objects, even though instances is seemingly shared among all LengthLimitedSingletonCollection<>\ngeneric classes.
If you need to have a static field shared among instances with different generic arguments, define a non-generic base class to store your static\nmembers, then set your generic type to inherit from the base class.
\n\npublic class LengthLimitedSingletonCollection<T> where T : new()\n{\n protected const int MaxAllowedLength = 5;\n protected static Dictionary<Type, object> instances = new Dictionary<Type, object>(); // Noncompliant\n\n public static T GetInstance()\n {\n object instance;\n\n if (!instances.TryGetValue(typeof(T), out instance))\n {\n if (instances.Count >= MaxAllowedLength)\n {\n throw new Exception();\n }\n instance = new T();\n instances.Add(typeof(T), instance);\n }\n return (T)instance;\n }\n}\n\n\npublic class SingletonCollectionBase\n{\n protected static Dictionary<Type, object> instances = new Dictionary<Type, object>();\n}\n\npublic class LengthLimitedSingletonCollection<T> : SingletonCollectionBase where T : new()\n{\n protected const int MaxAllowedLength = 5;\n\n public static T GetInstance()\n {\n object instance;\n\n if (!instances.TryGetValue(typeof(T), out instance))\n {\n if (instances.Count >= MaxAllowedLength)\n {\n throw new Exception();\n }\n instance = new T();\n instances.Add(typeof(T), instance);\n }\n return (T)instance;\n }\n}\n\nIf the static field or property uses a type parameter, then the developer is assumed to understand that the static member is not shared among the\nclosed constructed types.
\n\npublic class Cache<T>\n{\n private static Dictionary<string, T> CacheDictionary { get; set; } // Compliant\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2743.json",
"content": "{\n \"title\": \"Static fields should not be used in generic types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2743\",\n \"sqKey\": \"S2743\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2755.html",
"content": "This vulnerability allows the usage of external entities in XML.
\nExternal Entity Processing allows for XML parsing with the involvement of external entities. However, when this functionality is enabled without\nproper precautions, it can lead to a vulnerability known as XML External Entity (XXE) attack.
\nOne significant danger of XXE vulnerabilities is the potential for sensitive data exposure. By crafting malicious XML payloads, attackers can\nreference external entities that contain sensitive information, such as system files, database credentials, or configuration files. When these\nentities are processed during XML parsing, the attacker can extract the contents and gain unauthorized access to sensitive data. This poses a severe\nthreat to the confidentiality of critical information.
\nAnother consequence of XXE vulnerabilities is the potential for denial-of-service attacks. By exploiting the ability to include external entities,\nattackers can construct XML payloads that cause resource exhaustion. This can overwhelm the system’s memory, CPU, or other critical resources, leading\nto system unresponsiveness or crashes. A successful DoS attack can disrupt the availability of services and negatively impact the user experience.
\nXXE vulnerabilities can also enable Server-Side Request Forgery (SSRF) attacks. By leveraging the ability to include external entities, an attacker\ncan make the vulnerable application send arbitrary requests to other internal or external systems. This can result in unintended actions, such as\nretrieving data from internal resources, scanning internal networks, or attacking other systems. SSRF attacks can lead to severe consequences,\nincluding unauthorized data access, system compromise, or even further exploitation within the network infrastructure.
\nThe following code contains examples of XML parsers that have external entity processing enabled. As a result, the parsers are vulnerable to XXE\nattacks if an attacker can control the XML file that is processed.
\n\nusing System.Xml;\n\npublic static void decode()\n{\n XmlDocument parser = new XmlDocument();\n parser.XmlResolver = new XmlUrlResolver(); // Noncompliant\n parser.LoadXml(\"xxe.xml\");\n}\n\nXmlDocument is safe by default since .NET Framework 4.5.2. For older versions, set XmlResolver explicitly to\nnull.
\nusing System.Xml;\n\npublic static void decode()\n{\n XmlDocument parser = new XmlDocument();\n parser.XmlResolver = null;\n parser.LoadXml(\"xxe.xml\");\n}\n\nThe most effective approach to prevent XXE vulnerabilities is to disable external entity processing entirely, unless it is explicitly required for\nspecific use cases. By default, XML parsers should be configured to reject the processing of external entities. This can be achieved by setting the\nappropriate properties or options in your XML parser library or framework.
\nIf external entity processing is necessary for certain scenarios, adopt a whitelisting approach to restrict the entities that can be resolved\nduring XML parsing. Create a list of trusted external entities and disallow all others. This approach ensures that only known and safe entities are\nprocessed.\n
\n You should rely on features provided by your XML parser to restrict the external entities.
Using operator pairs (=+, =-, or =!) that look like reversed single operators (+=,\n-= or !=) is confusing. They compile and run but do not produce the same result as their mirrored counterpart.
\nint target = -5;\nint num = 3;\n\ntarget =- num; // Noncompliant: target = -3. Is that the intended behavior?\ntarget =+ num; // Noncompliant: target = 3\n\n
This rule raises an issue when =+, =-, or =! are used without any space between the operators and when there\nis at least one whitespace after.
Replace the operators with a single one if that is the intention
\n\nint target = -5;\nint num = 3;\n\ntarget -= num; // target = -8\n\n
Or fix the spacing to avoid confusion
\n\nint target = -5;\nint num = 3;\n\ntarget = -num; // target = -3\n\n\n" }, { "path": "analyzers/rspec/cs/S2757.json", "content": "{\n \"title\": \"Non-existent operators like \\\"\\u003d+\\\" should not be used\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2757\",\n \"sqKey\": \"S2757\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S2760.html", "content": "
When the same condition is checked twice in a row, it is either confusing - why have separate checks? - or an error - some other condition should\nhave been checked in the second test.
\n\nif (a == b)\n{\n doTheThing(b);\n}\nif (a == b) // Noncompliant; is this really what was intended?\n{\n doTheThing(c);\n}\n\n\nif (a == b)\n{\n doTheThing(b);\n doTheThing(c);\n}\n\nor
\n\nif (a == b)\n{\n doTheThing(b);\n}\nif (b == c)\n{\n doTheThing(c);\n}\n\nSince it is a common pattern to test a variable, reassign it if it fails the test, then re-test it, that pattern is ignored.
\n\n" }, { "path": "analyzers/rspec/cs/S2760.json", "content": "{\n \"title\": \"Sequential tests should not check the same condition\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2760\",\n \"sqKey\": \"S2760\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S2761.html", "content": "The repetition of a prefix operator (!, or ~) is usually a typo. The second operator invalidates the first one.
\nint v1 = 0;\nbool v2 = false;\n\nvar v3 = !!v1; // Noncompliant: equivalent to \"v1\"\nvar v4 = ~~v2; // Noncompliant: equivalent to \"v2\"\n\n\n" }, { "path": "analyzers/rspec/cs/S2761.json", "content": "{\n \"title\": \"Doubled prefix operators \\\"!!\\\" and \\\"~~\\\" should not be used\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2761\",\n \"sqKey\": \"S2761\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S2857.html", "content": "
When concatenating strings, it is very easy to forget a whitespace.
\nIn some scenarios this might cause runtime errors, one of which is while creating an SQL query via concatenation:
\n\nstring select = \"SELECT p.FirstName, p.LastName, p.PhoneNumber\" +\n \"FROM Person as p\" + // Noncompliant: concatenation results in \"p.PhoneNumberFROM\"\n \"WHERE p.Id = @Id\"; // Noncompliant: concatenation results in \"pWHERE\"\n\n
This rule raises an issue when the spacing around SQL keywords appears to be missing, making the concatenated string invalid SQL syntax. It would\nrequire the user to add the appropriate whitespaces:
\n\nstring select = \"SELECT p.FirstName, p.LastName, p.PhoneNumber\" +\n \" FROM Person as p\" +\n \" WHERE p.Id = @Id\";\n\n\n" }, { "path": "analyzers/rspec/cs/S2857.json", "content": "{\n \"title\": \"SQL keywords should be delimited by whitespace\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"sql\"\n ],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-2857\",\n \"sqKey\": \"S2857\",\n \"scope\": \"Main\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S2925.html", "content": "
Using Thread.Sleep in a test might introduce unpredictable and inconsistent results depending on the environment. Furthermore, it will\nblock the thread, which means the system resources are not being fully used.
\n[TestMethod]\npublic void SomeTest()\n{\n Thread.Sleep(500); // Noncompliant\n // assertions...\n}\n\nAn alternative is a task-based asynchronous approach, using
More specifically the Task.Delay method should be\nused, because of the following advantages:
\nThread.Sleep\n[TestMethod]\npublic async Task SomeTest()\n{\n await Task.Delay(500);\n // assertions...\n}\n\nAnother scenario is when some data might need to be mocked using Moq, and a delay needs to be\nintroduced:
\n\n[TestMethod]\npublic void UserService_Test()\n{\n var userService = new Mock<UserService>();\n var expected = new User();\n\n userService\n .Setup(m => m.GetUserById(42))\n .Returns(() =>\n {\n Thread.Sleep(500); // Noncompliant\n return Task.FromResult(expected);\n });\n\n // assertions...\n}\n\nAn alternative to Thread.Sleep while mocking with Moq is to use ReturnsAsync and pass the amount of time to\ndelay there:
\n[TestMethod]\npublic void UserService_Test()\n{\n var userService = new Mock<UserService>();\n var expected = new User();\n\n userService\n .Setup(m => m.GetUserById(42))\n .ReturnsAsync(expected, TimeSpan.FromMilliseconds(500));\n\n // assertions...\n}\n\nWhen writing managed code, there is no need to worry about memory\nallocation or deallocation as it is taken care of by the garbage\ncollector. However, certain objects, such as Bitmap, utilize unmanaged memory for specific purposes like Bitmap) for efficiency reasons.
In addition, it’s essential to manage other system resources besides memory. The operating system has limits on the number of FileStream) or WebClient) that can remain open simultaneously. Therefore, it’s\ncrucial to Dispose of these resources promptly when they are no longer required, instead of relying on the garbage collector to invoke\nthe finalizers of these objects at an unpredictable time in the future.
This rule keeps track of private fields and local variables of specific types that implement IDisposable or\nIAsyncDisposable. It identifies instances of these types that are not properly disposed, closed, aliased, returned, or passed to other\nmethods. This applies to instances that are either directly created using the new operator or instantiated through a predefined list of\nfactory methods.
Here is the list of the types tracked by this rule:
\nFluentAssertions.Execution.AssertionScopeSystem.Drawing.BitmapSystem.Drawing.ImageSystem.IO.FileStreamSystem.IO.StreamReaderSystem.IO.StreamWriterSystem.Net.Sockets.TcpClientSystem.Net.Sockets.UdpClientSystem.Net.WebClientHere is the list of predefined factory methods tracked by this rule:
\nSystem.Drawing.Image.FromFile()System.Drawing.Image.FromStream()System.IO.File.Create()System.IO.File.Open()IDisposable / IAsyncDisposable variables returned from a method or passed to other methods are ignored, as are local\nIDisposable / IAsyncDisposable objects that are initialized with other IDisposable /\nIAsyncDisposable objects.
\npublic Stream WriteToFile(string path, string text)\n{\n var fs = new FileStream(path, FileMode.Open); // Compliant: it is returned\n var bytes = Encoding.UTF8.GetBytes(text);\n fs.Write(bytes, 0, bytes.Length);\n return fs;\n}\n\npublic void ReadFromStream(Stream s)\n{\n var sr = new StreamReader(s); // Compliant: it would close the underlying stream.\n // ...\n}\n\nIt is essential to identify what kind of disposable resource variable is used to know how to fix this issue.
\nIn the case of a disposable resource store as a member (either as field or property), it should be disposed at the same time as the class. The best\nway to achieve this is to follow the dispose\npattern.
\nWhen creating the disposable resource for a one-time use (cases not covered by the exceptions), it should be disposed at the end of its creation\nscope. The easiest to ensure your resource is disposed when reaching the end of a scope is to either use
\npublic class ResourceHolder\n{\n private FileStream fs; // Noncompliant: dispose or close are never called\n\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open);\n }\n\n public void WriteToFile(string path, string text)\n {\n var fs = new FileStream(path, FileMode.Open); // Noncompliant: not disposed, returned or initialized with another disposable object\n var bytes = Encoding.UTF8.GetBytes(text);\n fs.Write(bytes, 0, bytes.Length);\n }\n}\n\n\npublic class ResourceHolder : IDisposable, IAsyncDisposable\n{\n private FileStream fs; // Compliant: disposed in Dispose/DisposeAsync methods\n\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open);\n }\n\n public void Dispose()\n {\n this.fs.Dispose();\n }\n\n public async ValueTask DisposeAsync()\n {\n await fs.DisposeAsync().ConfigureAwait(false);\n }\n\n public void WriteToFile(string path, string text)\n {\n using (var fs = new FileStream(path, FileMode.Open)) // Compliant: disposed at the end of the using block\n {\n var bytes = Encoding.UTF8.GetBytes(text);\n fs.Write(bytes, 0, bytes.Length);\n }\n }\n}\n\nAn IDisposable object should be disposed (there are some rare exceptions where not disposing is fine, most notably Task).\nIf a class has an IDisposable field, there can be two situations:
Dispose on it.In the second case, the safest way for the class to ensure Dispose is called is to call it in its own Dispose function,\nand therefore to be itself IDisposable. A class is considered to own an IDisposable field resource if it created the object\nreferenced by the field.
\npublic class ResourceHolder // Noncompliant; doesn't implement IDisposable\n{\n private FileStream fs; // This member is never Disposed\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open); // I create the FileStream, I'm owning it\n }\n public void CloseResource()\n {\n this.fs.Close();\n }\n}\n\n\npublic class ResourceHolder : IDisposable\n{\n private FileStream fs;\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open); // I create the FileStream, I'm owning it\n }\n public void CloseResource()\n {\n this.fs.Close();\n }\n public void Dispose()\n {\n this.fs.Dispose();\n }\n}\n\nreadonly fields can only be assigned in a class constructor. If a class has a field that’s not marked readonly but is\nonly set in the constructor, it could cause confusion about the field’s intended use. To avoid confusion, such fields should be marked\nreadonly to make their intended use explicit, and to prevent future maintainers from inadvertently changing their use.
Serializable attribute.partial classes.struct that are not primitive or pointer types are also ignored because of possible unwanted behavior.Mark the given field with the readonly modifier.
\npublic class Person\n{\n private int _birthYear; // Noncompliant\n\n Person(int birthYear)\n {\n _birthYear = birthYear;\n }\n}\n\n\npublic class Person\n{\n private readonly int _birthYear;\n\n Person(int birthYear)\n {\n _birthYear = birthYear;\n }\n}\n\nWhile the properties of a readonly\nreference type field can still be changed\nafter initialization, those of a readonly struct, cannot.
If the member could be either a class or a struct then assignment to its properties could be unreliable, working\nsometimes but not others.
There are two ways to fix this issue:
\nclass\ninterface IPoint\n{\n int X { get; set; }\n int Y { get; set; }\n}\n\nclass PointManager<T1, T2>\n where T1 : IPoint\n where T2 : IPoint\n{\n readonly T1 point1; // this could be a struct\n readonly T2 point2; // this could be a struct\n\n public PointManager(T1 point1, T2 point2)\n {\n this.point1 = point1;\n this.point2 = point2;\n }\n\n public void MovePoints(int newX)\n {\n point1.X = newX; //Noncompliant: if point is a struct, then nothing happened\n point2.X = newX; //Noncompliant: if point is a struct, then nothing happened\n }\n}\n\n\ninterface IPoint\n{\n int X { get; set; }\n int Y { get; set; }\n}\n\nclass PointManager<T1, T2>\n where T1 : IPoint\n where T2 : class, IPoint\n{\n readonly T1 point1; // this could be a struct\n readonly T2 point2; // this is a class\n\n public PointManager(T1 point1, T2 point2)\n {\n this.point1 = point1;\n this.point2 = point2;\n }\n\n public void MovePoints(int newX) // assignment to point1 has been removed\n {\n point2.X = newX; // Compliant: point2 is a class\n }\n}\n\nIt is possible in an IDisposable to call Dispose on class members from any method, but the contract of\nDispose is that it will clean up all unmanaged resources. Move disposing of members to some other method, and you risk resource\nleaks.
This rule also applies for disposable ref structs.
\n\npublic class ResourceHolder : IDisposable\n{\n private FileStream fs;\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open);\n }\n public void CloseResource()\n {\n this.fs.Close();\n }\n\n public void CleanUp()\n {\n this.fs.Dispose(); // Noncompliant; Dispose not called in class' Dispose method\n }\n\n public void Dispose()\n {\n // method added to satisfy demands of interface\n }\n}\n\n\npublic class ResourceHolder : IDisposable\n{\n private FileStream fs;\n public void OpenResource(string path)\n {\n this.fs = new FileStream(path, FileMode.Open);\n }\n public void CloseResource()\n {\n this.fs.Close();\n }\n\n public void Dispose()\n {\n this.fs.Dispose();\n }\n}\n\nIDisposable is an interface implemented by all types which need to\nprovide a mechanism for releasing unmanaged\nresources.
\nUnlike managed memory, which is taken care of by the
The interface declares a Dispose method, which the\nimplementer has to define.
\nThe method name Dispose should be used exclusively to implement IDisposable.Dispose to prevent any confusion.
It may be tempting to create a Dispose method for other purposes, but doing so will result in confusion and likely lead to problems in\nproduction.
Methods named Dispose and invoked from the IDisposable.Dispose implementation are not reported.
\npublic class GarbageDisposal : IDisposable\n{\n protected virtual void Dispose(bool disposing)\n {\n //...\n }\n public void Dispose()\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n}\n\nFirst, it is important to determine whether instances of the type defining the Dispose method should support the
The decision would be based on whether the instance can have unmanaged resources which have to be dealt with, upon destruction or earlier in the\nlifetime of the object.
\nThe Dispose pattern can help to take the\ndecision.
\nIf the type should not support the pattern, the Dispose method should be renamed to something which is different than\nDispose, but still relevant and possibly more specific to the context.
\npublic class GarbageDisposal\n{\n private int Dispose() // Noncompliant\n {\n // ...\n }\n}\n\n\npublic class GarbageDisposal : IDisposable\n{\n public void Dispose()\n {\n // ...\n }\n}\n\nor
\n\npublic class GarbageDisposal\n{\n private int Grind()\n {\n // ...\n }\n}\n\nIn C#, without constraints on a generic type parameter, both null can be misleading as value types, like struct, can never be null.
To avoid unexpected comparisons:
\n\nbool IsDefault<T>(T value)\n{\n if (value == null) // Noncompliant\n {\n // ...\n }\n}\n\n\nbool IsDefault<T>(T value)\n{\n if (EqualityComparer<T>.Default.Equals(value, default(T)))\n {\n // ...\n }\n}\n\nor
\n\nbool IsDefault<T>(T value) where T : class\n{\n if (value == null)\n {\n // ...\n }\n}\n\ndefault operatorThis rule addresses the issue of incomplete assertions that can occur when using certain test frameworks. Incomplete assertions can lead to tests\nthat do not effectively verify anything. The rule enforces the use of complete assertions in specific cases, namely:
\n\nstring actual = \"Using Fluent Assertions\";\nactual.Should(); // Noncompliant\n\n
\nstring actual = \"Using NFluent\";\nCheck.That(actual); // Noncompliant\n\n
\ncommand.Received(); // Noncompliant\n\n
In such cases, what is intended to be a test doesn’t actually verify anything.
\nFluent Assertions provides an interface for writing assertions, and it is important to ensure that Should() is properly\nused in conjunction with an assertion method.
\nstring actual = \"Hello World!\";\nactual.Should(); // Noncompliant\n\n
\nstring actual = \"Hello World!\";\nactual.Should().Contain(\"Hello\");\n\n
NFluent offers a syntax for assertions, and it’s important to follow Check.That() with an assertion method to complete\nthe assertion.
\nstring actual = \"Hello World!\";\nCheck.That(actual); // Noncompliant\n\n
\nstring actual = \"Hello World!\";\nCheck.That(actual).Contains(\"Hello\");\n\n
NSubstitute is a mocking framework, and Received() is used to verify that a specific method has been called. However,\ninvoking a method on the mock after calling Received() is necessary to ensure the complete assertion.
\ncommand.Received(); // Noncompliant\n\n
\ncommand.Received().Execute();\n\n
In the interests of readability, code that can be simplified should be simplified. To that end, there are several ways
Simplify the LINQ expressions:
\nOfType instead of using Where and the\n is operator, followed\n by a cast in a SelectAny instead of Where(element ⇒ [expression]).Any().Using Entity Framework may require enforcing client evaluations. Such queries should use ToArray() or\nToList() in the middle of a query chain.
\npublic void Foo(IEnumerable<Vehicle> seq, List<int> list)\n{\n var result1 = seq.Select(x => x as Car).Any(x => x != null); // Noncompliant; use OfType\n var result2 = seq.Select(x => x as Car).Any(x => x != null && x.HasOwner); // Noncompliant; use OfType before calling Any\n var result3 = seq.Where(x => x is Car).Select(x => x as Car); // Noncompliant; use OfType\n var result4 = seq.Where(x => x is Car).Select(x => (Car)x); // Noncompliant; use OfType\n var result5 = seq.Where(x => x.HasOwner).Any(); // Noncompliant; use Any([predicate])\n\n var num = list.Count(); // Noncompliant; use the Count property\n var arr = seq.ToList().ToArray(); // Noncompliant; ToList is not needed\n var count = seq.ToList().Count(x => x.HasOwner); // Noncompliant; ToList is not needed\n}\n\n\npublic void Foo(IEnumerable<Vehicle> seq, List<int> list)\n{\n var result1 = seq.OfType<Car>().Any();\n var result2 = seq.OfType<Car>().Any(x => x.HasOwner);\n var result3 = seq.OfType<Car>();\n var result4 = seq.OfType<Car>();\n var result5 = seq.Any(x => x.HasOwner);\n\n var num = list.Count;\n var arr = seq.ToArray();\n var count = seq.Count(x => x.HasOwner);\n}\n\nIn C#, the Object.ReferenceEquals method is\nused to compare two reference type\nvariables. If you use this method to compare two int,\nfloat, or bool you will not get the expected results because value type variables contain an instance of the type and not a\nreference to it.
Due to value type variables containing directly an instance of the type, they can’t have the same reference, and using\nObject.ReferenceEquals to compare them will always return false even if the compared variables have the same value.
When comparing value types, prefer using the Object.Equals.
Note that in the case of structure types, it\nis recommended to
\nusing System;\n\nstruct MyStruct\n{\n int valueA;\n int valueB;\n}\n\nstatic class MyClass\n{\n public static void Method(MyStruct struct1, MyStruct struct2)\n {\n if (Object.ReferenceEquals(struct1, struct2)) // Noncompliant: this will be always false\n {\n // ...\n }\n }\n}\n\n\nusing System;\n\nstruct MyStruct : IEquatable<MyStruct>\n{\n int valueA;\n int valueB;\n\n public bool Equals(MyStruct other) => valueA == other.valueA && valueB == other.valueB;\n\n public override bool Equals(object obj) => obj is MyStruct other && Equals(other);\n\n public override int GetHashCode() => HashCode.Combine(valueA, valueB);\n\n public static bool operator ==(MyStruct lhs, MyStruct rhs) => lhs.Equals(rhs);\n\n public static bool operator !=(MyStruct lhs, MyStruct rhs) => !(lhs == rhs);\n}\n\nstatic class MyClass\n{\n public static void Method(MyStruct struct1, MyStruct struct2)\n {\n if (struct1.Equals(struct2)) // Compliant: value are compared\n {\n // ...\n }\n }\n}\n\nObject.ReferenceEquals(Object,\n Object) MethodObject.Equals MethodWhen an object has a field annotated with ThreadStatic, that field is shared within a given thread, but unique across threads. Since a\nclass' static initializer is only invoked for the first thread created, it also means that only the first thread will have the expected initial\nvalues.
Instead, allow such fields to be initialized to their default values or make the initialization lazy.
\n\npublic class Foo\n{\n [ThreadStatic]\n public static object PerThreadObject = new object(); // Noncompliant. Will be null in all the threads except the first one.\n}\n\n\npublic class Foo\n{\n [ThreadStatic]\n public static object _perThreadObject;\n public static object PerThreadObject\n {\n get\n {\n if (_perThreadObject == null)\n {\n _perThreadObject = new object();\n }\n return _perThreadObject;\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S2996.json",
"content": "{\n \"title\": \"\\\"ThreadStatic\\\" fields should not be initialized\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"multi-threading\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2996\",\n \"sqKey\": \"S2996\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S2997.html",
"content": "When you use a using statement, the\ngoal is to ensure the correct disposal of an IDisposable\ninstance when the control leaves the using statement block.
If you return that IDisposable instance inside the block, using will dispose it before the caller can use it, likely\ncausing exceptions at runtime. You should either remove using statement or avoid returning the IDisposable in the\nusing statement block.
\npublic FileStream WriteToFile(string path, string text)\n{\n using (var fs = File.Create(path)) // Noncompliant: 'fs' is disposed at the end of the using scope\n {\n var bytes = Encoding.UTF8.GetBytes(text);\n fs.Write(bytes, 0, bytes.Length);\n return fs;\n }\n}\n\n\npublic FileStream WriteToFile(string path, string text)\n{\n var fs = File.Create(path);\n var bytes = Encoding.UTF8.GetBytes(text);\n fs.Write(bytes, 0, bytes.Length);\n return fs; // Compliant: 'fs' is not disposed once the end of the scope is reached and the caller can use it\n}\n\nWhen you annotate a field with the ThreadStatic\nattribute, it is an indication that the value of this field is unique for each thread. But if you don’t mark the field as static,\nthen the ThreadStatic attribute is ignored.
The ThreadStatic attribute should either be removed or replaced with the use of ThreadLocal<T> class, which gives a similar\nbehavior for non-static fields.
\npublic class MyClass\n{\n [ThreadStatic] // Noncompliant\n private int count = 0;\n\n // ...\n}\n\n\npublic class MyClass\n{\n private int count = 0;\n\n // ...\n}\n\nor
\n\npublic class MyClass\n{\n private readonly ThreadLocal<int> count = new ThreadLocal<int>();\n public int Count\n {\n get { return count.Value; }\n set { count.Value = value; }\n }\n // ...\n}\n\nAssigning a value to a static field in a constructor could cause unreliable behavior at runtime since it will change the value for all\ninstances of the class.
Instead remove the field’s static modifier, or initialize it statically.
\npublic class Person\n{\n private static DateTime dateOfBirth;\n private static int expectedFingers;\n\n public Person(DateTime birthday)\n {\n dateOfBirth = birthday; // Noncompliant; now everyone has this birthday\n expectedFingers = 10; // Noncompliant\n }\n}\n\n\npublic class Person\n{\n private DateTime dateOfBirth;\n private static int expectedFingers = 10;\n\n public Person(DateTime birthday)\n {\n this.dateOfBirth = birthday;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3010.json",
"content": "{\n \"title\": \"Static fields should not be updated in constructors\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3010\",\n \"sqKey\": \"S3010\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3011.html",
"content": "Altering or bypassing the accessibility of classes, methods, or fields through reflection violates the encapsulation principle. This can break the\ninternal contracts of the accessed target and lead to maintainability issues and runtime errors.
\nThis rule raises an issue when reflection is used to change the visibility of a class, method or field, and when it is used to directly update a\nfield value.
\n\nusing System.Reflection;\n\nType dynClass = Type.GetType(\"MyInternalClass\");\n// Noncompliant. Using BindingFlags.NonPublic will return non-public members\nBindingFlags bindingAttr = BindingFlags.NonPublic | BindingFlags.Static;\nMethodInfo dynMethod = dynClass.GetMethod(\"mymethod\", bindingAttr);\nobject result = dynMethod.Invoke(dynClass, null);\n\n
The compiler automatically initializes class fields, auto-properties and events to their default values before setting them with any initialization\nvalues, so there is no need to explicitly set a member to its default value. Further, under the logic that cleaner code is better code, it’s\nconsidered poor style to do so.
\n\nclass X\n{\n public int field = 0; // Noncompliant\n public object o = null; // Noncompliant\n public object MyProperty { get; set; } = null; // Noncompliant\n public event EventHandler MyEvent = null; // Noncompliant\n}\n\n\nclass X\n{\n public int field;\n public object o;\n public object MyProperty { get; set; }\n public event EventHandler MyEvent;\n}\n\nconst fields are ignored.
There’s no point in having a public member in a non-public type because objects that can’t access the type will never\nhave the chance to access the member.
This rule raises an issue when a type has methods, fields, or inner types with higher visibility than the type itself has.
\n\ninternal class MyClass\n{\n public static decimal PI = 3.14m; // Noncompliant\n\n public int GetOne() // Noncompliant\n {\n return 1;\n }\n\n protected record NestedType // Noncompliant: outer class is internal\n {\n public bool FlipCoin() // Noncompliant: outer class is internal\n {\n return false;\n }\n // ...\n }\n}\n\n\npublic class MyClass // Class visibility upgrade makes members compliant\n{\n public static decimal PI = 3.14m;\n\n public int GetOne()\n {\n return 1;\n }\n\n protected record NestedType\n {\n public bool FlipCoin() // Outer type is public\n {\n return false;\n }\n // ...\n }\n}\n\nUser defined operators need to be public:
\n\npublic static implicit operator byte(MyClass a) => 1; // Compliant\npublic static explicit operator MyClass(byte a) => new MyClass(a); // Compliant\n\n
Nested types, even if private, can be used and inherited in the parent type. In this case, the visibility of the outer type is considered.
\n\ninternal class MyClass\n{\n private class NestedClass\n {\n public int PublicProperty { get; } // Noncompliant: should be internal\n protected internal int ProtectedInternalProperty { get; } // Compliant: can be used in `InternalsVisibleTo` assemblies\n internal int InternalProperty { get; } // Compliant: can be used in `InternalsVisibleTo` assemblies\n protected int ProtectedProperty { get; } // Compliant: can be used in derived type\n private protected int PrivateProtectedProperty { get; } // Compliant: can be used in derived type\n private int PrivateProperty { get; }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3059.json",
"content": "{\n \"title\": \"Types should not have members with visibility set higher than the type\\u0027s visibility\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3059\",\n \"sqKey\": \"S3059\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3060.html",
"content": "One of the possible ways of performing food is Pizza.
The is operator is often used before a direct
\nif (food is Pizza pizza)\n\n
There’s no valid reason to test this with is. The only plausible explanation for such a test is that you’re executing\ncode in a parent class conditionally based on the kind of child class this is.
\npublic class Food\n{\n public void DoSomething()\n {\n if (this is Pizza) // Noncompliant\n {\n // Code specific to Pizza...\n }\n }\n}\n\nHowever, code that’s specific to a child class should be in that child class, not in the parent.
\nOne way is to take advantage of the object-orientation of\nC# and use polymorphism.
\nFor example, when simple method polymorphism is not enough because it is necessary to reuse multiple sections of the parent method, the
\npublic class Food\n{\n public void DoSomething()\n {\n // Code shared by all Food...\n if (this is Pizza) // Noncompliant\n {\n // Code specific to Pizza...\n }\n }\n}\n\n\npublic class Food\n{\n public virtual void DoSomething()\n {\n // Code shared by all Food...\n }\n}\n\npublic class Pizza : Food\n{\n public override void DoSomething()\n {\n base.DoSomething();\n // Code specific to Pizza...\n }\n}\n\nStringBuilder instances that never build a string clutter the code and worse are a drag on performance. Either they\nshould be removed, or the missing ToString() call should be added.
\npublic void DoSomething(List<string> strings) {\n var sb = new StringBuilder(); // Noncompliant\n sb.Append(\"Got: \");\n foreach(var str in strings) {\n sb.Append(str).Append(\", \");\n // ...\n }\n}\n\n\npublic void DoSomething(List<string> strings) {\n foreach(var str in strings) {\n // ...\n }\n}\n\nor
\n\npublic void DoSomething(List<string> strings) {\n var sb = new StringBuilder();\n sb.Append(\"Got: \");\n foreach(var str in strings) {\n sb.Append(str).Append(\", \");\n // ...\n }\n logger.LogInformation(sb.ToString());\n}\n\nNo issue is reported when StringBuilder is:
sb.CopyTo(), sb.GetChunks(), sb.Length, or sb[index].ToString() invocation there.var sb = GetStringBuilder();).An async method with a\nvoid return type does not follow the Task or Task<TResult>
Doing so prevents control over the asynchronous\nexecution, such as:
\nEventHandler delegate signature \n Using void for EventHandler is compliant with the TAP model.\n \npublic async void button1_Click(object sender, EventArgs e)\n{\n await DoSomethingAsync();\n}\nOn[A-Z]\\w* pattern Some frameworks may not use the same EventHandler method signature.\n \npublic async void OnClick(EventContext data)\n{\n await DoSomethingAsync();\n}\nUpdate the return type of the method from void to Task.
\nprivate async void ThrowExceptionAsync() // Noncompliant: async method return type is 'void'\n{\n throw new InvalidOperationException();\n}\n\npublic void Method()\n{\n try\n {\n ThrowExceptionAsync();\n }\n catch (Exception)\n {\n // The exception is never caught here\n throw;\n }\n}\n\n\nprivate async Task ThrowExceptionAsync() // Compliant: async method return type is 'Task'\n{\n throw new InvalidOperationException();\n}\n\npublic async Task Method()\n{\n try\n {\n await ThrowExceptionAsync();\n }\n catch (Exception)\n {\n // The exception is caught here\n throw;\n }\n}\n\nasync (C#\n Reference)Task ClassTask<TResult>\n ClassEventHandler DelegateThere’s no point in chaining multiple OrderBy calls in a LINQ; only the last one will be reflected in the result because each\nsubsequent call completely reorders the list. Thus, calling OrderBy multiple times is a performance issue as well, because all of the\nsorting will be executed, but only the result of the last sort will be kept.
Instead, use ThenBy for each call after the first.
\nvar x = personList\n .OrderBy(person => person.Age)\n .OrderBy(person => person.Name) // Noncompliant\n .ToList(); // x is sorted by Name, not sub-sorted\n\n
\nvar x = personList\n .OrderBy(person => person.Age)\n .ThenBy(person => person.Name)\n .ToList();\n\n
| Method | \nRuntime | \nMean | \nStdDev | \nAllocated | \n
|---|---|---|---|---|
| \n OrderByAge \n | \n \n .NET 9.0 \n | \n \n 12.84 ms \n | \n \n 0.804 ms \n | \n \n 1.53 MB \n | \n
| \n OrderByAgeOrderBySize \n | \n \n .NET 9.0 \n | \n \n 24.08 ms \n | \n \n 0.267 ms \n | \n \n 3.05 MB \n | \n
| \n OrderByAgeThenBySize \n | \n \n .NET 9.0 \n | \n \n 18.58 ms \n | \n \n 0.747 ms \n | \n \n 1.91 MB \n | \n
| \n | \n | \n | \n | \n |
| \n OrderByAge \n | \n \n .NET Framework 4.8.1 \n | \n \n 22.99 ms \n | \n \n 0.228 ms \n | \n \n 1.53 MB \n | \n
| \n OrderByAgeOrderBySize \n | \n \n .NET Framework 4.8.1 \n | \n \n 44.90 ms \n | \n \n 0.581 ms \n | \n \n 4.3 MB \n | \n
| \n OrderByAgeThenBySize \n | \n \n .NET Framework 4.8.1 \n | \n \n 31.72 ms \n | \n \n 0.402 ms \n | \n \n 1.91 MB \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\npublic class Person\n{\n public string Name { get; set; }\n public int Age { get; set; }\n public int Size { get; set; }\n}\n\nprivate Random random = new Random(1);\nprivate Consumer consumer = new Consumer();\nprivate Person[] array;\n\n[Params(100_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n array = Enumerable.Range(0, N).Select(x => new Person\n {\n Name = Path.GetRandomFileName(),\n Age = random.Next(0, 100),\n Size = random.Next(0, 200)\n }).ToArray();\n}\n\n[Benchmark(Baseline = true)]\npublic void OrderByAge() =>\n array.OrderBy(x => x.Age).Consume(consumer);\n\n[Benchmark]\npublic void OrderByAgeOrderBySize() =>\n array.OrderBy(x => x.Age).OrderBy(x => x.Size).Consume(consumer);\n\n[Benchmark]\npublic void OrderByAgeThenBySize() =>\n array.OrderBy(x => x.Age).ThenBy(x => x.Size).Consume(consumer);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\nIntel Core Ultra 7 165H, 1 CPU, 22 logical and 16 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S3169.json", "content": "{\n \"title\": \"Multiple \\\"OrderBy\\\" calls should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3169\",\n \"sqKey\": \"S3169\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S3172.html", "content": "
In C#, delegates can be added together to chain their execution, and subtracted to remove their execution from the chain.
\nSubtracting a chain of delegates from another one might yield unexpected results as shown hereunder - and is likely to be a bug.
\n\nMyDelegate first, second, third, fourth;\nfirst = () => Console.Write(\"1\");\nsecond = () => Console.Write(\"2\");\nthird = () => Console.Write(\"3\");\nfourth = () => Console.Write(\"4\");\n\nMyDelegate chain1234 = first + second + third + fourth; // Compliant - chain sequence = \"1234\"\nMyDelegate chain12 = chain1234 - third - fourth; // Compliant - chain sequence = \"12\"\n\n\nMyDelegate chain14 = first + fourth; // creates a new MyDelegate instance which is a list under the covers\nMyDelegate chain23 = chain1234 - chain14; // Noncompliant; (first + fourth) doesn't exist in chain1234\n\n\n// The chain sequence of \"chain23\" will be \"1234\" instead of \"23\"!\n// Indeed, the sequence \"1234\" does not contain the subsequence \"14\", so nothing is subtracted\n// (but note that \"1234\" contains both the \"1\" and \"4\" subsequences)\nchain23 = chain1234 - (first + fourth); // Noncompliant\n\nchain23(); // will print \"1234\"!\n\n
\nMyDelegate chain23 = chain1234 - first - fourth; // Compliant - \"1\" is first removed, followed by \"4\"\n\nchain23(); // will print \"23\"\n\n\n" }, { "path": "analyzers/rspec/cs/S3172.json", "content": "{\n \"title\": \"Delegates should not be subtracted\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"30min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3172\",\n \"sqKey\": \"S3172\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3215.html", "content": "
Needing to cast from an interface to a concrete type indicates that something is wrong with the abstractions in use, likely that\nsomething is missing from the interface. Instead of casting to a discrete type, the missing functionality should be added to the\ninterface. Otherwise there is a risk of runtime exceptions.
\npublic interface IMyInterface\n{\n void DoStuff();\n}\n\npublic class MyClass1 : IMyInterface\n{\n public int Data { get { return new Random().Next(); } }\n\n public void DoStuff()\n {\n // TODO...\n }\n}\n\npublic static class DowncastExampleProgram\n{\n static void EntryPoint(IMyInterface interfaceRef)\n {\n MyClass1 class1 = (MyClass1)interfaceRef; // Noncompliant\n int privateData = class1.Data;\n\n class1 = interfaceRef as MyClass1; // Noncompliant\n if (class1 != null)\n {\n // ...\n }\n }\n}\n\nCasting to object doesn’t raise an issue, because it can never fail.
\nstatic void EntryPoint(IMyInterface interfaceRef)\n{\n var o = (object)interfaceRef;\n ...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3215.json",
"content": "{\n \"title\": \"\\\"interface\\\" instances should not be cast to concrete types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1h\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-3215\",\n \"sqKey\": \"S3215\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3216.html",
"content": "After an awaited Task has executed, you can continue execution in the original, calling thread or any arbitrary thread.\nUnless the rest of the code needs the context from which the Task was spawned, Task.ConfigureAwait(false) should be used to\nkeep execution in the Task thread to avoid the need for context switching and the possibility of deadlocks.
This rule raises an issue when code in a class library targeting .Net Framework awaits a Task and continues execution in\nthe original calling thread.
The rule does not raise for .Net Core libraries as there is no SynchronizationContext in .Net Core.
\nvar response = await httpClient.GetAsync(url); // Noncompliant\n\n
\nvar response = await httpClient.GetAsync(url).ConfigureAwait(false);\n\n\n" }, { "path": "analyzers/rspec/cs/S3216.json", "content": "{\n \"title\": \"\\\"ConfigureAwait(false)\\\" should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"multi-threading\",\n \"async-await\",\n \"suspicious\",\n \"performance\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-3216\",\n \"sqKey\": \"S3216\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3217.html", "content": "
The foreach\nstatement was introduced in the C# language prior to generics to make it easier to work with the non-generic collections available at that time such\nas ArrayList. The foreach statements allow you to\ndowncast elements of a collection of Objects to any other type.
The problem is that to achieve the cast, the foreach statements silently perform
C# code iterating on generic collections or arrays should not rely on foreach statement’s silent explicit\nconversions.
\npublic class Fruit { }\npublic class Orange : Fruit { }\npublic class Apple : Fruit { }\n\nclass MyTest\n{\n public void Test()\n {\n var fruitBasket = new List<Fruit>();\n fruitBasket.Add(new Orange());\n fruitBasket.Add(new Orange());\n fruitBasket.Add(new Apple());\n\n foreach (Orange orange in fruitBasket) // Noncompliant\n {\n //...\n }\n }\n}\n\n\npublic class Fruit { }\npublic class Orange : Fruit { }\npublic class Apple : Fruit { }\n\nclass MyTest\n{\n public void Test()\n {\n var fruitBasket = new List<Fruit>();\n fruitBasket.Add(new Orange());\n fruitBasket.Add(new Orange());\n fruitBasket.Add(new Apple());\n\n foreach (Orange orange in fruitBasket.OfType<Orange>())\n {\n //...\n }\n }\n}\n\nThe rule ignores iterations on collections of objects. This includes legacy code that uses ArrayList. Furthermore, the\nrule does not report on cases when user-defined conversions are being called.
Naming the members of an inner class the same as the static members of its enclosing class is possible but generally considered a bad practice.\nThat’s because maintainers may be confused about which members are being used in a given context. Instead the inner class member should be given\ndistinct and descriptive name, and all references to it should be updated accordingly.
\n\nclass Outer\n{\n public static int A;\n\n public class Inner\n {\n public int A; // Noncompliant\n\n public int MyProp\n {\n get => A; // Returns inner A. Was that intended?\n }\n }\n}\n\nHere’s an example of compliant code after renaming the inner class member, this way the property will return the Outer A:
\nclass Outer\n{\n public static int A;\n\n public class Inner\n {\n public int B; // Compliant\n\n public int MyProp\n {\n get => A; // Returns outer A\n }\n }\n}\n\nOr if you want to reference the Inner A field:
\nclass Outer\n{\n public static int B;\n\n public class Inner\n {\n public int A; // Compliant\n\n public int MyProp\n {\n get => A; // Returns inner A\n }\n }\n}\n\nThe rules for method resolution are complex and perhaps not properly understood by all coders. The params keyword can make method\ndeclarations overlap in non-obvious ways, so that slight changes in the argument types of an invocation can resolve to different methods.
This rule raises an issue when an invocation resolves to a method declaration with params, but could also resolve to another\nnon-params method too.
\npublic class MyClass\n{\n private void Format(string a, params object[] b) { }\n\n private void Format(object a, object b, object c) { }\n}\n\n// ...\nMyClass myClass = new MyClass();\n\nmyClass.Format(\"\", null, null); // Noncompliant, resolves to the first Format with params, but was that intended?\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3220.json",
"content": "{\n \"title\": \"Method calls should not resolve ambiguously to overloads with \\\"params\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3220\",\n \"sqKey\": \"S3220\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3234.html",
"content": "GC.SuppressFinalize asks the Common Language Runtime not to call the finalizer of an object. This is useful when implementing the\ndispose pattern where object finalization is already handled in IDisposable.Dispose. However, it has no effect if there is no finalizer\ndefined in the object’s type, so using it in such cases is just confusing.
This rule raises an issue when GC.SuppressFinalize is called for objects of sealed types without a finalizer.
Note: {rule:csharpsquid:S3971} is a stricter version of this rule. Typically it makes sense to activate only one of these 2\nrules.
\n\nsealed class MyClass\n{\n public void Method()\n {\n ...\n GC.SuppressFinalize(this); //Noncompliant\n }\n}\n\n\nsealed class MyClass\n{\n public void Method()\n {\n ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3234.json",
"content": "{\n \"title\": \"\\\"GC.SuppressFinalize\\\" should not be invoked for types without destructors\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\",\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3234\",\n \"sqKey\": \"S3234\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3235.html",
"content": "Redundant parentheses are simply wasted keystrokes, and should be removed.
\n\n[MyAttribute()] //Noncompliant\nclass MyClass\n{\n public int MyProperty { get; set; }\n public static MyClass CreateNew(int propertyValue)\n {\n return new MyClass() //Noncompliant\n {\n MyProperty = propertyValue\n };\n }\n}\n\n\n[MyAttribute]\nclass MyClass\n{\n public int MyProperty { get; set; }\n public static MyClass CreateNew(int propertyValue)\n {\n return new MyClass\n {\n MyProperty = propertyValue\n };\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3235.json",
"content": "{\n \"title\": \"Redundant parentheses should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\",\n \"finding\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3235\",\n \"sqKey\": \"S3235\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3236.html",
"content": "Caller information attributes: CallerFilePathAttribute, CallerLineNumberAttribute, and\nCallerArgumentExpressionAttribute provide a way to get information about the caller of a method through optional parameters. But the\narguments for these optional parameters are only generated if they are not explicitly defined in the call. Thus, specifying the argument values\ndefeats the purpose of the attributes.
\nvoid TraceMessage(string message,\n [CallerFilePath] string filePath = null,\n [CallerLineNumber] int lineNumber = 0)\n{\n /* ... */\n}\n\nvoid MyMethod()\n{\n TraceMessage(\"my message\", \"A.B.C.Foo.cs\", 42); // Noncompliant\n}\n\n\nvoid TraceMessage(string message,\n [CallerFilePath] string filePath = \"\",\n [CallerLineNumber] int lineNumber = 0)\n{\n /* ... */\n}\n\nvoid MyMethod()\n{\n TraceMessage(\"my message\");\n}\n\nCallerMemberName is not checked to avoid False-Positives with WPF/UWP applications.System.Diagnostics.Debug.Assert is excluded as a custom message from the developer is sometimes preferred as an explanation of the\n failed assertion.When you need to get external input for set and init methods defined for properties and indexers or for\nremove and add methods for events, you should always get this input throught the value contextual keyword.
The contextual keyword value is similar to an input parameter of a method; it references the value that the client code is attempting\nto assign to the property, indexer or event.
The keyword value holds the value the accessor was called with. Not using it means that the accessor ignores the caller’s intent which\ncould cause unexpected results at runtime.
\nprivate int count;\npublic int Count\n{\n get { return count; }\n set { count = 42; } // Noncompliant\n}\n\n\nprivate int count;\npublic int Count\n{\n get { return count; }\n set { count = value; }\n}\n\nThis rule doesn’t raise an issue when the setter is empty and part of the implementation of an interface. The assumption is that this\npart of the interface is not meaningful to that particular implementation. A good example of that would be a \"sink\" logger that discards any logs.
In the interests of keeping code clean, the simplest possible conditional syntax should be used. That means
\n??= operator for a self-assign-if-not-null operation,?? operator for an assign-if-not-null operation, and?: for assignment to a single variable.\nobject a = null, b = null, x;\n\nif (a != null) // Noncompliant; needlessly verbose\n{\n x = a;\n}\nelse\n{\n x = b;\n}\n\nx = a != null ? a : b; // Noncompliant; better but could still be simplified\n\nx = (a == null) ? new object() : a; // Noncompliant\n\nif (condition) // Noncompliant\n{\n x = a;\n}\nelse\n{\n x = b;\n}\n\nif (a == null) // Noncompliant\n a = new object();\n\nvar y = null ?? new object(); // Noncompliant\n\na = a ?? new object(); // Noncompliant for C# 8\n\n\nobject x;\n\nx = a ?? b;\nx = a ?? b;\nx = a ?? new object();\nx = condition ? a : b;\na ??= new object();\nvar y = new object();\na ??= new object();\n\n\n" }, { "path": "analyzers/rspec/cs/S3240.json", "content": "{\n \"title\": \"The simplest possible condition syntax should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3240\",\n \"sqKey\": \"S3240\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S3241.html", "content": "
Private methods are intended for use only within their scope. If these methods return values that are not utilized by any calling functions, it\nindicates that the return operation is unnecessary. Removing such returns can enhance both efficiency and code clarity.
\n\nclass SomeClass\n{\n private int PrivateMethod() => 42;\n\n public void PublicMethod()\n {\n PrivateMethod(); // Noncompliant: the result of PrivateMethod is not used\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3241.json",
"content": "{\n \"title\": \"Methods should not return values that are never used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"design\",\n \"unused\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3241\",\n \"sqKey\": \"S3241\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3242.html",
"content": "When a derived type is used as a parameter instead of the base type, it limits the uses of the method. If the additional functionality that is\nprovided in the derived type is not required then that limitation isn’t required, and should be removed.
\nThis rule raises an issue when a method declaration includes a parameter that is a derived type and accesses only members of the base type.
\n\nusing System;\nusing System.IO;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void ReadStream(FileStream stream) // Noncompliant: Uses only System.IO.Stream methods\n {\n int a;\n while ((a = stream.ReadByte()) != -1)\n {\n // Do something.\n }\n }\n }\n}\n\n\nusing System;\nusing System.IO;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void ReadStream(Stream stream)\n {\n int a;\n while ((a = stream.ReadByte()) != -1)\n {\n // Do something.\n }\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3242.json",
"content": "{\n \"title\": \"Method parameters should be declared with base types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3242\",\n \"sqKey\": \"S3242\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3244.html",
"content": "When working with anonymous\nfunctions, it is important to keep in mind that each time you create one, it is a completely new instance.
\nIn this example, even though the same lambda expression is used, the expressions are stored separately in the memory and are therefore not equal or\nthe same.
\n\nFunc<int, int> lambda1 = x => x + 1;\nFunc<int, int> lambda2 = x => x + 1;\n\nvar result = lambda1 == lambda2; // result is false here\n\n
This is even more true when working with events since they\nare multicast\ndelegates that offer ways of
Instead, store the callback to a variable or a named method and use the variable or method to subscribe and unsubscribe.
\nStore the callback to a variable or a named method and use the variable or method to subscribe and unsubscribe.
\n\nevent EventHandler myEvent;\n\nvoid DoWork()\n{\n myEvent += (s, e) => Console.WriteLine($\"Event raised with sender {s} and arguments {e}!\");\n // ...\n myEvent -= (s, e) => Console.WriteLine($\"Event raised with sender {s} and arguments {e}!\"); // Noncompliant: this callback was never subscribed\n}\n\n\nevent EventHandler myEvent;\nvoid LogEvent(object s, EventArgs e) => Console.WriteLine($\"Event raised with sender {s} and arguments {e}!\");\n\nvoid DoWork()\n{\n myEvent += LogEvent;\n // ...\n myEvent -= LogEvent; // Compliant: LogEvent points to the same callback used for subscribing\n}\n\nIn the interests of making code as usable as possible, interfaces and delegates with generic parameters should use the out and\nin modifiers when possible to make the interfaces and delegates covariant and contravariant, respectively.
The out keyword can be used when the type parameter is used only as a return type in the interface or delegate. Doing so makes the\nparameter covariant, and allows interface and delegate instances created with a sub-type to be used as instances created with a base type. The most\nnotable example of this is IEnumerable<out T>, which allows the assignment of an IEnumerable<string> instance to\nan IEnumerable<object> variable, for instance.
The in keyword can be used when the type parameter is used only as a method parameter in the interface or a parameter in the delegate.\nDoing so makes the parameter contravariant, and allows interface and delegate instances created with a base type to be used as instances created with\na sub-type. I.e. this is the inversion of covariance. The most notable example of this is the Action<in T> delegate, which allows\nthe assignment of an Action<object> instance to a Action<string> variable, for instance.
\ninterface IConsumer<T> // Noncompliant\n{\n bool Eat(T fruit);\n}\n\n\ninterface IConsumer<in T>\n{\n bool Eat(T fruit);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3246.json",
"content": "{\n \"title\": \"Generic type parameters should be co\\/contravariant when possible\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"MODULAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3246\",\n \"sqKey\": \"S3246\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3247.html",
"content": "In C#, the is\ntype testing operator can be used to check if the run-time type of an object is compatible with a given type. If the object is not null, then the\nis operator performs a cast, and so performing another cast following the check result is redundant.
This can impact:
\nUse pattern macthing to perform the check\nand retrieve the cast result.
\n\nif (x is Fruit) // Noncompliant\n{\n var f = (Fruit)x; // or x as Fruit\n // ...\n}\n\n\nif (x is Fruit fruit)\n{\n // ...\n}\n\nis, as, typeof and casts| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n IsPattern_Class \n | \n \n .NET 9.0 \n | \n \n 176.48 ns \n | \n \n 0.765 ns \n | \n
| \n IsWithCast_Class \n | \n \n .NET 9.0 \n | \n \n 246.12 ns \n | \n \n 22.391 ns \n | \n
| \n | \n | \n | \n |
| \n IsPattern_Class \n | \n \n .NET Framework 4.8.1 \n | \n \n 325.11 ns \n | \n \n 14.435 ns \n | \n
| \n IsWithCast_Class \n | \n \n .NET Framework 4.8.1 \n | \n \n 311.22 ns \n | \n \n 11.145 ns \n | \n
| \n | \n | \n | \n |
| \n IsPattern_Interface \n | \n \n .NET 9.0 \n | \n \n 26.77 ns \n | \n \n 1.123 ns \n | \n
| \n IsWithCast_Interface \n | \n \n .NET 9.0 \n | \n \n 26.45 ns \n | \n \n 2.115 ns \n | \n
| \n | \n | \n | \n |
| \n IsPattern_Interface \n | \n \n .NET Framework 4.8.1 \n | \n \n 119.80 ns \n | \n \n 5.411 ns \n | \n
| \n IsWithCast_Interface \n | \n \n .NET Framework 4.8.1 \n | \n \n 119.33 ns \n | \n \n 4.380 ns \n | \n
| \n | \n | \n | \n |
| \n IsPattern_ValueType \n | \n \n .NET 9.0 \n | \n \n 22.58 ns \n | \n \n 1.161 ns \n | \n
| \n IsWithCast_ValueType \n | \n \n .NET 9.0 \n | \n \n 19.41 ns \n | \n \n 2.675 ns \n | \n
| \n | \n | \n | \n |
| \n IsPattern_ValueType \n | \n \n .NET Framework 4.8.1 \n | \n \n 39.66 ns \n | \n \n 0.645 ns \n | \n
| \n IsWithCast_ValueType \n | \n \n .NET Framework 4.8.1 \n | \n \n 41.34 ns \n | \n \n 0.462 ns \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate Random random = new Random(1);\n\nprivate object ReturnSometimes<T>() where T : new() =>\n random.Next(2) switch\n {\n 0 => new T(),\n 1 => new object(),\n };\n\n[BenchmarkCategory(\"ValueType\"), Benchmark(Baseline = true)]\npublic int IsPattern_ValueType()\n{\n var i = ReturnSometimes<int>();\n return i is int d\n ? d\n : default;\n}\n\n[BenchmarkCategory(\"ValueType\"), Benchmark]\npublic int IsWithCast_ValueType()\n{\n var i = ReturnSometimes<int>();\n return i is int\n ? (int)i\n : default;\n}\n\n[BenchmarkCategory(\"Class\"), Benchmark(Baseline = true)]\npublic DuplicateCasts IsPattern_Class()\n{\n var i = ReturnSometimes<DuplicateCasts>();\n return i is DuplicateCasts d\n ? d\n : default;\n}\n\n[BenchmarkCategory(\"Class\"), Benchmark]\npublic DuplicateCasts IsWithCast_Class()\n{\n var i = ReturnSometimes<DuplicateCasts>();\n return i is DuplicateCasts\n ? (DuplicateCasts)i\n : default;\n}\n\n[BenchmarkCategory(\"Interface\"), Benchmark(Baseline = true)]\npublic IReadOnlyList<int> IsPattern_Interface()\n{\n var i = ReturnSometimes<List<int>>();\n return i is IReadOnlyList<int> d\n ? d\n : default;\n}\n\n[BenchmarkCategory(\"Interface\"), Benchmark]\npublic IReadOnlyList<int> IsWithCast_Interface()\n{\n var i = ReturnSometimes<List<int>>();\n return i is IReadOnlyList<int>\n ? (IReadOnlyList<int>)i\n : default;\n}\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 10 (10.0.19045.5247/22H2/2022Update)\nIntel Core Ultra 7 165H, 1 CPU, 22 logical and 16 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n .NET 9.0 : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9282.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S3247.json", "content": "{\n \"title\": \"Duplicate casts should not be made\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3247\",\n \"sqKey\": \"S3247\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3249.html", "content": "
Making a base call when overriding a method is generally a good idea, but not in the case of GetHashCode and Equals for classes that directly extend Object.\nThese methods are based on the object’s reference, meaning that no two objects that use those base methods can be equal or have the same\nhash.
This rule doesn’t report on guard conditions checking for reference equality. For example:
\n\npublic override bool Equals(object obj)\n{\n if (base.Equals(obj)) // Compliant, it's a guard condition.\n {\n return true;\n }\n ...\n}\n\n\nvar m1 = new MyClass(2);\nvar m2 = new MyClass(2);\n\nm1.Equals(m2) // False\nm1.GetHashCode(); // 43942919\nm2.GetHashCode(); // 59941935\n\nclass MyClass\n{\n private readonly int x;\n public MyClass(int x) =>\n this.x = x;\n\n public override bool Equals(Object obj) =>\n base.Equals();\n\n public override int GetHashCode() =>\n x.GetHashCode() ^ base.GetHashCode(); // Noncompliant, base.GetHashCode returns a code based on the objects reference\n}\n\n\nvar m1 = new MyClass(2);\nvar m2 = new MyClass(2);\n\nm1.Equals(m2) // True\nm1.GetHashCode(); // 2\nm2.GetHashCode(); // 2\n\nclass MyClass\n{\n private readonly int x;\n public MyClass(int x) =>\n this.x = x;\n\n public override bool Equals(Object obj) =>\n this.x == ((MyClass)obj).x;\n\n public override int GetHashCode() =>\n x.GetHashCode()\n}\n\npartial methods allow an increased degree of flexibility in programming a system. Hooks can be added to generated code by invoking\nmethods that define their signature, but might not have an implementation yet. But if the implementation is still missing when the code makes it to\nproduction, the compiler silently removes the call. In the best case scenario, such calls simply represent cruft, but in they worst case they are\ncritical, missing functionality, the loss of which will lead to unexpected results at runtime.
This rule raises an issue for partial methods for which no implementation can be found in the assembly.
\n\npartial class C\n{\n partial void M(); //Noncompliant\n\n void OtherM()\n {\n M(); //Noncompliant. Will be removed.\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3251.json",
"content": "{\n \"title\": \"Implementations should be provided for \\\"partial\\\" methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3251\",\n \"sqKey\": \"S3251\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3253.html",
"content": "Since the compiler will automatically invoke the base type’s no-argument constructor, there’s no need to specify its invocation explicitly. Also,\nwhen only a single public parameterless constructor is defined in a class, then that constructor can be removed because the compiler\nwould generate it automatically. Similarly, empty static constructors and empty destructors are also wasted keystrokes.
\nclass X\n{\n public X() { } // Noncompliant\n static X() { } // Noncompliant\n ~X() { } // Noncompliant\n\n ...\n}\n\nclass Y : X\n{\n public Y(int parameter) : base() // Noncompliant\n {\n /* does something with the parameter */\n }\n}\n\n\nclass X\n{\n ...\n}\n\nclass Y : X\n{\n public Y(int parameter)\n {\n /* does something with the parameter */\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3253.json",
"content": "{\n \"title\": \"Constructor and destructor declarations should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3253\",\n \"sqKey\": \"S3253\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3254.html",
"content": "Specifying the default parameter values in a method call is redundant. Such values should be omitted in the interests of readability.
\n\npublic void M(int x, int y=5, int z = 7) { /* ... */ }\n\n// ...\nM(1, 5); // Noncompliant, y has the default value\nM(1, z: 7); // Noncompliant, z has the default value\n\n\npublic void M(int x, int y=5, int z = 7) { /* ... */ }\n\n// ...\nM(1);\nM(1);\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3254.json",
"content": "{\n \"title\": \"Default parameter values should not be passed as arguments\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3254\",\n \"sqKey\": \"S3254\",\n \"scope\": \"Main\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3256.html",
"content": "Using string.Equals to determine if a string is empty is significantly slower than using string.IsNullOrEmpty() or\nchecking for string.Length == 0. string.IsNullOrEmpty() is both clear and concise, and therefore preferred to laborious,\nerror-prone, manual null- and emptiness-checking.
\n\"\".Equals(name); // Noncompliant\n!name.Equals(\"\"); // Noncompliant\nname.Equals(string.Empty); // Noncompliant\n\n
\nname != null && name.Length > 0 // Compliant but more error prone\n!string.IsNullOrEmpty(name)\nstring.IsNullOrEmpty(name)\n\n\n" }, { "path": "analyzers/rspec/cs/S3256.json", "content": "{\n \"title\": \"\\\"string.IsNullOrEmpty\\\" should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3256\",\n \"sqKey\": \"S3256\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3257.html", "content": "
In C#, the type of a variable can often be inferred by the compiler. The use of the [var keyword](
Additionally, initializations providing the default value can also be omitted, helping to make the code more concise and readable.
\nUnnecessarily verbose declarations and initializations should be simplified. Specifically, the following should be omitted when they can be\ninferred:
\nnew DelegateTypenew Nullable<Type>Remove any unneeded code. C# provides many features designed to help you write more concise code.
\n\nvar l = new List<int>() {}; // Noncompliant, {} can be removed\nvar o = new object() {}; // Noncompliant, {} can be removed\n\nvar ints = new int[] {1, 2, 3}; // Noncompliant, int can be omitted\nints = new int[3] {1, 2, 3}; // Noncompliant, the size specification can be removed\n\nint? i = new int?(5); // Noncompliant new int? could be omitted, it can be inferred from the declaration, and there's implicit conversion from T to T?\nvar j = new int?(5);\n\nFunc<int, int> f1 = (int i) => 1; //Noncompliant, can be simplified\n\nclass Class\n{\n private event EventHandler MyEvent;\n\n public Class()\n {\n MyEvent += new EventHandler((a,b)=>{ }); // Noncompliant, needlessly verbose\n }\n}\n\n\nvar l = new List<int>();\nvar o = new object();\n\nvar ints = new [] {1, 2, 3};\nints = new [] {1, 2, 3};\n\nint? i = 5;\nvar j = new int?(5);\n\nFunc<int, int> f1 = (i) => 1;\n\nclass Class\n{\n private event EventHandler MyEvent;\n\n public Class()\n {\n MyEvent += (a,b)=>{ };\n }\n}\n\nClasses and records with either private or file access modifiers aren’t visible outside of their assemblies or files, so\nif they’re not extended inside their scope, they should be made explicitly non-extensible with the addition of the sealed keyword.
We measured at least 4x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
The code can be improved by adding the sealed keyword in front of the class or record types that have no\ninheritors.
\nprivate class MyClass // Noncompliant\n{\n // ...\n}\n\nprivate record MyRecord // Noncompliant\n{\n // ...\n}\n\n\nfile class MyClass // Noncompliant\n{\n // ...\n}\n\nfile record MyRecord // Noncompliant\n{\n // ...\n}\n\n\nprivate sealed class MyClass\n{\n // ...\n}\n\nprivate sealed record MyRecord\n{\n // ...\n}\n\n\nfile sealed class MyClass\n{\n // ...\n}\n\nfile sealed record MyRecord\n{\n // ...\n}\n\nsealed keyword| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n UnsealedType \n | \n \n .NET 5.0 \n | \n \n 918.7 us \n | \n \n 10.72 us \n | \n
| \n SealedType \n | \n \n .NET 5.0 \n | \n \n 231.2 us \n | \n \n 3.20 us \n | \n
| \n UnsealedType \n | \n \n .NET 6.0 \n | \n \n 867.9 us \n | \n \n 5.65 us \n | \n
| \n SealedType \n | \n \n .NET 6.0 \n | \n \n 218.4 us \n | \n \n 0.59 us \n | \n
| \n UnsealedType \n | \n \n .NET 7.0 \n | \n \n 1,074.5 us \n | \n \n 3.15 us \n | \n
| \n SealedType \n | \n \n .NET 7.0 \n | \n \n 216.1 us \n | \n \n 1.19 us \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n[Params(1_000_000)]\npublic int Iterations { get; set; }\n\nprivate readonly UnsealedClass unsealedType = new UnsealedClass();\nprivate readonly SealedClass sealedType = new SealedClass();\n\n[Benchmark(Baseline = true)]\npublic void UnsealedType()\n{\n for (int i = 0; i < Iterations; i++)\n {\n unsealedType.DoNothing();\n }\n}\n\n[Benchmark]\npublic void SealedType()\n{\n for (int i = 0; i < Iterations; i++)\n {\n sealedType.DoNothing();\n }\n}\n\nprivate class BaseType\n{\n public virtual void DoNothing() { }\n}\n\nprivate class UnsealedClass : BaseType\n{\n public override void DoNothing() { }\n}\n\nprivate sealed class SealedClass : BaseType\n{\n public override void DoNothing() { }\n}\n\nHardware Configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 5.0 : .NET 5.0.17 (5.0.1722.21314), X64 RyuJIT AVX2\n .NET 6.0 : .NET 6.0.16 (6.0.1623.17311), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S3260.json", "content": "{\n \"title\": \"Non-derived \\\"private\\\" classes and records should be \\\"sealed\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3260\",\n \"sqKey\": \"S3260\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3261.html", "content": "
Namespaces with no lines of code clutter a project and should be removed.
\n\nnamespace MyEmptyNamespace // Noncompliant\n{\n\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3261.json",
"content": "{\n \"title\": \"Namespaces should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3261\",\n \"sqKey\": \"S3261\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3262.html",
"content": "Overriding methods automatically inherit the params behavior. To ease readability, this modifier should be explicitly used in the\noverriding method as well.
\nclass Base\n{\n public virtual void Method(params int[] numbers)\n {\n ...\n }\n}\nclass Derived : Base\n{\n public override void Method(int[] numbers) // Noncompliant, the params is missing.\n {\n ...\n }\n}\n\n\nclass Base\n{\n public virtual void Method(params int[] numbers)\n {\n ...\n }\n}\nclass Derived : Base\n{\n public override void Method(params int[] numbers)\n {\n ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3262.json",
"content": "{\n \"title\": \"\\\"params\\\" should be used on overrides\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3262\",\n \"sqKey\": \"S3262\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3263.html",
"content": "Static field initializers are executed in the order in which they appear in the class from top to bottom. Thus, placing a static field in a class\nabove the field or fields required for its initialization will yield unexpected results.
\n\nclass MyClass\n{\n public static int X = Y; // Noncompliant; Y at this time is still assigned default(int), i.e. 0\n public static int Y = 42;\n}\n\n\nclass MyClass\n{\n public static int Y = 42;\n public static int X = Y;\n}\n\nor
\n\nclass MyClass\n{\n public static int X;\n public static int Y = 42;\n\n static MyClass()\n {\n X = Y;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3263.json",
"content": "{\n \"title\": \"Static fields should appear in the order they must be initialized \",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3263\",\n \"sqKey\": \"S3263\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3264.html",
"content": "Events that are not invoked anywhere are dead code, and there’s no good reason to keep them in the source.
\n\nclass UninvokedEventSample\n{\n private event Action<object, EventArgs> Happened; // Noncompliant\n\n public void RegisterEventHandler(Action<object, EventArgs> handler)\n {\n Happened += handler; // we register some event handlers\n }\n\n public void RaiseEvent()\n {\n if (Happened != null)\n {\n // Happened(this, null); // the event is never triggered, because this line is commented out.\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3264.json",
"content": "{\n \"title\": \"Events should be invoked\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3264\",\n \"sqKey\": \"S3264\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3265.html",
"content": "Enumerations are commonly used to identify\ndistinct elements from a set of values.
\nHowever, they can also serve as bit flags, enabling bitwise operations to combine multiple\nelements within a single value.
\n\n// Saturday = 0b00100000, Sunday = 0b01000000, weekend = 0b01100000\nvar weekend = Days.Saturday | Days.Sunday; // Combining elements\n\n
When enumerations are used as bit flags, it is considered
\nenum Permissions\n{\n None = 0,\n Read = 1,\n Write = 2,\n Execute = 4\n}\n\n// ...\n\nvar x = Permissions.Read | Permissions.Write; // Noncompliant: enum is not annotated with [Flags]\n\nThe FlagsAttribute explicitly marks an enumeration as bit flags, making it clear that it uses bit fields and is intended to be used as\nflags.
\n[Flags]\nenum Permissions\n{\n None = 0,\n Read = 1,\n Write = 2,\n Execute = 4\n}\n\n// ...\n\nvar x = Permissions.Read | Permissions.Write; // Compliant: enum is annotated with [Flags]\n\nAdditionally, adding the FlagsAttribute to the enumeration enable a
This rule will not raise for FlagsAttribute, it is often used in a similar fashion.
Using explicit loops for filtering, selecting, or aggregating elements can make code more verbose and harder to read. LINQ expressions provide a\nmore concise and expressive way to perform these operations, improving code clarity and maintainability.
\nIf the affected code is part of a performance-critical hot path and that the fix would negatively impact performance, you can self-declare the\nPerformanceSensitiveAttribute in your codebase, or use the one provided by
\n[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]\npublic sealed class PerformanceSensitiveAttribute() : Attribute;\n\n[PerformanceSensitiveAttribute]\nList<string> Method(IEnumerable<string> collection, Predicate<string> condition)\n{\n var result = new List<string>();\n foreach (var element in collection) // Without the attribute, this would raise an issue\n {\n if (condition(element))\n {\n result.Add(element);\n }\n }\n return result;\n}\n\nThe rule will respect the AllowGenericEnumeration\nproperty:
\n[PerformanceSensitive(\"Enumeration\", AllowGenericEnumeration = true)]\nList<string> Method(IEnumerable<string> collection, Predicate<string> condition) { }\n\nIn this case, the rule will not be disabled even if the method is marked with the PerformanceSensitiveAttribute attribute.
Replace explicit loops and conditional blocks with equivalent LINQ expressions.
\nUse the System.Linq.Async package to enable LINQ operations on
\nList<string> Method(IEnumerable<string> collection, Predicate<string> condition)\n{\n var result = new List<string>();\n foreach (var element in collection) // Noncompliant\n {\n if (condition(element))\n {\n result.Add(element);\n }\n }\n return result;\n}\n\n\nList<string> Method(IEnumerable<MyDto> collection)\n{\n var result = new List<string>();\n foreach (var element in collection) // Noncompliant\n {\n var someValue = element.Property;\n if (someValue != null)\n {\n result.Add(someValue);\n }\n }\n return result;\n}\n\n\npublic void Method(List<string> list)\n{\n foreach (var element in list)\n {\n var someValue = element.Length;\n }\n}\n\n\nasync void Method(IAsyncEnumerable<int> collection)\n{\n await foreach (var element in collection)\n {\n if (element is 42)\n {\n Console.WriteLine(\"The meaning of Life.\");\n }\n }\n}\n\n\nList<string> Method(IEnumerable<string> collection, Predicate<string> condition) =>\n collection.Where(x => condition(x)).ToList();\n\n
\nList<string> Method(IEnumerable<MyDto> collection) =>\n collection.Select(x => x.Property).Where(y => y != null).ToList();\n\n
\nvoid Method(List<int> list)\n{\n foreach (var length in list.Select(x => x.Length))\n {\n var someValue = length;\n }\n}\n\n\nasync void Method(IAsyncEnumerable<int> collection)\n{\n await foreach (var element in collection.Where(x => x is 42)))\n {\n Console.WriteLine(\"The meaning of Life.\");\n }\n}\n\nThis vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nIn the mode Cipher Block Chaining (CBC), each block is used as cryptographic input for the next block. For this reason, the first block requires an\ninitialization vector (IV), also called a \"starting variable\" (SV).
\nIf the same IV is used for multiple encryption sessions or messages, each new encryption of the same plaintext input would always produce the same\nciphertext output. This may allow an attacker to detect patterns in the ciphertext.
\nAfter retrieving encrypted data and performing cryptographic attacks on it on a given timeframe, attackers can recover the plaintext that\nencryption was supposed to protect.
\nDepending on the recovered data, the impact may vary.
\nBelow are some real-world scenarios that illustrate the potential impact of an attacker exploiting the vulnerability.
\nBy modifying the plaintext of the encrypted message, an attacker may be able to trigger additional vulnerabilities in the code. An attacker can\nfurther exploit a system to obtain more information.\n
\n Encrypted values are often considered trustworthy because it would not be possible for a third party to modify them under normal circumstances.
When encrypted data contains personal or sensitive information, its retrieval by an attacker can lead to privacy violations, identity theft,\nfinancial loss, reputational damage, or unauthorized access to confidential systems.
\nIn this scenario, a company, its employees, users, and partners could be seriously affected.
\nThe impact is twofold, as data breaches and exposure of encrypted data can undermine trust in the organization, as customers, clients and\nstakeholders may lose confidence in the organization’s ability to protect their sensitive data.
\nIn many industries and locations, there are legal and compliance requirements to protect sensitive data. If encrypted data is compromised and the\nplaintext can be recovered, companies face legal consequences, penalties, or violations of privacy laws.
\n\nusing System.IO;\nusing System.Security.Cryptography;\n\npublic void Encrypt(byte[] key, byte[] dataToEncrypt, MemoryStream target)\n{\n var aes = new AesCryptoServiceProvider();\n\n byte[] iv = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };\n var encryptor = aes.CreateEncryptor(key, iv); // Noncompliant\n\n var cryptoStream = new CryptoStream(target, encryptor, CryptoStreamMode.Write);\n var swEncrypt = new StreamWriter(cryptoStream);\n\n swEncrypt.Write(dataToEncrypt);\n}\n\nIn this example, the code implicitly uses a number generator that is considered strong, thanks to aes.IV.
\nusing System.IO;\nusing System.Security.Cryptography;\n\npublic void Encrypt(byte[] key, byte[] dataToEncrypt, MemoryStream target)\n{\n var aes = new AesCryptoServiceProvider();\n\n var encryptor = aes.CreateEncryptor(key, aes.IV);\n\n var cryptoStream = new CryptoStream(target, encryptor, CryptoStreamMode.Write);\n var swEncrypt = new StreamWriter(cryptoStream);\n\n swEncrypt.Write(dataToEncrypt);\n}\n\nTo ensure high security, initialization vectors must meet two important criteria:
\nThe IV does not need be secret, so the IV or information sufficient to determine the IV may be transmitted along with the ciphertext.
\nIn the previous non-compliant example, the problem is not that the IV is hard-coded.\n
\n It is that the same IV is used for multiple encryption attempts.
When a cookie is configured with the HttpOnly attribute set to true, the browser guaranties that no client-side script will\nbe able to read it. In most cases, when a cookie is created, the default value of HttpOnly is false and it’s up to the developer\nto decide whether or not the content of the cookie can be read by the client-side script. As a majority of Cross-Site Scripting (XSS) attacks target\nthe theft of session-cookies, the HttpOnly attribute can help to reduce their impact as it won’t be possible to exploit the XSS\nvulnerability to steal session-cookies.
HttpOnly attribute offer an additional protection (not the case for an XSRF-TOKEN cookie / CSRF token for\n example)There is a risk if you answered yes to any of those questions.
\nHttpOnly flag should be set to true for most of the cookies and it’s mandatory for session /\n sensitive-security cookies.When the HttpCookie.HttpOnly property is set to false then the cookie can be accessed by client side code:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\nmyCookie.HttpOnly = false; // Sensitive: this cookie is created with the httponly flag set to false and so it can be stolen easily in case of XSS vulnerability\n\n
The default value of\nHttpOnly flag is false, unless overwritten by an application’s configuration file:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\n// Sensitive: this cookie is created without the httponly flag (by default set to false) and so it can be stolen easily in case of XSS vulnerability\n\n
Set the HttpCookie.HttpOnly property to true:
\nHttpCookie myCookie = new HttpCookie(\"Sensitive cookie\");\nmyCookie.HttpOnly = true; // Compliant: the sensitive cookie is protected against theft thanks to the HttpOnly property set to true (HttpOnly = true)\n\n
Or change the default flag values for the whole application by editing the
\n<httpCookies httpOnlyCookies=\"true\" requireSSL=\"true\" />\n\n
requireSSL attribute corresponds programmatically to the Secure field.httpOnlyCookies attribute corresponds programmatically to the httpOnly field.Caller information attributes\nprovide a way to get information about the caller of a method through
This rule raises an issue when the following attributes are used on parameters before the end of the parameter list:
\nMove the decorated parameters to the end of the parameter list.
\n\nvoid TraceMessage([CallerMemberName] string memberName = \"\",\n [CallerFilePath] string filePath = \"\",\n [CallerLineNumber] int lineNumber = 0,\n string message = null) // Noncompliant: decorated parameters appear before \"message\" parameter\n{\n /* ... */\n}\n\n\nvoid TraceMessage(string message = null,\n [CallerMemberName] string memberName = \"\",\n [CallerFilePath] string filePath = \"\",\n [CallerLineNumber] int lineNumber = 0)\n{\n /* ... */\n}\n\nAn assertion is a piece of code that’s used during development when the true, that means everything is operating as expected.
In non-debug mode, all Debug.Assert calls\nare automatically left out (via the Conditional(\"DEBUG\") mechanism). So, by\ncontract, the boolean expressions that are evaluated by those assertions must not contain any
The rule will raise if the method name starts with any of the following remove, delete, add,\npop, update, retain, insert, push, append, clear,\ndequeue, enqueue, dispose, put, or set, although SetEquals will be\nignored.
In the following example, the assertion checks the return value of the remove method in the argument. Because the whole line is skipped in\nnon-debug builds, the call to Remove never happens in such builds.
\nDebug.Assert(list.Remove(\"dog\"));\n\n
The Remove call must be extracted and the return value needs to be asserted instead.
\nbool result = list.Remove(\"dog\");\nDebug.Assert(result);\n\n
Debug.Assert\n MethodConditional attributeIf a variable that is not supposed to change is not marked as const, it could be accidentally reassigned elsewhere in the code,\nleading to unexpected behavior and bugs that can be hard to track down.
By declaring a variable as const, you ensure that its value remains constant throughout the code. It also signals to other developers\nthat this value is intended to remain constant. This can make the code easier to understand and maintain.
In some cases, using const can lead to performance improvements. The compiler might be able to make optimizations knowing that the\nvalue of a const variable will not change.
Mark the given variable with the const modifier.
\npublic bool Seek(int[] input)\n{\n var target = 32; // Noncompliant\n foreach (int i in input)\n {\n if (i == target)\n {\n return true;\n }\n }\n return false;\n}\n\n\npublic bool Seek(int[] input)\n{\n const int target = 32;\n foreach (int i in input)\n {\n if (i == target)\n {\n return true;\n }\n }\n return false;\n}\n\n\npublic class Sample\n{\n public void Method()\n {\n var context = $\"{nameof(Sample)}.{nameof(Method)}\"; // Noncompliant (C# 10 and above only)\n }\n}\n\n\npublic class Sample\n{\n public void Method()\n {\n const string context = $\"{nameof(Sample)}.{nameof(Method)}\";\n }\n}\n\nNested ternaries are hard to read and can make the order of operations complex to understand.
\n\npublic string GetReadableStatus(Job j)\n{\n return j.IsRunning ? \"Running\" : j.HasErrors ? \"Failed\" : \"Succeeded\"; // Noncompliant\n}\n\nInstead, use another line to express the nested operation in a separate statement.
\n\npublic string GetReadableStatus(Job j)\n{\n if (j.IsRunning)\n {\n return \"Running\";\n }\n return j.HasErrors ? \"Failed\" : \"Succeeded\";\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3358.json",
"content": "{\n \"title\": \"Ternary operators should not be nested\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3358\",\n \"sqKey\": \"S3358\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3363.html",
"content": "You should only set a property of a temporal type (like DateTime or DateTimeOffset) as the primary key of a table if the\nvalues are guaranteed to be unique.
Using temporal types as the primary key of a table is risky. When these types are used as primary keys, it usually means that each new key is\ncreated with the use of .Now or .UtcNow properties from DateTime and DateTimeOffset classes. In\nthose cases, duplicate keys exceptions may occur in many ways:
DateTime type);The rule raises an issue if:
\nId, <type name>Id or decorated by the [Key] or\n [PrimaryKey] attribute.Either use a GUID or the auto generated ID as a primary key.
\n\ninternal class Account\n{\n public DateTime Id { get; set; }\n\n public string Name { get; set; }\n public string Surname { get; set; }\n}\n\n\ninternal class Account\n{\n public Guid Id { get; set; }\n\n public string Name { get; set; }\n public string Surname { get; set; }\n}\n\nor
\n\ninternal class Person\n{\n [Key]\n public DateTime PersonIdentifier { get; set; }\n\n public string Name { get; set; }\n public string Surname { get; set; }\n}\n\n\ninternal class Person\n{\n [Key]\n public Guid PersonIdentifier { get; set; }\n\n public string Name { get; set; }\n public string Surname { get; set; }\n}\n\nIn single-threaded environments, the use of this in constructors is normal, and expected. But in multi-threaded environments, it could\nexpose partially-constructed objects to other threads, and should be used with caution.
The classic example is a class with a static list of its instances. If the constructor stores this in the list, another\nthread could access the object before it’s fully-formed. Even when the storage of this is the last instruction in the constructor,\nthere’s still a danger if the class is not final. In that case, the initialization of subclasses won’t be complete before\nthis is exposed.
This rule raises an issue when this is assigned to any globally-visible object in a constructor, and when it is passed to the method\nof another object in a constructor
\npublic class Monument\n{\n public static readonly List<Monument> ALL_MONUMENTS = new List<Monument>();\n // ...\n\n public Monument(string location, ...)\n {\n ALL_MONUMENTS.Add(this); // Noncompliant; passed to a method of another object\n\n this.location = location;\n // ...\n }\n}\n\nThis rule ignores instances of assigning this directly to a static field of the same class because that case is covered\nby {rule:csharpsquid:S3010} .
Adherence to the standard naming conventions makes your code not only more readable, but more usable. For instance, class FirstAttribute :\nAttribute can be used simply with First, but you must use the full name for class AttributeOne : Attribute.
This rule raises an issue when classes extending Attribute, EventArgs, or Exception, do not end with their\nparent class names.
\nclass AttributeOne : Attribute // Noncompliant\n{\n}\n\n\nclass FirstAttribute : Attribute\n{\n}\n\nIf a class' direct base class doesn’t follow the convention, then no issue is reported on the class itself, regardless of whether or not it\nconforms to the convention.
\n\nclass Timeout : Exception // Noncompliant\n{\n}\nclass ExtendedTimeout : Timeout // Ignored; doesn't conform to convention, but the direct base doesn't conform either\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3376.json",
"content": "{\n \"title\": \"Attribute, EventArgs, and Exception type names should end with the type being extended\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3376\",\n \"sqKey\": \"S3376\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3397.html",
"content": "object.Equals() overrides can be optimized by checking first for reference equality between this and the parameter. This\ncheck can be implemented by calling object.ReferenceEquals() or base.Equals(), where base is\nobject. However, using base.Equals() is a maintenance hazard because while it works if you extend Object\ndirectly, if you introduce a new base class that overrides Equals, it suddenly stops working.
This rule raises an issue if base.Equals() is used but base is not object.
\nclass Base\n{\n private int baseField;\n\n public override bool Equals(object other)\n {\n if (base.Equals(other)) // Okay; base is object\n {\n return true;\n }\n\n return this.baseField == ((Base)other).baseField;\n }\n}\n\nclass Derived : Base\n{\n private int derivedField;\n\n public override bool Equals(object other)\n {\n if (base.Equals(other)) // Noncompliant\n {\n return true;\n }\n\n return this.derivedField == ((Derived)other).derivedField;\n }\n}\n\n\nclass Base\n{\n private int baseField;\n\n public override bool Equals(object other)\n {\n if (object.ReferenceEquals(this, other)) // base.Equals is okay here, but object.ReferenceEquals is better\n {\n return true;\n }\n\n return this.baseField == ((Base)other).baseField;\n }\n}\n\nclass Derived : Base\n{\n private int derivedField;\n\n public override bool Equals(object other)\n {\n if (object.ReferenceEquals(this, other))\n {\n return true;\n }\n\n return base.Equals(other) && this.derivedField == ((Derived)other).derivedField;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3397.json",
"content": "{\n \"title\": \"\\\"base.Equals\\\" should not be used to check for reference equality in \\\"Equals\\\" if \\\"base\\\" is not \\\"object\\\"\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3397\",\n \"sqKey\": \"S3397\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3398.html",
"content": "When a private static method is only invoked by a nested class, there’s no reason not to move it into that class. It will still have\nthe same access to the outer class' static members, but the outer class will be clearer and less cluttered.
\npublic class Outer\n{\n private const int base = 42;\n\n private static void Print(int num) // Noncompliant - static method is only used by the nested class, should be moved there\n {\n Console.WriteLine(num + base);\n }\n\n public class Nested\n {\n public void SomeMethod()\n {\n Outer.Print(1);\n }\n }\n}\n\n\npublic class Outer\n{\n private const int base = 42;\n\n public class Nested\n {\n public void SomeMethod()\n {\n Print(1);\n }\n\n private static void Print(int num)\n {\n Console.WriteLine(num + base);\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3398.json",
"content": "{\n \"title\": \"\\\"private\\\" methods called only by inner classes should be moved to those classes\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3398\",\n \"sqKey\": \"S3398\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3400.html",
"content": "There’s no point in forcing the overhead of a method call for a method that always returns the same constant value. Even worse, the fact that a\nmethod call must be made will likely mislead developers who call the method thinking that something more is done. Declare a constant instead.
\nThis rule raises an issue if on methods that contain only one statement: the return of a constant value.
\nint GetBestNumber()\n{\n return 12; // Noncompliant\n}\n\n\nconst int BestNumber = 12;\n\n
or
\n\nstatic readonly int BestNumber = 12;\n\n\n" }, { "path": "analyzers/rspec/cs/S3400.json", "content": "{\n \"title\": \"Methods should not return constants\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3400\",\n \"sqKey\": \"S3400\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3415.html", "content": "
The standard assertions library methods such as AreEqual and AreSame in MSTest and\nNUnit, or Equal and Same in XUnit, expect the first argument to be the expected value and\nthe second argument to be the actual value.
Having the expected value and the actual value in the wrong order will not alter the outcome of tests, (succeed/fail when it should) but the error\nmessages will contain misleading information.
\nThis rule raises an issue when the actual argument to an assertions library method is a hard-coded value and the expected argument is not.
\nYou should provide the assertion methods with a hard-coded value as the expected value, while the actual value of the assertion should derive from\nthe portion of code that you want to test.
\n\nAssert.AreEqual(runner.ExitCode, 0, \"Unexpected exit code\"); // Noncompliant; Yields error message like: Expected:<-1>. Actual:<0>.\n\n
\nAssert.AreEqual(0, runner.ExitCode, \"Unexpected exit code\");\n\n\n" }, { "path": "analyzers/rspec/cs/S3415.json", "content": "{\n \"title\": \"Assertion arguments should be passed in the correct order\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"tests\",\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3415\",\n \"sqKey\": \"S3415\",\n \"scope\": \"Tests\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3416.html", "content": "
It is a well-established convention to name each logger after its enclosing type. This rule raises an issue when the convention is not\nrespected.
\n\nclass EnclosingType\n{\n private readonly ILogger logger;\n\n public EnclosingType(ILoggerFactory loggerFactory)\n {\n logger = loggerFactory.CreateLogger<AnotherType>(); // Noncompliant\n logger = loggerFactory.CreateLogger<EnclosingType>(); // Compliant\n }\n}\n\nNot following such a convention can result in confusion and logging misconfiguration.
\nFor example, the person configuring the log may attempt to change the logging behavior for the MyNamespace.EnclosingType type, by\noverriding defaults for the logger named after that type.
\n{\n \"Logging\": {\n \"LogLevel\": {\n \"Default\": \"Error\",\n \"MyNamespace.EnclosingType\": \"Debug\"\n }\n }\n}\n\nHowever, if the convention is not in place, the override would not affect logs from MyNamespace.EnclosingType, since they are made via\na logger with a different name.
Moreover, using the same logger name for multiple types prevents the granular configuration of each type’s logger, since there is no way to\ndistinguish them in configuration.
\nThe rule targets the following logging frameworks: * Microsoft\nExtensions Logging * Apache log4net * NLog
\nThe rule doesn’t raise issues when custom handling of logging names is in place, and the logger name is not derived from a Type.
\nclass EnclosingType\n{\n private readonly ILogger logger;\n\n EnclosingType(ILoggerFactory loggerFactory)\n {\n logger = loggerFactory.CreateLogger(\"My cross-type logging category\"); // Compliant\n logger = loggerFactory.CreateLogger(AComplexLogicToFindTheRightType()); // Compliant\n }\n}\n\nWhen the logger name is defined by a generic type parameter:
\n\nclass EnclosingType\n{\n private readonly ILogger logger;\n\n public EnclosingType(ILoggerFactory loggerFactory)\n {\n logger = loggerFactory.CreateLogger<AnotherType>(); // Noncompliant\n logger = loggerFactory.CreateLogger<EnclosingType>(); // Compliant\n }\n}\n\nWhen the logger name is defined by an input parameter of type Type:
\nclass EnclosingType\n{\n private readonly ILogger logger;\n\n public EnclosingType(ILoggerFactory loggerFactory)\n {\n logger = loggerFactory.CreateLogger(typeof(AnotherType)); // Noncompliant\n logger = loggerFactory.CreateLogger(typeof(EnclosingType)); // Compliant\n logger = loggerFactory.CreateLogger(GetType()); // Compliant\n }\n}\n\nWhen the logger name is a string, derived from a Type:
\nclass EnclosingType\n{\n private readonly ILogger logger;\n\n public EnclosingType(ILoggerFactory loggerFactory)\n {\n logger = loggerFactory.CreateLogger(typeof(AnotherType).Name); // Noncompliant\n logger = loggerFactory.CreateLogger(typeof(AnotherType).FullName); // Noncompliant\n logger = loggerFactory.CreateLogger(nameof(AnotherType)); // Noncompliant\n // Fix by referring to the right type\n logger = loggerFactory.CreateLogger(typeof(EnclosingType).Name); // Compliant\n logger = loggerFactory.CreateLogger(typeof(EnclosingType).FullName); // Compliant\n logger = loggerFactory.CreateLogger(nameof(EnclosingType)); // Compliant\n // or by retrieving the right type dynamically\n logger = loggerFactory.CreateLogger(GetType().FullName); // Compliant\n }\n}\n\nThe rules for method resolution can be complex and may not be fully understood by all developers. The situation becomes even more challenging when\ndealing with method overloads that have optional parameter values.
\nThis rule raises an issue when an overload with default parameter values is hidden by another overload that does not have the optional\nparameters.
\nSee the following example:
\n\nMyClass.Print(1); // which overload of Print will be called?\n\npublic static class MyClass\n{\n public static void Print(int number) { }\n public static void Print(int number, string delimiter = \"\\n\") { } // Noncompliant, default parameter value is hidden by overload\n}\n\nIn this code snippet, the Print method is overloaded with two versions, where the first one hides the second one. This can lead to\nconfusion and uncertainty about which overload of the method will be invoked when calling it.
To address the problem you have a couple of options:
\n\nMyClass.Print(1); // which overload of Print will be called?\n\npublic static class MyClass\n{\n public static void Print(int number) { }\n public static void Print(int number, string delimiter = \"\\n\") { } // Noncompliant: default parameter value is hidden by overload\n}\n\n\nMyClass.PrintWithDelimiter(1);\n\npublic static class MyClass\n{\n public static void Print(int number) { }\n public static void PrintWithDelimiter(int number, string delimiter = \"\\n\") { } // Compliant\n}\n\nIt should be clear to a casual reader what code a test is testing and what results are expected. Unfortunately, that’s not usually the case with\nthe ExpectedException attribute since an exception could be thrown from almost any line in the method.
This rule detects MSTest and NUnit ExpectedException attribute.
This rule ignores:
\ncatch or finally clause\n[TestMethod]\n[ExpectedException(typeof(InvalidOperationException))]\npublic void UsingTest()\n{\n Console.ForegroundColor = ConsoleColor.Black;\n try\n {\n using var _ = new ConsoleAlert();\n Assert.AreEqual(ConsoleColor.Red, Console.ForegroundColor);\n throw new InvalidOperationException();\n }\n finally\n {\n Assert.AreEqual(ConsoleColor.Black, Console.ForegroundColor); // The exception itself is not relevant for the test.\n }\n}\n\npublic sealed class ConsoleAlert : IDisposable\n{\n private readonly ConsoleColor previous;\n\n public ConsoleAlert()\n {\n previous = Console.ForegroundColor;\n Console.ForegroundColor = ConsoleColor.Red;\n }\n\n public void Dispose() =>\n Console.ForegroundColor = previous;\n}\n\nRemove the ExpectedException attribute in favor of using the
\n[TestMethod]\n[ExpectedException(typeof(ArgumentNullException))] // Noncompliant\npublic void Method_NullParam()\n{\n var sut = new MyService();\n sut.Method(null);\n}\n\n\n[TestMethod]\npublic void Method_NullParam()\n{\n var sut = new MyService();\n Assert.ThrowsException<ArgumentNullException>(() => sut.Method(null));\n}\n\nRemove the ExpectedException attribute in favor of using the
\n[Test]\n[ExpectedException(typeof(ArgumentNullException))] // Noncompliant\npublic void Method_NullParam()\n{\n var sut = new MyService();\n sut.Method(null);\n}\n\n\n[Test]\npublic void Method_NullParam()\n{\n var sut = new MyService();\n Assert.Throws<ArgumentNullException>(() => sut.Method(null));\n}\n\nA method is identified as a test method if it is marked with one of the following attributes:
\n[TestMethod] or [DataTestMethod] (for MSTest).[Fact] or [Theory] (for xUnit).[Test], [TestCase], [TestCaseSource], or [Theory] (for NUnit).However, non-public methods are not considered test methods and will not be executed, regardless of whether they have a test\nattribute. Additionally, methods with the async void modifier or methods that contain generics <T> anywhere in their\nsignatures are also excluded from being recognized as tests and will not be executed.
\n[TestMethod]\nvoid TestNullArg() // Noncompliant, method is not public\n{ /* ... */ }\n\n[TestMethod]\npublic async void MyIgnoredTestMethod() // Noncompliant, this is an 'async void' method\n{ /* ... */ }\n\n[TestMethod]\npublic void MyIgnoredGenericTestMethod<T>(T foo) // Noncompliant, method has generics in its signature\n{ /* ... */ }\n\n\n[TestMethod]\npublic void TestNullArg()\n{ /* ... */ }\n\n[TestMethod]\npublic async Task MyIgnoredTestMethod()\n{ /* ... */ }\n\n[TestMethod]\npublic void MyIgnoredGenericTestMethod(int foo)\n{ /* ... */ }\n\nFor xUnit, accessibility is disregarded when it comes to [Fact] test methods, as they do not necessarily need to be\ndeclared as public.
In xUnit, [Theory] test methods, as well as [TestCase] and [TestCaseSource] test methods in\nNUnit, have the flexibility to be generic, allowing for a wider range of test scenarios.
There’s no point in checking a variable against the value you’re about to assign it. Save the cycles and lines of code, and simply perform the\nassignment.
\n\nif (x != a) // Noncompliant; why bother?\n{\n x = a;\n}\n\n\nx = a;\n\n
Properties and checks inside setters are excluded from this rule because they could have side effects and removing the check could lead to\nundesired side effects.
\n\nif (MyProperty != a)\n{\n MyProperty = a; // Compliant because the setter could be expensive call\n}\n\n\nprivate int myField;\npublic int SomeProperty\n{\n get\n {\n return myField;\n }\n set\n {\n if (myField != value)\n {\n myField = value;\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3440.json",
"content": "{\n \"title\": \"Variables should not be checked against the values they\\u0027re about to be assigned\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3440\",\n \"sqKey\": \"S3440\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3441.html",
"content": "When an anonymous type’s properties are copied from properties or variables with the same names, it yields cleaner code to omit the new type’s\nproperty name and the assignment operator.
\n\nvar X = 5;\n\nvar anon = new\n{\n X = X, //Noncompliant, the new object would have the same property without the \"X =\" part.\n Y = \"my string\"\n};\n\n\nvar X = 5;\n\nvar anon = new\n{\n X,\n Y = \"my string\"\n};\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3441.json",
"content": "{\n \"title\": \"Redundant property names should be omitted in anonymous classes\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3441\",\n \"sqKey\": \"S3441\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3442.html",
"content": "The abstract modifier in a class declaration is\nused to indicate that a class is intended only to be a base class of other classes, not instantiated on its own.
\nSince abstract classes cannot be instantiated, there is no need for public or internal constructors. If\nthere is basic initialization logic that should run when an extending class instance is created, you can add it in a private,\nprivate protected or protected constructor.
Restrict the constructor visibility to the minimum: private, private protected or protected, depending on\nthe usage.
\nabstract class Base\n{\n public Base() // Noncompliant: should be private, private protected or protected.\n {\n //...\n }\n}\n\n\nabstract class Base\n{\n protected Base()\n {\n //...\n }\n}\n\nCalling GetType on a Type variable will always return the System.Type representation, which is equivalent to\ntypeof(System.Type). This also applies to passing a Type argument to IsInstanceOfType which always returns\nfalse.
In both cases, the results are entirely predictable and should be avoided.
\nCalling GetType on System.Type is considered compliant to get an instance of System.RuntimeType, as\ndemonstrated in the following example:
\ntypeof(Type).GetType(); // Can be used by convention to get an instance of 'System.RuntimeType'\n\n
Make sure the usage of GetType or IsInstanceOfType is invoked with the correct variable or argument type.
\nvoid ExamineSystemType(string str)\n{\n Type stringType = str.GetType();\n Type runtimeType = stringType.GetType(); // Noncompliant\n\n if (stringType.IsInstanceOfType(typeof(string))) // Noncompliant; will always return false\n { /* ... */ }\n}\n\n\nvoid ExamineSystemType(string str)\n{\n Type stringType = str.GetType();\n\n if (stringType.IsInstanceOfType(str)) // Compliant\n { /* ... */ }\n}\n\nWhen an interface inherits from two interfaces that both define a member with the same name, trying to access that member through the derived\ninterface will result in the compiler error CS0229 Ambiguity between 'IBase1.SomeProperty' and 'IBase2.SomeProperty'.
So instead, every caller will be forced to cast instances of the derived interface to one or the other of its base interfaces to resolve the\nambiguity and be able to access the member. Instead, it is better to resolve the ambiguity in the definition of the derived interface either by:
\n\npublic interface IBase1\n{\n string SomeProperty { get; set; }\n}\n\npublic interface IBase2\n{\n string SomeProperty { get; set; }\n}\n\npublic interface IDerived : IBase1, IBase2 // Noncompliant, accessing IDerived.SomeProperty is ambiguous\n{\n}\n\npublic class MyClass : IDerived\n{\n // Implements both IBase1.SomeProperty and IBase2.SomeProperty\n public string SomeProperty { get; set; } = \"Hello\";\n\n public static void Main()\n {\n MyClass myClass = new MyClass();\n Console.WriteLine(myClass.SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IBase1)myClass).SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IBase2)myClass).SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IDerived)myClass).SomeProperty); // Error CS0229 Ambiguity between 'IBase1.SomeProperty' and 'IBase2.SomeProperty'\n }\n}\n\n\npublic interface IDerived : IBase1, IBase2\n{\n new string SomeProperty { get; set; }\n}\n\npublic class MyClass : IDerived\n{\n // Implements IBase1.SomeProperty, IBase2.SomeProperty and IDerived.SomeProperty\n public string SomeProperty { get; set; } = \"Hello\";\n\n public static void Main()\n {\n MyClass myClass = new MyClass();\n Console.WriteLine(myClass.SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IBase1)myClass).SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IBase2)myClass).SomeProperty); // Writes \"Hello\" as expected\n Console.WriteLine(((IDerived)myClass).SomeProperty); // Writes \"Hello\" as expected\n }\n}\n\nor
\n\npublic interface IBase1\n{\n string SomePropertyOne { get; set; }\n}\n\npublic interface IBase2\n{\n string SomePropertyTwo { get; set; }\n}\n\npublic interface IDerived : IBase1, IBase2\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3444.json",
"content": "{\n \"title\": \"Interfaces should not simply inherit from base interfaces with colliding members\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3444\",\n \"sqKey\": \"S3444\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3445.html",
"content": "In C#, the
In the software development context, an expression is a value or anything that executes and ends up being a value. The expression shall be\nimplicitly convertible to System.Exception, and the result of evaluating the expression is converted to System.Exception\nbefore being thrown.
\ntry\n{\n}\ncatch(Exception exception)\n{\n // code that uses the exception\n throw exception; // The exception stack trace is cleared up to this point.\n}\n\nIn this case, the stack trace, will be cleared, losing the list of method calls between the\noriginal method that threw the exception and the current method.
\nThis syntax is supported only in a catch block, in which case, that statement re-throws the exception currently being handled by that\ncatch block, preserving the stack trace.
\ntry\n{\n}\ncatch(Exception exception)\n{\n // code that uses the exception\n throw; // The stack trace of the initial exception is preserved.\n}\n\nIt is allowed using the thrown exception as an argument and wrapping it in another exception.
\ntry\n{\n}\ncatch(Exception exception)\n{\n throw new Exception(\"Additional information\", exception);\n}\n\nThe recommended way to re-throw an exception is to use the throw statement without including an expression. This ensures that all call stack\ninformation is preserved when the exception is propagated to the caller, making debugging easier.
\n\ntry\n{\n}\ncatch(Exception exception)\n{\n throw exception;\n}\n\n\ntry\n{\n}\ncatch(Exception)\n{\n throw;\n}\n\nThe use of ref or [Optional] indicates that the parameter doesn’t have to be provided, while out and ref mean that\nthe parameter will be used to return data to the caller (ref additionally indicates that the parameter may also be used to pass data into\nthe method).
Thus, making it [Optional] to provide the parameter in which you will be passing back the method results doesn’t make sense. In fact,\nthe compiler will raise an error on such code. Unfortunately, it raises the error on method calls where the [Optional] parameter has been\nomitted, not the source of the problem, the method declaration.
\nclass MyClass\n{\n public void DoStuff([Optional] ref int i) // Noncompliant\n {\n Console.WriteLine(i);\n }\n\n public static void Main()\n {\n new MyClass().DoStuff(); // Compilation Error [CS7036]\n }\n}\n\n\nclass MyClass\n{\n public void DoStuff(ref int i)\n {\n Console.WriteLine(i);\n }\n\n public static void Main()\n {\n var i = 42;\n new MyClass().DoStuff(ref i);\n }\n}\n\nNumbers can be shifted with the << and >> int or a type that has an int. However, when the left operand is int at runtime, then a
\ndynamic d = 5;\nvar x = d >> 5.4; // Noncompliant\nx = d << null; // Noncompliant\nx <<= new object(); // Noncompliant\n\n
There is no point in providing a default value for a parameter if callers are required to provide a value for it anyway. Thus,\n[DefaultParameterValue] should always be used in conjunction with [Optional].
\npublic void MyMethod([DefaultParameterValue(5)] int j) //Noncompliant, useless\n{\n Console.WriteLine(j);\n}\n\n\npublic void MyMethod(int j = 5)\n{\n Console.WriteLine(j);\n}\n\nor
\n\npublic void MyMethod([DefaultParameterValue(5)][Optional] int j)\n{\n Console.WriteLine(j);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3450.json",
"content": "{\n \"title\": \"Parameters with \\\"[DefaultParameterValue]\\\" attributes should also be marked \\\"[Optional]\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3450\",\n \"sqKey\": \"S3450\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3451.html",
"content": "DefaultValue does not make the compiler set\nthe default value, as its name may suggest. What you probably wanted to use is
The DefaultValue attribute from the\nSystem.ComponentModel namespace, is sometimes used to declare a member’s default value. This can be used, for instance, by the reset\nfeature of a visual designer or by a code generator.
\npublic void DoStuff([DefaultValue(4)] int i)\n{\n // i is not automatically assigned 4\n}\n\nThe Optional attribute from the\nSystem.Runtime.InteropServices namespace is sometimes used to indicate that a parameter is optional, as an alternative to the\nlanguage-specific construct.
\npublic void DoStuff([Optional] int i)\n{\n // i would be assigned default(int) = 0\n}\n\nThe use of [DefaultValue] with [Optional] has no more effect than [Optional] alone. That’s because\n[DefaultValue] doesn’t actually do anything; it merely indicates the intent for the value.
\nclass MyClass\n{\n public void DoStuff([Optional][DefaultValue(4)] int i, int j = 5) // Noncompliant\n {\n Console.WriteLine(i);\n }\n\n public static void Main()\n {\n new MyClass().DoStuff(); // prints 0, since [DefaultValue] doesn't actually set the default, and default(int) is used instead\n }\n}\n\nMore than likely, [DefaultValue] was used in confusion instead of [DefaultParameterValue], the language-agnostic version\nof the default parameter initialization mechanism provided by C#.
\nclass MyClass\n{\n public void DoStuff([Optional][DefaultParameterValue(4)] int i, int j = 5)\n {\n Console.WriteLine(i);\n }\n\n public static void Main()\n {\n new MyClass().DoStuff(); // prints 4\n }\n}\n\nNotice that you can’t use both [DefaultParameterValue] and default parameter initialization on the same parameter.
\nvoid DoStuff([Optional][DefaultParameterValue(4)] int i = 5) // Error CS1745 Cannot specify default parameter value in conjunction with DefaultParameterAttribute or OptionalAttribute\n\n
When a class has only a private constructor, it can’t be instantiated except within the class itself. Such classes can be considered\ndead code and should be fixed
static members are also ignored because they are covered by Rule {rule:csharpsquid:S1118}.\npublic class MyClass // Noncompliant: the class contains only private constructors\n{\n private MyClass() { ... }\n}\n\n\npublic class MyClass // Compliant: the class contains at least one non-private constructor\n{\n public MyClass() { ... }\n}\n\nThe string type offers an indexer property that allows you to treat it as a char array. Therefore, if you just need to\naccess a specific character or iterate over all of them, the ToCharArray call should be omitted. For these cases, not omitting makes the\ncode harder to read and less efficient as ToCharArray copies the characters from the string object into a new Unicode\ncharacter array.
The same principle applies to utf-8 literals\ntypes (ReadOnlySpan<byte>, Span<byte>) and the ToArray method.
\nstring str = \"some string\";\nforeach (var c in str.ToCharArray()) // Noncompliant\n{\n // ...\n}\n\nReadOnlySpan<byte> span = \"some UTF-8 string literal\"u8;\nforeach (var c in span.ToArray()) // Noncompliant\n{\n // ...\n}\n\n\nstring str = \"some string\";\nforeach (var c in str)\n{\n // ...\n}\n\nReadOnlySpan<byte> span = \"some UTF-8 string literal\"u8;\nforeach (var b in span) // Compliant\n{\n // ...\n}\n\nA composite format string is a string that contains\nplaceholders, represented by indices inside curly braces \"{0}\", \"{1}\", etc. These placeholders are replaced by values when the string is printed or\nlogged.
\nBecause composite format strings are interpreted at runtime, rather than validated by the compiler, they can contain errors that lead to unexpected\nbehaviors or runtime errors.
\nThis rule validates the correspondence between arguments and composite formats when calling the following methods:
\nString.Format StringBuilder.AppendFormat Console.Write Console.WriteLine TextWriter.Write TextWriter.WriteLine Debug.WriteLine(String, Object[])\n Trace.TraceError(String, Object[])\n Trace.TraceInformation(String, Object[]) Trace.TraceWarning(String, Object[])\n TraceSource.TraceInformation(String, Object[]) \nvar pattern = \"{0} {1} {2}\";\nvar res = string.Format(pattern, 1, 2); // Incorrect, but the analyzer doesn't raise any warnings here\n\n\nvar array = new int[] {};\nvar res = string.Format(\"{0} {1}\", array); // Compliant; we don't know the size of the array\n\n:) is actually valid. A composite format string contains placeholders, replaced by values when the string is printed or logged. Mismatch in the format specifiers and the\narguments provided can lead to incorrect strings being created.
\nTo avoid issues, a developer should ensure that the provided arguments match format specifiers.
\nMoreover, use string interpolation when possible.
\nInstead of
\n\nstring str = string.Format(\"Hello {0} {1}!\", firstName, lastName);\n\nuse
\n\nstring str = $\"Hello {firstName} {lastName}!\";\n\nWith string interpolation:
\n\ns = string.Format(\"{0}\", arg0, arg1); // Noncompliant, arg1 is declared but not used.\ns = string.Format(\"{0} {2}\", arg0, arg1, arg2); // Noncompliant, the format item with index 1 is missing, so arg1 will not be used.\ns = string.Format(\"foo\"); // Noncompliant; there is no need to use \"string.Format\" here.\n\n\ns = string.Format(\"{0}\", arg0);\ns = string.Format(\"{0} {1}\", arg0, arg2);\ns = \"foo\";\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3457.json",
"content": "{\n \"title\": \"Composite format strings should be used correctly\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3457\",\n \"sqKey\": \"S3457\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3458.html",
"content": "Empty case clauses that fall through to the default are useless. Whether or not such a case is present, the\ndefault clause will be invoked. Such cases simply clutter the code, and should be removed.
\nswitch(ch)\n{\n case 'a' :\n HandleA();\n break;\n case 'b' :\n HandleB();\n break;\n case 'c' : // Noncompliant\n default:\n HandleTheRest();\n break;\n}\n\n\nswitch(ch)\n{\n case 'a' :\n HandleA();\n break;\n case 'b' :\n HandleB();\n break;\n default:\n HandleTheRest();\n break;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3458.json",
"content": "{\n \"title\": \"Empty \\\"case\\\" clauses that fall through to the \\\"default\\\" should be omitted\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3458\",\n \"sqKey\": \"S3458\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3459.html",
"content": "Fields and auto-properties that are never assigned to hold the default values for their types. They are either pointless code or, more likely,\nmistakes.
\n\nclass MyClass\n{\n private int field; // Noncompliant, shouldn't it be initialized? This way the value is always default(int), 0.\n private int Property { get; set; } // Noncompliant\n public void Print()\n {\n Console.WriteLine(field); //Will always print 0\n Console.WriteLine(Property); //Will always print 0\n }\n}\n\n\nclass MyClass\n{\n private int field = 1;\n private int Property { get; set; } = 42;\n public void Print()\n {\n field++;\n Console.WriteLine(field);\n Console.WriteLine(Property);\n }\n}\n\nSystem.SerializableAttribute attribute.Recursion is a technique used to define a problem in terms of the problem itself, usually in\nterms of a simpler version of the problem itself.
\nFor example, the implementation of the generator for the n-th value of the Fibonacci\nsequence comes naturally from its mathematical definition, when recursion is used:
\n\nint NthFibonacciNumber(int n)\n{\n if (n <= 1)\n {\n return 1;\n }\n else\n {\n return NthFibonacciNumber(n - 1) + NthFibonacciNumber(n - 2);\n }\n}\n\nAs opposed to:
\n\nint NthFibonacciNumber(int n)\n{\n int previous = 0;\n\tint last = 1;\n\tfor (var i = 0; i < n; i++)\n\t{\n (previous, last) = (last, last + previous);\n\t}\n\treturn last;\n}\n\nThe use of recursion is acceptable in methods, like the one above, where you can break out of it.
\n\nint NthFibonacciNumber(int n)\n{\n if (n <= 1)\n {\n return 1; // Base case: stop the recursion\n }\n // ...\n}\n\nIt is also acceptable and makes sense in some type definitions:
\n\nclass Box : IComparable<Box>\n{\n public int CompareTo(Box? other)\n {\n // Compare the two Box instances...\n }\n}\n\nWith types, some invalid recursive definitions are caught by the compiler:
\n\nclass C2<T> : C2<T> // Error CS0146: Circular base type dependency\n{\n}\n\nclass C2<T> : C2<C2<T>> // Error CS0146: Circular base type dependency\n{\n}\n\nIn more complex scenarios, however, the code will compile but execution will result in a
\nclass C1<T>\n{\n}\n\nclass C2<T> : C1<C2<C2<T>>> // Noncompliant\n{\n}\n\nvar c2 = new C2<int>(); // This would result into a TypeLoadException\n\nWhen optional parameter values are not passed to base method calls, the value passed in by the caller is ignored. This can cause the function to\nbehave differently than expected, leading to errors and making the code difficult to debug.
\n\npublic class BaseClass\n{\n public virtual void MyMethod(int i = 1)\n {\n Console.WriteLine(i);\n }\n}\n\npublic class DerivedClass : BaseClass\n{\n public override void MyMethod(int i = 1)\n {\n // ...\n base.MyMethod(); // Noncompliant: caller's value is ignored\n }\n\n static int Main(string[] args)\n {\n DerivedClass dc = new DerivedClass();\n dc.MyMethod(12); // prints 1\n }\n}\n\n\npublic class BaseClass\n{\n public virtual void MyMethod(int i = 1)\n {\n Console.WriteLine(i);\n }\n}\n\npublic class DerivedClass : BaseClass\n{\n public override void MyMethod(int i = 1)\n {\n // ...\n base.MyMethod(i);\n }\n\n static int Main(string[] args)\n {\n DerivedClass dc = new DerivedClass();\n dc.MyMethod(12); // prints 12\n }\n}\n\nMicrosoft Learn -
The default clause should take appropriate action. Having an empty default is a waste of keystrokes.
\nenum Fruit\n{\n Apple,\n Orange,\n Banana\n}\n\nvoid PrintName(Fruit fruit)\n{\n switch(fruit)\n {\n case Fruit.Apple:\n Console.WriteLine(\"apple\");\n break;\n default: //Noncompliant\n break;\n }\n}\n\n\nenum Fruit\n{\n Apple,\n Orange,\n Banana\n}\n\nvoid PrintName(Fruit fruit)\n{\n switch(fruit)\n {\n case Fruit.Apple:\n Console.WriteLine(\"apple\");\n break;\n default:\n throw new NotSupportedException();\n }\n}\n\nor
\n\nvoid PrintName(Fruit fruit)\n{\n switch(fruit)\n {\n case Fruit.Apple:\n Console.WriteLine(\"apple\");\n break;\n }\n}\n\ndefault clauses containing only a comment are ignored with the assumption that they are empty on purpose and the comment documents\nwhy.
The ServiceContract attribute specifies that a class or interface defines the communication contract of a Windows Communication\nFoundation (WCF) service. The service operations of this class or interface are defined by OperationContract attributes added to methods.\nIt doesn’t make sense to define a contract without any service operations; thus, in a ServiceContract class or interface at least one\nmethod should be annotated with OperationContract. Similarly, WCF only serves OperationContract methods that are defined\ninside ServiceContract classes or interfaces; thus, this rule also checks that ServiceContract is added to the containing\ntype of OperationContract methods.
\n[ServiceContract]\ninterface IMyService // Noncompliant\n{\n int MyServiceMethod();\n}\n\n\n[ServiceContract]\ninterface IMyService\n{\n [OperationContract]\n int MyServiceMethod();\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3597.json",
"content": "{\n \"title\": \"\\\"ServiceContract\\\" and \\\"OperationContract\\\" attributes should be used together\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3597\",\n \"sqKey\": \"S3597\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3598.html",
"content": "When declaring a Windows Communication Foundation (WCF) OperationContract\nmethod as one-way,\nthat service method won’t return any result, not even an underlying empty confirmation message. These are fire-and-forget methods that are useful in\nevent-like communication. Therefore, specifying a return type has no effect and can confuse readers.
The rule doesn’t report if OperationContractAttribute.AsyncPattern\nis set to true.
\n[ServiceContract]\ninterface IMyService\n{\n [OperationContract(IsOneWay = true)]\n int SomethingHappened(int parameter); // Noncompliant\n}\n\n\n[ServiceContract]\ninterface IMyService\n{\n [OperationContract(IsOneWay = true)]\n void SomethingHappened(int parameter);\n}\n\nMicrosoft Learn -
Adding params to a method override has no effect.\nThe compiler accepts it, but the callers won’t be able to benefit from the added modifier.
\n\nclass Base\n{\n public virtual void Method(int[] numbers)\n {\n ...\n }\n}\nclass Derived : Base\n{\n public override void Method(params int[] numbers) // Noncompliant, method can't be called with params syntax.\n {\n ...\n }\n}\n\n\nclass Base\n{\n public virtual void Method(int[] numbers)\n {\n ...\n }\n}\nclass Derived : Base\n{\n public override void Method(int[] numbers)\n {\n ...\n }\n}\n\nMarking a method with the Pure\nattribute indicates that the method doesn’t make any visible state changes. Therefore, a Pure method should return a result. Otherwise,\nit indicates a no-operation call.
Using Pure on a void method is either by mistake or the method is not doing a meaningful task.
\nclass Person\n{\n private int age;\n\n [Pure] // Noncompliant: The method makes a state change\n void ConfigureAge(int age) =>\n this.age = age;\n}\n\n\nclass Person\n{\n private int age;\n\n void ConfigureAge(int age) =>\n this.age = age;\n}\n\nFields, properties and events can be initialized either inline or in the constructor. Initializing them inline and in the constructor at the same\ntime is redundant; the inline initialization will be overridden.
\n\nclass Person\n{\n int age = 42; // Noncompliant\n public Person(int age)\n {\n this.age = age;\n }\n}\n\n\nclass Person\n{\n int age;\n public Person(int age)\n {\n this.age = age;\n }\n}\n\nThis rule doesn’t report an issue if not all constructors initialize the field. If the field is initialized inline to its default value, then\n{rule:csharpsquid:S3052} already reports an issue on the initialization.
\n\n" }, { "path": "analyzers/rspec/cs/S3604.json", "content": "{\n \"title\": \"Member initializer values should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3604\",\n \"sqKey\": \"S3604\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3610.html", "content": "Calling GetType() on a Type\nobject to typeof(Nullable<SomeType>) will either throw an true or false and can be known at compile time.
\nvoid DoChecks<T>(Nullable<T> value) where T : struct\n{\n bool areEqual = value.GetType() == typeof(Nullable<int>); // Noncompliant: always false\n bool areNotEqual = value.GetType() != typeof(Nullable<int>); // Noncompliant: always true\n\n Nullable<int> nullable = null;\n bool nullComparison = nullable.GetType() != typeof(Nullable<int>); // Noncompliant: throws NullReferenceException\n}\n\n\nvoid DoChecks<T>(Nullable<T> value) where T : struct\n{\n bool areEqual = value.GetType() == typeof(int); // Compliant: can be true or false\n bool areNotEqual = value.GetType() != typeof(int); // Compliant: can be true or false\n\n Nullable<int> nullable = null;\n bool nullComparison = nullable is not null && nullable.GetType() == typeof(int); // Compliant: does not throw NullReferenceException\n}\n\nJump statements, such as return, yield break, goto, and continue are used to change the normal\nflow of execution in a program. However, redundant jump statements can make code difficult to read and maintain.
\nvoid Foo()\n{\n goto A; // Noncompliant\n A:\n while (condition1)\n {\n if (condition2)\n {\n continue; // Noncompliant\n }\n else\n {\n DoTheThing();\n }\n }\n return; // Noncompliant; this is a void method\n}\n\n\nvoid Foo()\n{\n while (condition1)\n {\n if (!condition2)\n {\n DoTheThing();\n }\n }\n}\n\nreturn statements followed by a local function declaration are not considered redundant, as they help with readability.Nullable value types can hold either a value or null.
The value held in the nullable type can be accessed with the Value property or by casting it to the underlying type. Still, both\noperations throw an InvalidOperationException when the value is null. A nullable type should always be tested before\naccessing the value to avoid raising exceptions.
\nvoid Sample(bool condition)\n{\n int? nullableValue = condition ? 42 : null;\n Console.WriteLine(nullableValue.Value); // Noncompliant: InvalidOperationException is raised\n\n int? nullableCast = condition ? 42 : null;\n Console.WriteLine((int)nullableCast); // Noncompliant: InvalidOperationException is raised\n}\n\n\nvoid Sample(bool condition)\n{\n int? nullableValue = condition ? 42 : null;\n if (nullableValue.HasValue)\n {\n Console.WriteLine(nullableValue.Value);\n }\n\n int? nullableCast = condition ? 42 : null;\n if (nullableCast is not null)\n {\n Console.WriteLine((int)nullableCast);\n }\n}\n\nNotImplementedException is often used to mark methods which must be implemented for the overall functionality to be complete, but\nwhich the developer wants to implement later. That’s as opposed to the NotSupportedException which is thrown by methods which are\nrequired by base classes or interfaces, but which are not appropriate to the current class.
This rule raises an exception when NotImplementedException is thrown.
\nvoid doTheThing()\n{\n throw new NotImplementedException();\n}\n\nExceptions derived from NotImplementedException are ignored.
This rule raises an issue when the code cognitive complexity of a function is above a certain threshold.
\nCognitive Complexity is a measure of how hard it is to understand the control flow of a unit of code. Code with high cognitive complexity is hard\nto read, understand, test, and modify.
\nAs a rule of thumb, high cognitive complexity is a sign that the code should be refactored into smaller, easier-to-manage pieces.
\nHere are the core concepts:
\nThe method of computation is fully detailed in the pdf linked in the resources.
\nDevelopers spend more time reading and understanding code than writing it. High cognitive complexity slows down changes and increases the cost of\nmaintenance.
\nReducing cognitive complexity can be challenging.\n
\n Here are a few suggestions:
.? or ?? operator replaces multiple tests and simplifies the flow.Extraction of a complex condition in a new function.
\nThe code is using a complex condition and has a cognitive cost of 3.
\n\ndecimal CalculateFinalPrice(User user, Cart cart)\n{\n decimal total = CalculateTotal(cart);\n if (user.HasMembership() // +1 (if)\n && user.OrdersCount > 10 // +1 (more than one condition)\n && user.AccountActive\n && !user.HasDiscount\n || user.OrdersCount == 1) // +1 (change of operator in condition)\n {\n\n total = ApplyDiscount(user, total);\n }\n return total;\n}\n\nEven if the cognitive complexity of the whole program did not change, it is easier for a reader to understand the code of the\ncalculateFinalPrice function, which now only has a cognitive cost of 1.
\ndecimal CalculateFinalPrice(User user, Cart cart)\n{\n decimal total = CalculateTotal(cart);\n if (IsEligibleForDiscount(user)) // +1 (if)\n {\n total = applyDiscount(user, total);\n }\n return total;\n}\n\nbool IsEligibleForDiscount(User user)\n{\n return user.HasMembership()\n && user.OrdersCount > 10 // +1 (more than one condition)\n && user.AccountActive\n && !user.HasDiscount\n || user.OrdersCount == 1; // +1 (change of operator in condition)\n}\n\nBreak down large functions.
\nFor example, consider a function that calculates the total price of a shopping cart, including sales tax and shipping.\n
\n Note: The code is simplified here, to illustrate the purpose. Please imagine there is more happening in the foreach loops.
\ndecimal CalculateTotal(Cart cart)\n{\n decimal total = 0;\n foreach (Item item in cart.Items) // +1 (foreach)\n {\n total += item.Price;\n }\n\n // calculateSalesTax\n foreach (Item item in cart.Items) // +1 (foreach)\n {\n total += 0.2m * item.Price;\n }\n\n //calculateShipping\n total += 5m * cart.Items.Count;\n\n return total;\n}\n\nThis function could be refactored into smaller functions: The complexity is spread over multiple functions and the complex\nCalculateTotal has now a complexity score of zero.
\ndecimal CalculateTotal(Cart cart)\n{\n decimal total = 0;\n total = CalculateSubtotal(cart, total);\n total += CalculateSalesTax(cart, total);\n total += CalculateShipping(cart, total);\n return total;\n}\n\ndecimal CalculateSubtotal(Cart cart, decimal total)\n{\n foreach (Item item in cart.Items) // +1 (foreach)\n {\n total += item.Price;\n }\n\n return total;\n}\n\ndecimal CalculateSalesTax(Cart cart, decimal total)\n{\n foreach (Item item in cart.Items) // +1 (foreach)\n {\n total += 0.2m * item.Price;\n }\n\n return total;\n}\n\ndecimal CalculateShipping(Cart cart, decimal total)\n{\n total += 5m * cart.Items.Count;\n return total;\n}\n\nAvoid deep nesting by returning early.
\nThe below code has a cognitive complexity of 6.
\n\ndecimal CalculateDiscount(decimal price, User user)\n{\n if (IsEligibleForDiscount(user)) // +1 ( if )\n {\n if (user.HasMembership()) // +2 ( nested if )\n {\n return price * 0.9m;\n }\n else if (user.OrdersCount == 1) // +1 ( else )\n {\n return price * 0.95m;\n }\n else // +1 ( else )\n {\n return price;\n }\n }\n else // +1 ( else )\n {\n return price;\n }\n}\n\nChecking for the edge case first flattens the if statements and reduces the cognitive complexity to 3.
\ndecimal CalculateDiscount(decimal price, User user)\n{\n if (!IsEligibleForDiscount(user)) // +1 ( if )\n {\n return price;\n }\n\n if (user.HasMembership()) // +1 ( if )\n {\n return price * 0.9m;\n }\n\n if (user.OrdersCount == 1) // +1 ( else )\n {\n return price * 0.95m;\n }\n\n return price;\n}\n\nUse the null-conditional operator to access data.
\nIn the below code, the cognitive complexity is increased due to the multiple checks required to access the manufacturer’s name. This can be\nsimplified using the optional chaining operator.
\n\nstring GetManufacturerName(Product product)\n{\n string manufacturerName = null;\n if (product != null && product.Details != null &&\n product.Details.Manufacturer != null) // +1 (if) +1 (multiple condition)\n {\n manufacturerName = product.Details.Manufacturer.Name;\n }\n\n if (manufacturerName != null) // +1 (if)\n {\n return manufacturerName;\n }\n\n return \"Unknown\";\n}\n\nThe optional chaining operator will return null if any reference in the chain is null, avoiding multiple checks. The\n?? operator allows to provide the default value to use.
\nstring GetManufacturerName(Product product)\n{\n return product?.Details?.Manufacturer?.Name ?? \"Unknown\";\n}\n\nAs this code is complex, ensure that you have unit tests that cover the code before refactoring.
\nThe SafeHandle.DangerousGetHandle method poses significant risks and should be used carefully. This method carries the inherent danger\nof potentially returning an invalid handle, which can result in resource leaks and security vulnerabilities. Although it is technically possible to\nutilize this method without encountering issues, doing so correctly requires a high level of expertise. Therefore, it is recommended to avoid using\nthis method altogether.
The SafeHandle.DangerousGetHandle method is potentially prone to leaks and vulnerabilities due to its nature and usage. Here are a few\nreasons why:
SafeHandle class, there is an increased risk of failing to dispose system resources correctly.SafeHandle.DangerousGetHandle without proper validation can lead to security vulnerabilities that can be exploited by an attacker.\nstatic void Main(string[] args)\n{\n System.Reflection.FieldInfo fieldInfo = ...;\n SafeHandle handle = (SafeHandle)fieldInfo.GetValue(rKey);\n IntPtr dangerousHandle = handle.DangerousGetHandle(); // Noncompliant\n}\n\nThe point of having custom exception types is to convey more information than is available in standard types. But custom exception types must be\npublic for that to work.
If a method throws a non-public exception, the best you can do on the caller’s side is to catch the closest public base\nof the class. However, you lose all the information that the new exception type carries.
This rule will raise an issue if you directly inherit one of the following exception types in a non-public class:
\n\ninternal class MyException : Exception // Noncompliant\n{\n // ...\n}\n\n\npublic class MyException : Exception\n{\n // ...\n}\n\nThe name of a method should communicate what it does, and the names of its parameters should indicate how they’re used. If a method and its\nparameter have the same name it is an indication that one of these rules of thumb has been broken, if not both. Even if by some trick of language\nthat’s not the case, it is still likely to confuse callers and maintainers.
\n\npublic void Login(string login) // Noncompliant\n{\n //...\n}\n\n\npublic void Login(string userName)\n{\n //...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3872.json",
"content": "{\n \"title\": \"Parameter names should not duplicate the names of their methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\",\n \"confusing\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3872\",\n \"sqKey\": \"S3872\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3874.html",
"content": "Passing a parameter by reference, which is what happens when you use the out or ref parameter modifiers, means that the\nmethod will receive a pointer to the argument, rather than the argument itself. If the argument was a value type, the method will be able to change\nthe argument’s values. If it was a reference type, then the method receives a pointer to a pointer, which is usually not what was intended. Even when\nit is what was intended, this is the sort of thing that’s difficult to get right, and should be used with caution.
This rule raises an issue when out or ref is used on a non-Optional parameter in a public method.\nOptional parameters are covered by {rule:csharpsquid:S3447}.
\npublic void GetReply(\n ref MyClass input, // Noncompliant\n out string reply) // Noncompliant\n{ ... }\n\n\npublic string GetReply(MyClass input)\n{ ... }\n\npublic bool TryGetReply(MyClass input, out string reply)\n{ ... }\n\npublic ReplyData GetReply(MyClass input)\n{ ... }\n\ninternal void GetReply(ref MyClass input, out string reply)\n{ ... }\n\nThis rule will not raise issues for:
\nThe use of == to compare two objects is expected to do a reference comparison. That is, it is expected to return true if\nand only if they are the same object instance. Overloading the operator to do anything else will inevitably lead to the introduction of bugs by\ncallers.
\npublic static bool operator ==(MyType x, MyType y) // Noncompliant: confusing for the caller\n{\n // custom implementation\n}\n\nOn the other hand, overloading it to do exactly that is pointless; that’s what == does by default.
\npublic static bool operator ==(MyType x, MyType y) // Noncompliant: redundant\n{\n if (x == null)\n {\n return y == null;\n }\n\n return object.ReferenceEquals(x,y);\n}\n\noperator + or operator - are ignored.IComparable<T> or IEquatable<T> most probably behave as value-type objects and are\n ignored.Strings and integral types are typically used as indexers. When some other type is required, it typically indicates design problems, and\npotentially a situation where a method should be used instead.
\n\npublic int this[MyCustomClass index] // Noncompliant\n{\n // get and set accessors\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3876.json",
"content": "{\n \"title\": \"Strings or integral types should be used for indexers\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3876\",\n \"sqKey\": \"S3876\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3877.html",
"content": "The rule is reporting when an exception is thrown from certain methods and constructors. These methods are expected to behave in a specific way and\nthrowing an exception from them can lead to unexpected behavior and break the calling code.
\n\npublic override string ToString()\n{\n if (string.IsNullOrEmpty(Name))\n {\n throw new ArgumentException(nameof(Name)); // Noncompliant\n }\n //...\n}\n\nAn issue is raised when an exception is thrown from any of the following:
\nCertain exceptions will be ignored in specific contexts, thus not raising the issue:
\nSystem.NotImplementedException and its derivatives are ignored for all the aforementioned.System.InvalidOperationException, System.NotSupportedException, and System.ArgumentException and their\n derivatives are ignored in event accessors.Creating an array or using a collection expression solely for the purpose of passing it to a params parameter is unnecessary. Simply\npass the elements directly, and they will be automatically consolidated into the appropriate collection type.
\npublic void Base()\n{\n Method(new string[] { \"s1\", \"s2\" }); // Noncompliant: resolves to string[] overload\n Method(new string[] { }); // Noncompliant: resolves to string[] overload\n Method([\"s3\", \"s4\"]); // Noncompliant: resolves to ReadOnlySpan overload\n Method(new string[12]); // Compliant: resolves to string[] overload\n}\n\npublic void Method(params string[] args)\n{\n // ...\n}\n\npublic void Method(params ReadOnlySpan<string> args) // C# 13 params collections\n{\n // C# 13 params collection\n}\n\n\npublic void Base()\n{\n Method(\"s1\", \"s2\"); // resolves to ReadOnlySpan overload\n Method(); // resolves to ReadOnlySpan overload\n Method(\"s3\", \"s4\"); // resolves to ReadOnlySpan overload\n Method(new string[12]); // resolves to string[] overload\n}\n\npublic void Method(params string[] args)\n{\n // ..\n}\n\npublic void Method(params ReadOnlySpan<string> args) // C# 13 params collections\n{\n // ..\n}\n\nparams\n modifierparams\n collectionsFinalizers come with a performance cost due to the overhead of tracking the life cycle of objects. An empty one is consequently costly with no\nbenefit or justification.
\n\npublic class Foo\n{\n ~Foo() // Noncompliant\n {\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3880.json",
"content": "{\n \"title\": \"Finalizers should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3880\",\n \"sqKey\": \"S3880\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3881.html",
"content": "The IDisposable interface is a mechanism to release unmanaged resources, if not implemented correctly this could result in resource\nleaks or more severe bugs.
This rule raises an issue when the recommended dispose pattern, as defined by Microsoft, is not adhered to. See the Compliant\nSolution section for examples.
\nSatisfying the rule’s conditions will enable potential derived classes to correctly dispose the members of your class:
\nsealed classes are not checked.IDisposable your class should not have IDisposable in the list of its interfaces. In such\n cases it is recommended to override the base class’s protected virtual void Dispose(bool) method or its equivalent.IDisposable explicitly, e.g. the Dispose() method should be public.protected virtual void Dispose(bool) method. This method allows the derived classes to correctly dispose\n the resources of this class.Dispose() method should be invocation of Dispose(true) followed by\n GC.SuppressFinalize(this)Dispose(false).IDisposable it must call the Dispose, or Dispose(bool)\n method of the base class from within its own implementation of Dispose or Dispose(bool), respectively. This ensures that\n all resources from the base class are properly released.\npublic class Foo1 : IDisposable // Noncompliant - provide protected overridable implementation of Dispose(bool) on Foo or mark the type as sealed.\n{\n public void Dispose() // Noncompliant - should contain only a call to Dispose(true) and then GC.SuppressFinalize(this)\n {\n // Cleanup\n }\n}\n\npublic class Foo2 : IDisposable\n{\n void IDisposable.Dispose() // Noncompliant - Dispose() should be public\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n\n public virtual void Dispose() // Noncompliant - Dispose() should be sealed\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n}\n\npublic class Foo3 : IDisposable\n{\n public void Dispose()\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n\n protected virtual void Dispose(bool disposing)\n {\n // Cleanup\n }\n\n ~Foo3() // Noncompliant - Modify Foo.~Foo() so that it calls Dispose(false) and then returns.\n {\n // Cleanup\n }\n}\n\n\n// Sealed class\npublic sealed class Foo1 : IDisposable\n{\n public void Dispose()\n {\n // Cleanup\n }\n}\n\n// Simple implementation\npublic class Foo2 : IDisposable\n{\n public void Dispose()\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n\n protected virtual void Dispose(bool disposing)\n {\n // Cleanup\n }\n}\n\n// Implementation with a finalizer\npublic class Foo3 : IDisposable\n{\n public void Dispose()\n {\n Dispose(true);\n GC.SuppressFinalize(this);\n }\n\n protected virtual void Dispose(bool disposing)\n {\n // Cleanup\n }\n\n ~Foo3()\n {\n Dispose(false);\n }\n}\n\n// Base disposable class\npublic class Foo4 : DisposableBase\n{\n protected override void Dispose(bool disposing)\n {\n // Cleanup\n // Do not forget to call base\n base.Dispose(disposing);\n }\n}\n\nThis rule is deprecated, and will eventually be removed.
\nCoSetProxyBlanket and CoInitializeSecurity both work to set the permissions context in which the process invoked\nimmediately after is executed. Calling them from within that process is useless because it’s too late at that point; the permissions context has\nalready been set.
Specifically, these methods are meant to be called from non-managed code such as a C++ wrapper that then invokes the managed, i.e. C# or VB.NET,\ncode.
\n\n[DllImport(\"ole32.dll\")]\nstatic extern int CoSetProxyBlanket([MarshalAs(UnmanagedType.IUnknown)]object pProxy, uint dwAuthnSvc, uint dwAuthzSvc,\n\t[MarshalAs(UnmanagedType.LPWStr)] string pServerPrincName, uint dwAuthnLevel, uint dwImpLevel, IntPtr pAuthInfo,\n\tuint dwCapabilities);\n\npublic enum RpcAuthnLevel\n{\n\tDefault = 0,\n\tNone = 1,\n\tConnect = 2,\n\tCall = 3,\n\tPkt = 4,\n\tPktIntegrity = 5,\n\tPktPrivacy = 6\n}\n\npublic enum RpcImpLevel\n{\n\tDefault = 0,\n\tAnonymous = 1,\n\tIdentify = 2,\n\tImpersonate = 3,\n\tDelegate = 4\n}\n\npublic enum EoAuthnCap\n{\n\tNone = 0x00,\n\tMutualAuth = 0x01,\n\tStaticCloaking = 0x20,\n\tDynamicCloaking = 0x40,\n\tAnyAuthority = 0x80,\n\tMakeFullSIC = 0x100,\n\tDefault = 0x800,\n\tSecureRefs = 0x02,\n\tAccessControl = 0x04,\n\tAppID = 0x08,\n\tDynamic = 0x10,\n\tRequireFullSIC = 0x200,\n\tAutoImpersonate = 0x400,\n\tNoCustomMarshal = 0x2000,\n\tDisableAAA = 0x1000\n}\n\n[DllImport(\"ole32.dll\")]\npublic static extern int CoInitializeSecurity(IntPtr pVoid, int cAuthSvc, IntPtr asAuthSvc, IntPtr pReserved1,\n\tRpcAuthnLevel level, RpcImpLevel impers, IntPtr pAuthList, EoAuthnCap dwCapabilities, IntPtr pReserved3);\n\nstatic void Main(string[] args)\n{\n\tvar hres1 = CoSetProxyBlanket(null, 0, 0, null, 0, 0, IntPtr.Zero, 0); // Noncompliant\n\n\tvar hres2 = CoInitializeSecurity(IntPtr.Zero, -1, IntPtr.Zero, IntPtr.Zero, RpcAuthnLevel.None,\n\t\tRpcImpLevel.Impersonate, IntPtr.Zero, EoAuthnCap.None, IntPtr.Zero); // Noncompliant\n}\n\nThe parameter to Assembly.Load includes the full specification of the dll to be loaded. Use another method, and you might end up with\na dll other than the one you expected.
This rule raises an issue when Assembly.LoadFrom, Assembly.LoadFile, or Assembly.LoadWithPartialName is\ncalled.
The rule does not raise an issue when the methods are used within an AssemblyResolve event handler. In this context,\nusing Assembly.Load can cause a StackOverflowException due to recursive event firing, making Assembly.LoadFrom\nor Assembly.LoadFile the appropriate choices.
\nstatic void Main()\n{\n AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;\n}\n\nstatic Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)\n{\n return Assembly.LoadFrom(\"MyAssembly.dll\"); // Compliant: within AssemblyResolve handler\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.LoadFrom(\"MyAssembly.dll\"); // Noncompliant\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.LoadFile(@\"C:\\MyPath\\MyAssembly.dll\"); // Noncompliant\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.LoadWithPartialName(\"MyAssembly\"); // Noncompliant\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.Load(\"MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\"); // Compliant\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.Load(\"MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\"); // Compliant\n}\n\n\nstatic void Main(string[] args)\n{\n Assembly.Load(\"MyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\"); // Compliant\n}\n\nUsing the readonly keyword on a\nfield means it can’t be changed after initialization. However, that’s only partly true when applied to collections or arrays. The\nreadonly keyword enforces that another instance can’t be assigned to the field, but it cannot keep the contents from being updated. In\npractice, the field value can be changed, and the use of readonly on such a field is misleading, and you’re likely not getting the\nbehavior you expect.
This rule raises an issue when a non-private, readonly field is an array or collection.
To fix this, you should either use an immutable or readonly modifier to\nclarify the behavior.
\npublic class MyClass\n{\n public readonly string[] strings1; // Noncompliant\n public readonly string[] strings2; // Noncompliant\n public readonly string[] strings3; // Noncompliant\n // ...\n}\n\n\npublic class MyClass\n{\n public string[] strings1; // Compliant: remove readonly modifier\n public readonly ImmutableArray<string> strings; // Compliant: use an Immutable collection\n private readonly string[] strings; // Compliant: reduced accessibility to private\n\n // ...\n}\n\nThread.Suspend and Thread.Resume can give unpredictable results, and both methods have been deprecated. Indeed, if\nThread.Suspend is not used very carefully, a thread can be suspended while\nholding a lock, thus leading to a
There are other synchronization mechanisms that are safer and should be used instead, such as:
\nMonitor provides a mechanism that synchronizes access to objects.Mutex provides a mechanism that synchronizes interprocess access to a protected resource.Semaphore provides a mechanism that allows limiting the number of threads that have access to a protected resources\n concurrently.Events enable a class to notify others when something of interest occurs.The IEquatable<T> interface has only one method in it: Equals(<T>). If you’ve already written\nEquals(T), there’s no reason not to explicitly implement IEquatable<T>. Doing so expands the utility of your class by\nallowing it to be used where an IEquatable is called for.
Note: Classes that implement IEquatable<T> should also be sealed.
\nclass MyClass // Noncompliant\n{\n public bool Equals(MyClass other)\n {\n //...\n }\n}\n\n\nsealed class MyClass : IEquatable<MyClass>\n{\n public override bool Equals(object other)\n {\n return Equals(other as MyClass);\n }\n\n public bool Equals(MyClass other)\n {\n //...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3897.json",
"content": "{\n \"title\": \"Classes that provide \\\"Equals(\\u003cT\\u003e)\\\" should implement \\\"IEquatable\\u003cT\\u003e\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3897\",\n \"sqKey\": \"S3897\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3898.html",
"content": "If you’re using a struct, it is likely because you’re interested in performance. But by failing to implement\nIEquatable<T> you’re loosing performance when comparisons are made because without IEquatable<T>, boxing and\nreflection are used to make comparisons.
\nstruct MyStruct // Noncompliant\n{\n public int Value { get; set; }\n}\n\n\nstruct MyStruct : IEquatable<MyStruct>\n{\n public int Value { get; set; }\n\n public bool Equals(MyStruct other)\n {\n // ...\n }\n}\n\nMethods declared as public, protected, or protected internal can be accessed from other assemblies, which\nmeans you should validate parameters to be within the expected constraints. In general, checking against null is recommended in defensive\nprogramming.
This rule raises an issue when a parameter of a publicly accessible method is not validated against null before being\ndereferenced.
\npublic class MyClass\n{\n private MyOtherClass other;\n\n public void Foo(MyOtherClass other)\n {\n this.other = other.Clone(); // Noncompliant\n }\n\n protected void Bar(MyOtherClass other)\n {\n this.other = other.Clone(); // Noncompliant\n }\n}\n\n\npublic class MyClass\n{\n private MyOtherClass other;\n\n public void Foo(MyOtherClass other)\n {\n if (other != null)\n {\n this.other = other.Clone();\n }\n }\n\n protected void Bar(MyOtherClass other)\n {\n if (other != null)\n {\n this.other = other.Clone();\n }\n }\n\n public void Baz(MyOtherClass other)\n {\n ArgumentNullException.ThrowIfNull(other);\n\n this.other = other.Clone();\n }\n\n public void Qux(MyOtherClass other)\n {\n this.other = other; // Compliant: \"other\" is not being dereferenced\n }\n\n private void Xyzzy(MyOtherClass other)\n {\n this.other = other.Clone(); // Compliant: method is not publicly accessible\n }\n}\n\nnull via helper methods should be annotated with the [NotNull] attribute.[NotNull] ValidatedNotNullAttribute and mark the parameter that is\n validated for null in your method declaration with it:\nusing System;\n\n[AttributeUsage(AttributeTargets.Parameter, Inherited=false)]\npublic sealed class ValidatedNotNullAttribute : Attribute { }\n\npublic static class Guard\n{\n public static void NotNull<T>([ValidatedNotNullAttribute] T value, [CallerArgumentExpression(\"value\")] string name = \"\") where T : class\n {\n if (value == null)\n throw new ArgumentNullException(name);\n }\n}\n\npublic static class Utils\n{\n public static string ToUpper(string value)\n {\n Guard.NotNull(value);\n\n return value.ToUpper(); // Compliant\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3900.json",
"content": "{\n \"title\": \"Arguments of public methods should be validated against null\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\",\n \"symbolic-execution\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3900\",\n \"sqKey\": \"S3900\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3902.html",
"content": "Using Type.Assembly to get the current assembly is nearly free in terms of performance; it’s a simple property access. On the other\nhand, Assembly.GetExecutingAssembly() can take up to 30 times as long because it walks up the call stack to find the assembly.
Note that Assembly.GetExecutingAssembly() is different than Type.Assembly because it dynamically returns the assembly\nthat contains the startup object of the currently executed application. For example, if executed from an application it will return the application\nassembly, but if executed from a unit test project it could return the unit test assembly. Type.Assembly always returns the assembly that\ncontains the specified type.
\npublic class Example\n{\n public static void Main()\n {\n Assembly assem = Assembly.GetExecutingAssembly(); // Noncompliant\n Console.WriteLine(\"Assembly name: {0}\", assem.FullName);\n }\n}\n\n\npublic class Example\n{\n public static void Main()\n {\n Assembly assem = typeof(Example).Assembly; // Here we use the type of the current class\n Console.WriteLine(\"Assembly name: {0}\", assem.FullName);\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3902.json",
"content": "{\n \"title\": \"\\\"Assembly.GetExecutingAssembly\\\" should not be called\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3902\",\n \"sqKey\": \"S3902\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3903.html",
"content": "Types are declared in namespaces in order to prevent name collisions and as a way to organize them into the object hierarchy. Types that are\ndefined outside any named namespace are in a global namespace that cannot be referenced in code.
\n\npublic class Foo // Noncompliant\n{\n}\n\npublic struct Bar // Noncompliant\n{\n}\n\n\nnamespace SomeSpace\n{\n public class Foo\n {\n }\n\n public struct Bar\n {\n }\n}\n\nor alternatively in C#10 and above
\n\nnamespace SomeSpace;\npublic class Foo\n{\n}\n\npublic struct Bar\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3903.json",
"content": "{\n \"title\": \"Types should be defined in named namespaces\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"MODULAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3903\",\n \"sqKey\": \"S3903\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3904.html",
"content": "The AssemblyVersion attribute is used to\nspecify the version number of an assembly. An assembly is a compiled unit of code, which can be marked with a version number by applying the attribute\nto an assembly’s source code file.
\nThe AssemblyVersion attribute is useful for many reasons:
AssemblyVersion attribute, you can ensure that the correct version of the referenced assembly is used. This\n helps avoid compatibility issues and ensures that the expected behavior and functionality are maintained.If no AssemblyVersion is provided, the same default version will be used for every build. Since the version number is used by .NET\nFramework to uniquely identify an assembly, this can lead to broken dependencies.
\nusing System.Reflection;\n\n[assembly: AssemblyTitle(\"MyAssembly\")] // Noncompliant\nnamespace MyLibrary\n{\n // ...\n}\n\n\nusing System.Reflection;\n\n[assembly: AssemblyTitle(\"MyAssembly\")]\n[assembly: AssemblyVersion(\"42.1.125.0\")]\nnamespace MyLibrary\n{\n // ...\n}\n\nDelegate event handlers (i.e. delegates used as type of an event) should have a very specific signature:
\nvoid.System.Object and named 'sender'.System.EventArgs (or any derived type) and is named 'e'.This rule raises an issue whenever a delegate declaration doesn’t match that signature.
\npublic delegate void AlarmEventHandler(object s);\n\npublic class Foo\n{\n public event AlarmEventHandler AlarmEvent; // Noncompliant\n}\n\n\npublic delegate void AlarmEventHandler(object sender, AlarmEventArgs e);\n\npublic class Foo\n{\n public event AlarmEventHandler AlarmEvent; // Compliant\n}\n\nSince .Net Framework version 2.0 it is not necessary to declare a delegate that specifies a class derived from System.EventArgs. The\nSystem.EventHandler<TEventArgs> delegate mechanism should be used instead as it allows any class derived from\nEventArgs to be used with that handler.
This rule raises an issue when an old style delegate is used as an event handler.
\n\npublic class MyEventArgs : EventArgs\n{\n}\n\npublic delegate void MyEventHandler(object sender, MyEventArgs e); // Noncompliant\n\npublic class EventProducer\n{\n public event MyEventHandler MyEvent;\n\n protected virtual void OnMyEvent(MyEventArgs e)\n {\n if (MyEvent != null)\n {\n MyEvent(e);\n }\n }\n}\n\npublic class EventConsumer\n{\n public EventConsumer(EventProducer producer)\n {\n producer.MyEvent += HandleEvent;\n }\n\n private void HandleEvent(object sender, MyEventArgs e)\n {\n // Do something...\n }\n}\n\n\npublic class MyEventArgs : EventArgs\n{\n}\n\npublic class EventProducer\n{\n public event EventHandler<MyEventArgs> MyEvent;\n\n protected virtual void OnMyEvent(MyEventArgs e)\n {\n if (MyEvent != null)\n {\n MyEvent(e);\n }\n }\n}\n\npublic class EventConsumer\n{\n public EventConsumer(EventProducer producer)\n {\n producer.MyEvent += HandleEvent;\n }\n\n private void HandleEvent(object sender, MyEventArgs e)\n {\n // Do something...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3908.json",
"content": "{\n \"title\": \"Generic event handlers should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3908\",\n \"sqKey\": \"S3908\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3909.html",
"content": "The NET Framework 2.0 introduced the generic interface System.Collections.Generic.IEnumerable<T> and it should be preferred over\nthe older, non generic, interfaces.
This rule raises an issue when a public type implements System.Collections.IEnumerable.
\nusing System;\nusing System.Collections;\n\npublic class MyData\n{\n public MyData()\n {\n }\n}\n\npublic class MyList : CollectionBase // Noncompliant\n{\n public void Add(MyData data)\n {\n InnerList.Add(data);\n }\n\n // ...\n}\n\n\nusing System;\nusing System.Collections.ObjectModel;\n\npublic class MyData\n{\n public MyData()\n {\n }\n}\n\npublic class MyList : Collection<MyData>\n{\n // Implementation...\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3909.json",
"content": "{\n \"title\": \"Collections should implement the generic interface\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3909\",\n \"sqKey\": \"S3909\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3923.html",
"content": "Having all branches of a switch or if chain with the same implementation indicates a problem.
In the following code:
\n\nif (b == 0) // Noncompliant\n{\n DoTheThing();\n}\nelse\n{\n DoTheThing();\n}\n\nint b = a > 12 ? 4 : 4; // Noncompliant\n\nswitch (i) // Noncompliant\n{\n case 1:\n DoSomething();\n break;\n case 2:\n DoSomething();\n break;\n case 3:\n DoSomething();\n break;\n default:\n DoSomething();\n}\n\nEither there is a copy-paste error that needs fixing or an unnecessary switch or if chain that should be removed.
This rule does not apply to if chains without else, nor to switch without a default clause.
\nif (b == 0) //no issue, this could have been done on purpose to make the code more readable\n{\n DoSomething();\n}\nelse if (b == 1)\n{\n DoSomething();\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3923.json",
"content": "{\n \"title\": \"All branches in a conditional structure should not have exactly the same implementation\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3923\",\n \"sqKey\": \"S3923\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3925.html",
"content": "The ISerializable interface is\nthe mechanism to control the type serialization process. If not implemented correctly this could result in an invalid serialization and hard-to-detect\nbugs.
This rule raises an issue on types that implement ISerializable without following the
Specifically, this rule checks for these problems:
\nSerializableAttribute attribute is\n missing.NonSerializedAttribute attribute.protected.private.ISerializable.GetObjectData that is not both public and virtual.base constructor.ISerializable.GetObjectData method that does not call the base method.ISerializable.GetObjectData method is not overridden.Classes that inherit from Exception are implementing\nISerializable. Make sure the [Serializable] attribute is used and that ISerializable is correctly implemented.\nEven if you don’t plan to explicitly serialize the object yourself, it might still require serialization, for instance when crossing the boundary of\nan AppDomain.
This rule only raises an issue on classes that indicate that they are interested in serialization (see the Exceptions section). That is to\nreduce noise because a lot of classes in the base class library are implementing ISerializable, including the following classes: Exception, Uri, Hashtable, Dictionary<TKey,TValue>, DataSet, HttpWebRequest, Regex TreeNode, and others. There is often no need to add\nserialization support in classes derived from these types.
[Serializable] attributeISerializable in their base type list\n[Serializable] // 1.\npublic class SerializationOptIn_Attribute\n{\n}\n\npublic class SerializationOptIn_Interface : ISerializable // 2.\n{\n}\n\npublic class SerializationOptIn_Constructor\n{\n protected SerializationOptIn_Constructor(SerializationInfo info, StreamingContext context) // 3.\n {\n }\n}\n\nMake sure to follow the recommended guidelines when\nimplementing ISerializable.
\npublic class Bar\n{\n}\n\npublic class Foo : ISerializable // Noncompliant: serialization constructor is missing\n // Noncompliant: the [Serializable] attribute is missing\n{\n private readonly Bar bar; // Noncompliant: the field is not marked with [NonSerialized]\n}\n\npublic sealed class SealedFoo : Foo\n{\n private int val; // Noncompliant: 'val' is serializable and GetObjectData is not overridden\n\n public SealedFoo()\n {\n // ...\n }\n\n public SealedFoo(SerializationInfo info, StreamingContext context) // Noncompliant: serialization constructor is not `private`\n // Noncompliant: serialization constructor does not call base constructor\n {\n // ...\n }\n}\n\npublic class UnsealedFoo : Foo\n{\n public UnsealedFoo()\n {\n // ...\n }\n\n public UnsealedFoo(SerializationInfo info, StreamingContext context) // Noncompliant: serialization constructor is not `protected`\n : base(info, context)\n {\n // ...\n }\n\n protected void GetObjectData(SerializationInfo info, StreamingContext context) // Noncompliant: GetObjectData is not public virtual\n {\n // Noncompliant: does not call base.GetObjectData(info, context)\n }\n}\n\n\npublic class Bar\n{\n}\n\n[Serializable]\npublic class Foo : ISerializable // Compliant: the class is marked with [Serializable]\n{\n [NonSerialized]\n private readonly Bar bar; // Compliant: the field is marked with [NonSerialized]\n\n public Foo()\n {\n // ...\n }\n\n protected Foo(SerializationInfo info, StreamingContext context) // Compliant: serialization constructor is present\n {\n // ...\n }\n\n public virtual void GetObjectData(SerializationInfo info, StreamingContext context)\n {\n // ...\n }\n}\n\n[Serializable]\npublic sealed class SealedFoo : Foo\n{\n private int val; // Compliant: 'val' is serializable and GetObjectData is overridden\n\n public SealedFoo()\n {\n // ...\n }\n\n private SealedFoo(SerializationInfo info, StreamingContext context) // Compliant: serialization constructor is `private`\n : base(info, context) // Compliant: serialization constructor calls base constructor\n {\n // ...\n }\n\n public override void GetObjectData(SerializationInfo info, StreamingContext context)\n {\n base.GetObjectData(info, context);\n // ...\n }\n}\n\n[Serializable]\npublic class UnsealedFoo : Foo\n{\n public UnsealedFoo()\n {\n // ...\n }\n\n protected UnsealedFoo(SerializationInfo info, StreamingContext context) // Compliant: serialization constructor is `protected`\n : base(info, context)\n {\n // ...\n }\n\n public virtual void GetObjectData(SerializationInfo info, StreamingContext context) // Compliant: GetObjectData is public virtual\n {\n base.GetObjectData(info, context); // Compliant: calls base.GetObjectData(info, context)\n // ...\n\n }\n}\n\nISerializable\n InterfaceSerializableAttribute\n ClassNonSerializedAttribute\n ClassISerializable.GetObjectData MethodException ClassFields marked with System.Runtime.Serialization.OptionalFieldAttribute are serialized just like any other field. But such fields are\nignored on deserialization, and retain the default values associated with their types. Therefore, deserialization event handlers should be declared to\nset such fields during the deserialization process.
This rule raises when at least one field with the System.Runtime.Serialization.OptionalFieldAttribute attribute is declared but one\n(or both) of the following event handlers System.Runtime.Serialization.OnDeserializingAttribute or\nSystem.Runtime.Serialization.OnDeserializedAttribute are not present.
\n[Serializable]\npublic class Foo\n{\n [OptionalField(VersionAdded = 2)]\n int optionalField = 5;\n}\n\n\n[Serializable]\npublic class Foo\n{\n [OptionalField(VersionAdded = 2)]\n int optionalField = 5;\n\n [OnDeserializing]\n void OnDeserializing(StreamingContext context)\n {\n\t optionalField = 5;\n }\n\n [OnDeserialized]\n void OnDeserialized(StreamingContext context)\n {\n // Set optionalField if dependent on other deserialized values.\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3926.json",
"content": "{\n \"title\": \"Deserialization methods should be provided for \\\"OptionalField\\\" members\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"serialization\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3926\",\n \"sqKey\": \"S3926\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3927.html",
"content": "Serialization event handlers that don’t have the correct signature will not be called, bypassing augmentations to automated serialization and\ndeserialization events.
\nA method is designated a serialization event handler by applying one of the following serialization event attributes:
\nOnSerializingAttributeOnSerializedAttributeOnDeserializingAttributeOnDeserializedAttributeSerialization event handlers take a single parameter of type StreamingContext, return\nvoid, and have private visibility.
This rule raises an issue when any of these constraints are not respected.
\n\n[Serializable]\npublic class Foo\n{\n [OnSerializing]\n public void OnSerializing(StreamingContext context) {} // Noncompliant: should be private\n\n [OnSerialized]\n int OnSerialized(StreamingContext context) {} // Noncompliant: should return void\n\n [OnDeserializing]\n void OnDeserializing() {} // Noncompliant: should have a single parameter of type StreamingContext\n\n [OnSerializing]\n public void OnSerializing2<T>(StreamingContext context) {} // Noncompliant: should have no type parameters\n\n [OnDeserialized]\n void OnDeserialized(StreamingContext context, string str) {} // Noncompliant: should have a single parameter of type StreamingContext\n}\n\n\n[Serializable]\npublic class Foo\n{\n [OnSerializing]\n private void OnSerializing(StreamingContext context) {}\n\n [OnSerialized]\n private void OnSerialized(StreamingContext context) {}\n\n [OnDeserializing]\n private void OnDeserializing(StreamingContext context) {}\n\n [OnDeserialized]\n private void OnDeserialized(StreamingContext context) {}\n}\n\nSome constructors of the ArgumentException, ArgumentNullException, ArgumentOutOfRangeException and\nDuplicateWaitObjectException classes must be fed with a valid parameter name. This rule raises an issue in two cases:
\npublic void Foo(Bar a, int[] b)\n{\n throw new ArgumentException(); // Noncompliant\n throw new ArgumentException(\"My error message\", \"c\"); // Noncompliant\n throw new ArgumentException(\"My error message\", \"c\", innerException); // Noncompliant\n\n throw new ArgumentNullException(\"c\"); // Noncompliant\n throw new ArgumentNullException(nameof(c)); // Noncompliant\n throw new ArgumentNullException(\"My error message\", \"a\"); // Noncompliant\n\n throw new ArgumentOutOfRangeException(\"c\"); // Noncompliant\n throw new ArgumentOutOfRangeException(\"c\", \"My error message\"); // Noncompliant\n throw new ArgumentOutOfRangeException(\"c\", b, \"My error message\"); // Noncompliant\n\n throw new DuplicateWaitObjectException(\"c\", \"My error message\"); // Noncompliant\n}\n\n\npublic void Foo(Bar a, int[] b)\n{\n throw new ArgumentException(\"My error message\", \"a\");\n throw new ArgumentException(\"My error message\", \"b\", innerException);\n\n throw new ArgumentNullException(\"a\");\n throw new ArgumentNullException(nameof(a));\n throw new ArgumentNullException(\"a\", \"My error message\");\n\n throw new ArgumentOutOfRangeException(\"b\");\n throw new ArgumentOutOfRangeException(\"b\", \"My error message\");\n throw new ArgumentOutOfRangeException(\"b\", b, \"My error message\");\n\n throw new DuplicateWaitObjectException(\"b\", \"My error message\");\n}\n\nThe rule won’t raise an issue if the parameter name is not a constant value.
\n\n" }, { "path": "analyzers/rspec/cs/S3928.json", "content": "{\n \"title\": \"Parameter names used into ArgumentException constructors should match an existing one \",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3928\",\n \"sqKey\": \"S3928\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3937.html", "content": "The use of punctuation characters to separate subgroups in a number can make the number more readable. For instance consider 1,000,000,000 versus\n1000000000. But when the grouping is irregular, such as 1,000,00,000; it indicates an error.
\nThis rule raises an issue when underscores (_) are used to break a number into irregular subgroups.
\nint thousand = 100_0;\nint tenThousand = 100_00;\nint million = 1_000_00_000;\n\n
\nint thousand = 1000;\nint tenThousand = 10_000;\nint tenThousandWithout = 10000;\nint duos = 1_00_00;\nint million = 100_000_000;\n\n\n" }, { "path": "analyzers/rspec/cs/S3937.json", "content": "{\n \"title\": \"Number patterns should be regular\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-3937\",\n \"sqKey\": \"S3937\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3949.html", "content": "
Numbers are infinite, but the types that hold them are not. Each numeric type has hard upper and lower bounds. Try to calculate or assign numbers\nbeyond those bounds, and the result will be a value that has silently wrapped around from the expected positive value to a negative one, or vice\nversa.
\n\npublic int Transform(int value)\n{\n if (value <= 0)\n {\n return value;\n }\n int number = int.MaxValue;\n return number + value; // Noncompliant\n}\n\n\npublic long Transform(int value)\n{\n if (value <= 0)\n {\n return value;\n }\n long number = int.MaxValue;\n return number + value;\n}\n\nSystem.Collections.Generic.List<T> is a generic collection that is designed for performance and not inheritance. For example, it\ndoes not contain virtual members that make it easier to change the behavior of an inherited class. That means that future attempts to expand the\nbehavior will be spoiled because the extension points simply aren’t there. Instead, one of the following generic collections should be used:
System.Collections.Generic.IEnumerable<T>System.Collections.Generic.IReadOnlyCollection<T>System.Collections.Generic.ICollection<TKey>System.Collections.Generic.IReadOnlyList<T>System.Collections.Generic.IList<TKey>System.Collections.ObjectModel.Collection<T>System.Collections.ObjectModel.ReadOnlyCollection<T>System.Collections.ObjectModel.KeyedCollection<TKey, Titem>This rule raises an issue every time a System.Collections.Generic.List<T> is exposed:
\nnamespace Foo\n{\n public class Bar\n {\n public List<T> Method1(T arg) // Noncompliant\n {\n //...\n }\n }\n}\n\n\nnamespace Foo\n{\n public class Bar\n {\n public Collection<T> Method1(T arg)\n {\n //...\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3956.json",
"content": "{\n \"title\": \"\\\"Generic.List\\\" instances should not be part of public APIs\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3956\",\n \"sqKey\": \"S3956\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3962.html",
"content": "The value of a static readonly field is computed at runtime while the value of a const field is calculated at compile\ntime, which improves performance.
This rule raises an issue when a static readonly field is initialized with a value that is computable at compile time.
As specified by Microsoft, the list of types that can have a constant value are:
\n| C# type | \n.Net Fwk type | \n
|---|---|
| \n bool \n | \n \n System.Boolean \n | \n
| \n byte \n | \n \n System.Byte \n | \n
| \n sbyte \n | \n \n System.SByte \n | \n
| \n char \n | \n \n System.Char \n | \n
| \n decimal \n | \n \n System.Decimal \n | \n
| \n double \n | \n \n System.Double \n | \n
| \n float \n | \n \n System.Single \n | \n
| \n int \n | \n \n System.Int32 \n | \n
| \n uint \n | \n \n System.UInt32 \n | \n
| \n long \n | \n \n System.Int64 \n | \n
| \n ulong \n | \n \n System.UInt64 \n | \n
| \n short \n | \n \n System.Int16 \n | \n
| \n ushort \n | \n \n System.UInt16 \n | \n
| \n string \n | \n \n System.String \n | \n
\nnamespace myLib\n{\n public class Foo\n {\n static readonly int x = 1; // Noncompliant\n static readonly int y = x + 4; // Noncompliant\n static readonly string s = \"Bar\"; // Noncompliant\n }\n}\n\n\nnamespace myLib\n{\n public class Foo\n {\n const int x = 1;\n const int y = x + 4;\n const string s = \"Bar\";\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3962.json",
"content": "{\n \"title\": \"\\\"static readonly\\\" constants should be \\\"const\\\" instead\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3962\",\n \"sqKey\": \"S3962\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3963.html",
"content": "When a static constructor serves no other purpose that initializing static fields, it comes with an unnecessary\nperformance cost because the compiler generates a check before each static method or instance constructor invocation.
Instead, inline initialization is highly recommended.
\n\nnamespace myLib\n{\n public class Foo\n {\n static int i;\n static string s;\n\n static Foo() // Noncompliant\n {\n i = 3;\n ResourceManager sm = new ResourceManager(\"strings\", Assembly.GetExecutingAssembly());\n s = sm.GetString(\"mystring\");\n }\n }\n}\n\n\nnamespace myLib\n{\n public class Foo\n {\n static int i =3;\n static string s = InitString();\n\n static string InitString()\n {\n ResourceManager sm = new ResourceManager(\"strings\", Assembly.GetExecutingAssembly());\n return sm.GetString(\"mystring\");\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3963.json",
"content": "{\n \"title\": \"\\\"static\\\" fields should be initialized inline\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3963\",\n \"sqKey\": \"S3963\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3966.html",
"content": "Disposing an object twice in the same method, either with the Dispose\ndirectly, is confusing and error-prone. For example, another developer might try to use an already-disposed object, or there can be runtime errors for\nspecific paths in the code.
In addition, even if the Dispose method multiple times should not throw an exception, some implementations still do it. Thus it is safer to not\ndispose of an object twice when possible.
\nvar foo = new Disposable();\nfoo.Dispose();\nfoo.Dispose(); // Noncompliant\n\n
\nusing (var bar = new Disposable()) // Noncompliant\n{\n bar.Dispose();\n}\n\n\nvar foo = new Disposable();\nfoo.Dispose();\n\n
\nusing (var bar = new Disposable()) // Compliant\n{\n\n}\n\nA jagged array is an array whose elements are arrays. It is recommended over a multidimensional array because the arrays that make up the elements\ncan be of different sizes, which avoids wasting memory space.
\n\nint [,] myArray = // Noncompliant\n {\n {1,2,3,4},\n {5,6,7,0},\n {8,0,0,0},\n {9,0,0,0}\n };\n// ...\nmyArray[1,1] = 0;\n\n\nint[][] myArray =\n {\n new int[] {1,2,3,4},\n new int[] {5,6,7},\n new int[] {8},\n new int[] {9}\n };\n// ...\nmyArray[1][1] = 0;\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3967.json",
"content": "{\n \"title\": \"Multidimensional arrays should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3967\",\n \"sqKey\": \"S3967\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3971.html",
"content": "GC.SuppressFinalize requests that the system not call the finalizer for the specified object. This should only be done when\nimplementing Dispose as part of the
This rule raises an issue when GC.SuppressFinalize is called outside that pattern.
Placing an if statement on the same line as the closing } from a preceding if, else, or\nelse if block can lead to confusion and potential errors. It may indicate a missing else statement or create ambiguity for\nmaintainers who might fail to understand that the two statements are unconnected.
The following code snippet is confusing:
\n\nif (condition1) {\n // ...\n} if (condition2) { // Noncompliant\n //...\n}\n\nEither the two conditions are unrelated and they should be visually separated:
\n\nif (condition1) {\n // ...\n}\n\nif (condition2) {\n //...\n}\n\nOr they were supposed to be exclusive and you should use else if instead:
\nif (condition1) {\n // ...\n} else if (condition2) {\n //...\n}\n\nWhen the line immediately after conditional statements has neither curly braces nor indentation, the intent of the code is unclear and perhaps not\nexecuted as expected. Additionally, such code is confusing to maintainers.
\nThe rule will check the line indentation after the following conditional statements:
\n\nif (condition) // Noncompliant\nDoTheThing();\nDoTheOtherThing(); // Was the intent to call this function unconditionally?\n\n
It becomes even more confusing and bug-prone if lines get commented out.
\n\nif (condition) // Noncompliant\n// DoTheThing();\nDoTheOtherThing(); // Was the intent to call this function conditionally?\n\n
Indentation alone or together with curly braces makes the intent clear.
\n\nif (condition)\n DoTheThing();\nDoTheOtherThing(); // Clear intent to call this function unconditionally\n\n// or\n\nif (condition)\n{\n DoTheThing();\n}\nDoTheOtherThing(); // Clear intent to call this function unconditionally\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3973.json",
"content": "{\n \"title\": \"A conditionally executed single line should be denoted by indentation\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"confusing\",\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-3973\",\n \"sqKey\": \"S3973\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3981.html",
"content": "The size of a collection and the length of an array are always greater than or equal to zero. Testing it doesn’t make sense, since the result is\nalways true.
\nif(collection.Count >= 0){...} // Noncompliant: always true\n\nif(array.Length >= 0){...} // Noncompliant: always true\n\nSimilarly testing that it is less than zero will always return false.
\nif(enumerable.Count() < 0){...} // Noncompliant: always false\n\nFix the code to properly check for emptiness if it was the intent, or remove the redundant code to keep the current behavior.
\n\n" }, { "path": "analyzers/rspec/cs/S3981.json", "content": "{\n \"title\": \"Collection sizes and array length comparisons should make sense\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3981\",\n \"sqKey\": \"S3981\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S3984.html", "content": "Creating a new Exception without actually throwing does\nnot achieve the intended purpose.
\nif (x < 0)\n{\n new ArgumentException(\"x must be nonnegative\");\n}\n\nEnsure to throw the Exception with a throw\nstatement.
\nif (x < 0)\n{\n throw new ArgumentException(\"x must be nonnegative\");\n}\n\nException Classthrow, try-catch, try-finally, and try-catch-finallyAssemblies should conform with the Common Language Specification (CLS) in order to be usable across programming languages. To be compliant an\nassembly has to indicate it with System.CLSCompliantAttribute.
\nusing System;\n\n[assembly:CLSCompliant(true)]\nnamespace MyLibrary\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3990.json",
"content": "{\n \"title\": \"Assemblies should be marked as CLS compliant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3990\",\n \"sqKey\": \"S3990\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3992.html",
"content": "Assemblies should explicitly indicate whether they are meant to be COM visible or not. If the ComVisibleAttribute is not present, the\ndefault is to make the content of the assembly visible to COM clients.
Note that COM visibility can be overridden for individual types and members.
\n\nusing System;\n\nnamespace MyLibrary // Noncompliant\n{\n}\n\n\nusing System;\n\n[assembly: System.Runtime.InteropServices.ComVisible(false)]\nnamespace MyLibrary\n{\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3992.json",
"content": "{\n \"title\": \"Assemblies should explicitly specify COM visibility\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3992\",\n \"sqKey\": \"S3992\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3993.html",
"content": "When defining custom attributes, AttributeUsageAttribute\nmust be used to indicate where the attribute can be applied. This will:
\n\npublic sealed class MyAttribute : Attribute // Noncompliant - AttributeUsage is missing\n{\n private string text;\n\n public MyAttribute(string text)\n {\n this.text = text;\n }\n\n public string Text => text;\n}\n\n\n[AttributeUsage(AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate)]\npublic sealed class MyAttribute : Attribute\n{\n private string text;\n\n public MyAttribute(string text)\n {\n this.text = text;\n }\n\n public string Text => text;\n}\n\nString representations of URIs or URLs are prone to parsing and encoding errors which can lead to vulnerabilities. The System.Uri\nclass is a safe alternative and should be preferred. At minimum, an overload of the method taking a System.Uri as a parameter should be\nprovided in each class that contains a method with an apparent Uri passed as a string.
This rule raises issues when a method has a string parameter with a name containing \"uri\", \"Uri\", \"urn\", \"Urn\", \"url\" or \"Url\", and the type\ndoesn’t declare a corresponding overload taking an System.Uri parameter instead.
\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n\n public void FetchResource(string uriString) { } // Noncompliant\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n\n public void FetchResource(string uriString)\n {\n FetchResource(new Uri(uriString));\n }\n\n public void FetchResource(Uri uri) { }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3994.json",
"content": "{\n \"title\": \"URI Parameters should not be strings\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3994\",\n \"sqKey\": \"S3994\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3995.html",
"content": "String representations of URIs or URLs are prone to parsing and encoding errors which can lead to vulnerabilities. The System.Uri\nclass is a safe alternative and should be preferred.
This rule raises an issue when a method has a string return type and its name contains \"Uri\", \"Urn\", or \"Url\" or begins with \"uri\",\n\"urn\", or \"url\".
\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n public string GetParentUri() // Noncompliant\n {\n return \"http://www.mysite.com\";\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n\n public Uri GetParentUri()\n {\n return new URI(\"http://www.mysite.com\");\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3995.json",
"content": "{\n \"title\": \"URI return values should not be strings\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3995\",\n \"sqKey\": \"S3995\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3996.html",
"content": "String representations of URIs or URLs are prone to parsing and encoding errors which can lead to vulnerabilities. The System.Uri\nclass is a safe alternative and should be preferred.
This rule raises an issue when a property is a string type and its name contains \"uri\", \"Uri\", \"urn\", \"Urn\", \"url\" or \"Url\".
\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n string myUri;\n\n public string MyUri // Noncompliant\n {\n get { return myURI; }\n set { myUri = value; }\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n Uri myUri;\n\n public Uri MyUri\n {\n get { return myURI; }\n set { myUri = value; }\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3996.json",
"content": "{\n \"title\": \"URI properties should not be strings\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3996\",\n \"sqKey\": \"S3996\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3997.html",
"content": "String representations of URIs or URLs are prone to parsing and encoding errors which can lead to vulnerabilities. The System.Uri\nclass is a safe alternative and should be preferred.
This rule raises an issue when two overloads differ only by the string / Uri parameter and the string overload doesn’t call the\nUri overload. It is assumed that the string parameter represents a URI because of the exact match besides that parameter type. It stands\nto reason that the safer overload should be used.
\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n public void FetchResource(string uriString) // Noncompliant\n {\n // No calls to FetResource(Uri)\n }\n\n public void FetchResource(Uri uri) { }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n public void FetchResource(string uriString)\n {\n FetchResource(new Uri(uriString));\n }\n\n public void FetchResource(Uri uri) { }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S3997.json",
"content": "{\n \"title\": \"String URI overloads should call \\\"System.Uri\\\" overloads\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3997\",\n \"sqKey\": \"S3997\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S3998.html",
"content": "Objects that can be accessed across application\ndomain boundaries are said to have weak identity. This means that these objects can be considered shared resources outside of the domain, which\ncan be lead to them being accessed or modified by multiple threads or concurrent parts of a program, outside of the domain.
\nA thread acquiring a
Types with weak identity are:
\n\npublic class Sample\n{\n private readonly StackOverflowException myLock = new();\n\n public void Go()\n {\n lock (myLock) // Noncompliant\n {\n // ...\n }\n }\n}\n\n\npublic class Sample\n{\n private readonly object myLock = new();\n\n public void Go()\n {\n lock (myLock)\n {\n // ...\n }\n }\n}\n\nPointer and unmanaged function pointer types such as IntPtr, UIntPtr, int* etc. are used to access unmanaged\nmemory, usually in order to use C or C++ libraries. If such a pointer is not secured by making it private, internal or\nreadonly, it can lead to a vulnerability allowing access to arbitrary locations.
\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n public IntPtr myPointer; // Noncompliant\n protected UIntPtr myOtherPointer; // Noncompliant\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyClass\n {\n private IntPtr myPointer;\n protected readonly UIntPtr myOtherPointer;\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4000.json",
"content": "{\n \"title\": \"Pointers to unmanaged memory should not be visible\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-4000\",\n \"sqKey\": \"S4000\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4002.html",
"content": "This rule raises an issue when a disposable type contains fields of the following types and does not implement a finalizer:
\nSystem.IntPtrSystem.UIntPtrSystem.Runtime.InteropService.HandleRef\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n public class Foo : IDisposable // Noncompliant: Doesn't have a finalizer\n {\n private IntPtr myResource;\n private bool disposed = false;\n\n protected virtual void Dispose(bool disposing)\n {\n if (!disposed)\n {\n // Dispose of resources held by this instance.\n FreeResource(myResource);\n disposed = true;\n\n // Suppress finalization of this disposed instance.\n if (disposing)\n {\n GC.SuppressFinalize(this);\n }\n }\n }\n\n public void Dispose() {\n Dispose(true);\n }\n }\n}\n\n\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n public class Foo : IDisposable\n {\n private IntPtr myResource;\n private bool disposed = false;\n\n protected virtual void Dispose(bool disposing)\n {\n if (!disposed)\n {\n // Dispose of resources held by this instance.\n FreeResource(myResource);\n disposed = true;\n\n // Suppress finalization of this disposed instance.\n if (disposing)\n {\n GC.SuppressFinalize(this);\n }\n }\n }\n\n ~Foo()\n {\n Dispose(false);\n }\n }\n}\n\nA writable collection property can be replaced by a completely different collection. Making it readonly prevents that while still\nallowing individual members to be set. If you want to allow the replacement of the whole collection the recommended pattern is to implement a method\nto remove all the elements (e.g. System.Collections.List<T>.Clear) and a method to populate the collection (e.g.\nSystem.Collections.List<T>.AddRange).
This rule raises an issue when an externally visible writable property is of a type that implements System.Collections.ICollection or\nSystem.Collections.Generic.ICollection<T>.
\nusing System;\nusing System.Collections;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n List<string> strings;\n\n public List<string> SomeStrings\n {\n get { return strings; }\n set { strings = value; } // Noncompliant\n }\n }\n}\n\n\nusing System;\nusing System.Collections;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n List<string> strings;\n\n public List<string> SomeStrings\n {\n get { return strings; }\n }\n }\n}\n\nThis rule does not raise issues for
\nstring, Array and PermissionSet,DataMemberAttributeSerializable\n\n" }, { "path": "analyzers/rspec/cs/S4004.json", "content": "{\n \"title\": \"Collection properties should be readonly\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4004\",\n \"sqKey\": \"S4004\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4005.html", "content": "
String representations of URIs or URLs are prone to parsing and encoding errors which can lead to vulnerabilities. The System.Uri\nclass is a safe alternative and should be preferred.
This rule raises an issue when a called method has a string parameter with a name containing \"uri\", \"Uri\", \"urn\", \"Urn\", \"url\" or \"Url\" and the\ndeclaring type contains a corresponding overload that takes a System.Uri as a parameter.
When there is a choice between two overloads that differ only regarding the representation of a URI, the user should choose the overload that takes\na System.Uri argument.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void FetchResource(string uriString) { }\n public void FetchResource(Uri uri) { }\n\n public string ReadResource(string uriString, string name, bool isLocal) { }\n public string ReadResource(Uri uri, string name, bool isLocal) { }\n\n public void Main() {\n FetchResource(\"http://www.mysite.com\"); // Noncompliant\n ReadResource(\"http://www.mysite.com\", \"foo-resource\", true); // Noncompliant\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void FetchResource(string uriString) { }\n public void FetchResource(Uri uri) { }\n\n public string ReadResource(string uriString, string name, bool isLocal) { }\n public string ReadResource(Uri uri, string name, bool isLocal) { }\n\n public void Main() {\n FetchResource(new Uri(\"http://www.mysite.com\"));\n ReadResource(new Uri(\"http://www.mysite.com\"), \"foo-resource\", true);\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4005.json",
"content": "{\n \"title\": \"\\\"System.Uri\\\" arguments should be used instead of strings\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4005\",\n \"sqKey\": \"S4005\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4015.html",
"content": "Decreasing the accessibility\nlevel of an inherited method that is not
\npublic class Base\n{\n public void SomeMethod(int count) { }\n}\npublic class Derived : Base\n{\n private void SomeMethod(int count) { } // Noncompliant\n}\n\nclass Program\n{\n public void DoWork()\n {\n var derived = new Derived();\n derived.SomeMethod(42); // Base.SomeMethod is accessed here\n }\n}\n\nAnother potential problem is the case of a class deriving from Derived and accessing SomeMethod. In this scenario, the\nmethod accessed will instead be the Base implementation, which might not be what was expected.
\npublic class Base\n{\n public void SomeMethod(int count) { }\n}\npublic class Derived : Base\n{\n private void SomeMethod(int count) { } // Noncompliant\n}\n\npublic class SecondDerived : Derived\n{\n public void DoWork()\n {\n SomeMethod(42); // Base.SomeMethod is accessed here\n }\n}\n\nOne way to mitigate this, is by sealing the Derived class by using the
\npublic class Base\n{\n public void SomeMethod(int count) { }\n}\npublic sealed class Derived : Base\n{\n private void SomeMethod(int count) { } // Compliant: class is marked as sealed\n}\n\nAnother way to mitigate this, is by having the Derived implementation match the Base implementation of SomeMethod. From a caller’s perspective, this is closer to the expected behavior.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Base\n {\n public void SomeMethod(int count) { }\n }\n public class Derived : Base\n {\n public void SomeMethod(int count) { } // Compliant: same accessibility as Base.SomeMethod\n }\n\n public class Program\n {\n public void DoWork()\n {\n var derived = new Derived();\n derived.SomeMethod(42); // Derived.SomeMethod is called\n }\n }\n}\n\nLast but not least, consider using a different name for the Derived method, thus completely eliminating any confusion caused by the\nnaming collision.
\npublic class Base\n{\n public void SomeMethod(int count) { }\n}\npublic class Derived : Base\n{\n private void SomeOtherMethod(int count) { } // Compliant\n}\n\nIf an enum member’s name contains the word \"reserved\" it implies it is not currently used and will be change in the future. However\nchanging an enum member is a breaking change and can create significant problems. There is no need to reserve an enum member\nsince a new member can be added in the future, and such an addition will usually not be a breaking change.
This rule raises an issue when the name of an enumeration member contains \"reserved\".
\n\nusing System;\n\nnamespace MyLibrary\n{\n public enum Color\n {\n None,\n Red,\n Orange,\n Yellow,\n ReservedColor // Noncompliant\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4016.json",
"content": "{\n \"title\": \"Enumeration members should not be named \\\"Reserved\\\"\",\n \"type\": \"CODE_SMELL\",\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4016\",\n \"sqKey\": \"S4016\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4017.html",
"content": "A nested type is a type argument that is also a generic type. Calling a method with such a nested type argument requires complicated and confusing\ncode. It should be avoided as much as possible.
\n\nusing System;\nusing System.Collections.Generic;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void DoSomething(ICollection<ICollection<int>> outerCollect) // Noncompliant\n {\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4017.json",
"content": "{\n \"title\": \"Method signatures should not contain nested generic types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"30min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4017\",\n \"sqKey\": \"S4017\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4018.html",
"content": "Type inference enables the call of a generic method without explicitly specifying its type arguments. This is not possible when a parameter type is\nmissing from the argument list.
\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void MyMethod<T>() // Noncompliant\n {\n // this method can only be invoked by providing the type argument e.g. 'MyMethod<int>()'\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void MyMethod<T>(T param)\n {\n // type inference allows this to be invoked 'MyMethod(arg)'\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4018.json",
"content": "{\n \"title\": \"All type parameters should be used in the parameter list to enable type inference\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4018\",\n \"sqKey\": \"S4018\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4019.html",
"content": "When a method in a derived class has:
\nstring in the base class and object in the derived class)the result is that the base method becomes hidden.
\nAs shown in the following code snippet, when an instance of the derived class is used, invoking the method with an argument that matches the less\nderived parameter type will invoke the derived class method instead of the base class method:
\n\nclass BaseClass\n{\n internal void MyMethod(string str) => Console.WriteLine(\"BaseClass: Method(string)\");\n}\n\nclass DerivedClass : BaseClass\n{\n internal void MyMethod(object str) => Console.WriteLine(\"DerivedClass: Method(object)\"); // Noncompliant\n}\n\n// ...\nBaseClass baseObj = new BaseClass();\nbaseObj.MyMethod(\"Hello\"); // Output: BaseClass: Method(string)\n\nDerivedClass derivedObj = new DerivedClass();\nderivedObj.MyMethod(\"Hello\"); // Output: DerivedClass: Method(object) - DerivedClass method is hiding the BaseClass method\n\nBaseClass derivedAsBase = new DerivedClass();\nderivedAsBase.MyMethod(\"Hello\"); // Output: BaseClass: Method(string)\n\n\nclass BaseClass\n{\n internal void MyMethod(string str) => Console.WriteLine(\"BaseClass: Method(string)\");\n}\n\nclass DerivedClass : BaseClass\n{\n internal void MyOtherMethod(object str) => Console.WriteLine(\"DerivedClass: Method(object)\"); // Compliant\n}\n\n// ...\nBaseClass baseObj = new BaseClass();\nbaseObj.MyMethod(\"Hello\"); // Output: BaseClass: Method(string)\n\nDerivedClass derivedObj = new DerivedClass();\nderivedObj.MyMethod(\"Hello\"); // Output: BaseClass: Method(string)\n\nBaseClass derivedAsBase = new DerivedClass();\nderivedAsBase.MyMethod(\"Hello\"); // Output: BaseClass: Method(string)\n\nKeep in mind that you cannot fix this issue by using the virtual and overriding it in the DerivedClass because the parameter types are different.
The rule is not raised when the two methods have the same parameter types.
\nBy default the storage type of an enum is Int32. In most cases it is not necessary to change this. In particular you will\nnot achieve any performance gain by using a smaller data type (e.g. Byte) and may limit future uses.
\nusing System;\n\nnamespace MyLibrary\n{\n public enum Visibility : sbyte // Noncompliant\n {\n Visible = 0,\n Invisible = 1,\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public enum Visibility\n {\n Visible = 0,\n Invisible = 1,\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4022.json",
"content": "{\n \"title\": \"Enumerations should have \\\"Int32\\\" storage\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4022\",\n \"sqKey\": \"S4022\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4023.html",
"content": "Empty interfaces should be avoided as they do not provide any functional requirements for implementing classes.
\nEmpty interfaces are either useless or used as a marker.
This rule doesn’t raise in any of the following cases:
\n\npublic interface IAggregate: IComparable, IFormattable { } // Compliant: Aggregates two interfaces\n\nAn empty interface with a single base interface is compliant as long as the resulting interface binds a generic parameter or constrains it.
\n\n// Compliant: Bound to a concrete type\npublic interface IStringEquatable: IEquatable<string> { }\n// Compliant: Specialized by type parameter constraint\npublic interface ICreateableEquatable<T>: IEquatable<T> where T: new() { }\n\nAn empty interface is compliant if a custom attribute is applied to the interface.
\n\n[Obsolete]\npublic interface ISorted { } // Compliant: An attribute is applied to the interface declaration\n\nDo any of the following to fix the issue:
\nThe empty interface does not add any functionality.
\n\npublic interface IFoo // Noncompliant\n{\n\n}\n\nAdd members to the interface to be compliant.
\n\npublic interface IFoo\n{\n void Bar();\n}\n\nA typical use case for marker interfaces is doing type inspection via
The IIncludeFields marker interface is used to configure the JSON serialization of an object.
\n// An example marker interface\npublic interface IIncludeFields { }\n\npublic class OptInToIncludeFields: IIncludeFields { }\n\nSerialize(new OptInToIncludeFields());\n\nvoid Serialize<T>(T o)\n{\n // Use reflection to check if the interface is applied to the type\n var includeFields = o.GetType()\n .GetInterfaces().Any(i => i == typeof(IIncludeFields));\n var options = new JsonSerializerOptions()\n {\n // Take decisions based on the presence of the marker\n IncludeFields = includeFields,\n };\n}\n\nThe same example can be rewritten using custom attributes. This approach is preferable because it is more fine-grained, allows parameterization,\nand is more flexible in type hierarchies.
\n\n// A custom attribute used as a marker\n[AttributeUsage(AttributeTargets.Class)]\npublic sealed class IncludeFieldsAttribute: Attribute { }\n\n[IncludeFields]\npublic class OptInToIncludeFields { }\n\nSerialize(new OptInToIncludeFields());\n\nvoid Serialize<T>(T o)\n{\n // Use reflection to check if the attribute is applied to the type\n var includeFields = o.GetType()\n .GetCustomAttributes(typeof(IncludeFieldsAttribute), inherit: true).Any();\n var options = new JsonSerializerOptions()\n {\n // Take decisions based on the presence of the marker\n IncludeFields = includeFields,\n };\n}\n\nHaving a field in a child class with a name that differs from a parent class' field only by capitalization is sure to cause confusion. Such child\nclass fields should be renamed.
\n\npublic class Fruit\n{\n protected string plantingSeason;\n //...\n}\n\npublic class Raspberry : Fruit\n{\n protected string plantingseason; // Noncompliant\n // ...\n}\n\n\npublic class Fruit\n{\n protected string plantingSeason;\n //...\n}\n\npublic class Raspberry : Fruit\n{\n protected string whenToPlant;\n // ...\n}\n\nOr
\n\npublic class Fruit\n{\n protected string plantingSeason;\n //...\n}\n\npublic class Raspberry : Fruit\n{\n // field removed; parent field will be used instead\n // ...\n}\n\nThis rule ignores same-name fields that are static in both the parent and child classes. It also ignores private parent\nclass fields, but in all other such cases, the child class field should be renamed.
It is important to inform the ResourceManager of the language used to display the resources of the neutral culture for an assembly.\nThis improves lookup performance for the first resource loaded.
This rule raises an issue when an assembly contains a ResX-based resource but does not have the\nSystem.Resources.NeutralResourcesLanguageAttribute applied to it.
\nusing System;\n\npublic class MyClass // Noncompliant\n{\n public static void Main()\n {\n string[] cultures = { \"de-DE\", \"en-us\", \"fr-FR\" };\n Random rnd = new Random();\n int index = rnd.Next(0, cultures.Length);\n Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultures[index]);\n\n ResourceManager rm = new ResourceManager(\"MyResources\" ,\n typeof(MyClass).Assembly);\n string greeting = rm.GetString(\"Greeting\");\n\n Console.Write(\"Enter your name: \");\n string name = Console.ReadLine();\n Console.WriteLine(\"{0} {1}!\", greeting, name);\n }\n}\n\n\nusing System;\n\n[assembly:NeutralResourcesLanguageAttribute(\"en\")]\npublic class MyClass\n{\n public static void Main()\n {\n string[] cultures = { \"de-DE\", \"en-us\", \"fr-FR\" };\n Random rnd = new Random();\n int index = rnd.Next(0, cultures.Length);\n Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(cultures[index]);\n\n ResourceManager rm = new ResourceManager(\"MyResources\" ,\n typeof(MyClass).Assembly);\n string greeting = rm.GetString(\"Greeting\");\n\n Console.Write(\"Enter your name: \");\n string name = Console.ReadLine();\n Console.WriteLine(\"{0} {1}!\", greeting, name);\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4026.json",
"content": "{\n \"title\": \"Assemblies should be marked with \\\"NeutralResourcesLanguageAttribute\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4026\",\n \"sqKey\": \"S4026\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4027.html",
"content": "Exceptions types should provide the following constructors:
\npublic MyException()public MyException(string)public MyException(string, Exception)The absence of these constructors can complicate exception handling and limit the information that can be provided when an exception is thrown.
\n\npublic class MyException : Exception // Noncompliant: several constructors are missing\n{\n public MyException()\n {\n }\n}\n\n\npublic class MyException : Exception\n{\n public MyException()\n {\n }\n\n public MyException(string message)\n : base(message)\n {\n }\n\n public MyException(string message, Exception innerException)\n : base(message, innerException)\n {\n }\n}\n\nWhen a class implements the IEquatable<T> interface, it enters a contract that, in effect, states \"I know how to compare two\ninstances of type T or any type derived from T for equality.\". However if that class is derived, it is very unlikely that the base class will know how\nto make a meaningful comparison. Therefore that implicit contract is now broken.
Alternatively IEqualityComparer<T> provides a safer interface and is used by collections or Equals could be made\nvirtual.
This rule raises an issue when an unsealed, public or protected class implements IEquatable<T> and the\nEquals is neither virtual nor abstract.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Base : IEquatable<Base> // Noncompliant\n {\n public bool Equals(Base other)\n {\n if (other == null) { return false; }\n // do comparison of base properties\n return true;\n }\n\n public override bool Equals(object other) => Equals(other as Base);\n }\n\n class A : Base\n {\n public bool Equals(A other)\n {\n if (other == null) { return false; }\n // do comparison of A properties\n return base.Equals(other);\n }\n\n public override bool Equals(object other) => Equals(other as A);\n }\n\n class B : Base\n {\n public bool Equals(B other)\n {\n if (other == null) { return false; }\n // do comparison of B properties\n return base.Equals(other);\n }\n\n public override bool Equals(object other) => Equals(other as B);\n }\n\n internal class Program\n {\n static void Main(string[] args)\n {\n A a = new A();\n B b = new B();\n Console.WriteLine(a.Equals(b)); // This calls the WRONG equals. This causes Base.Equals(Base)\n // to be called which only compares the properties in Base and ignores the fact that\n // a and b are different types. In the working example A.Equals(Object) would have been\n // called and Equals would return false because it correctly recognizes that a and b are\n // different types. If a and b have the same base properties they will be returned as equal.\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public sealed class Foo : IEquatable<Foo>\n {\n public bool Equals(Foo other)\n {\n // Your code here\n }\n }\n}\n\nIEqualityComparer<T> Interface
\n\n" }, { "path": "analyzers/rspec/cs/S4035.json", "content": "{\n \"title\": \"Classes implementing \\\"IEquatable\\u003cT\\u003e\\\" should be sealed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4035\",\n \"sqKey\": \"S4035\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4036.html", "content": "When you run an OS command, it is always important to protect yourself against the risk of accidental or malicious replacement of the executables\nin the production system.
\nTo do so, it is important to point to the specific executable that should be used.
\nFor example, if you call git (without specifying a path), the operating system will search for the executable in the directories\nspecified in the PATH environment variable.\n
\n An attacker could have added, in a permissive directory covered by PATH , another executable called git, but with a\n completely different behavior, for example exfiltrating data or exploiting a vulnerability in your own code.
However, by calling /usr/bin/git or ../git (relative path) directly, the operating system will always use the intended\nexecutable.\n
\n Note that you still need to make sure that the executable is not world-writeable and potentially overwritten. This is not the scope of this\n rule.
There is a risk if you answered no to this question.
\nIf you wish to rely on the PATH environment variable to locate the OS command, make sure that each of its listed directories is fixed,\nnot susceptible to change, and not writable by unprivileged users.
If you determine that these folders cannot be altered, and that you are sure that the program you intended to use will be used, then you can\ndetermine that these risks are under your control.
\nA good practice you can use is to also hardcode the PATH variable you want to use, if you can do so in the framework you use.
If the previous recommendations cannot be followed due to their complexity or other requirements, then consider using the absolute path of the\ncommand instead.
\n\n$ whereis git\ngit: /usr/bin/git /usr/share/man/man1/git.1.gz\n$ ls -l /usr/bin/git\n-rwxr-xr-x 1 root root 3376112 Jan 28 10:13 /usr/bin/git\n\n
\nProcess p = new Process();\np.StartInfo.FileName = \"binary\"; // Sensitive\n\n
\nProcess p = new Process();\np.StartInfo.FileName = @\"C:\\Apps\\binary.exe\";\n\n
When a base type explicitly implements a public interface method, property or event, that member is only accessible in derived types through a\nreference to the current instance (namely this). If the derived type explicitly overrides that interface member, the base implementation\nbecomes inaccessible.
This rule raises an issue when an unsealed, externally visible type provides an explicit member implementation of an interface and\ndoes not provide an alternate, externally visible member with the same name.
This rule does not report a violation for an explicit implementation of IDisposable.Dispose when an externally visible\nClose() or System.IDisposable.Dispose(Boolean) method is provided.
Make the class sealed, change the class member to a non-explicit declaration, or provide a new class member exposing the functionality of the\nexplicit interface member.
\n\npublic interface IMyInterface\n{\n void MyMethod();\n}\n\npublic class Foo : IMyInterface\n{\n void IMyInterface.MyMethod() // Noncompliant\n {\n MyMethod();\n }\n}\n\n\npublic interface IMyInterface\n{\n void MyMethod();\n}\n\npublic class Foo : IMyInterface\n{\n void IMyInterface.MyMethod()\n {\n MyMethod();\n }\n\n // This method can be public or protected\n protected void MyMethod()\n {\n // Do something ...\n }\n}\n\nCertain characters, once normalized to lowercase, cannot make a round trip. That is, they can not be converted from one locale to another and then\naccurately restored to their original characters.
\nIt is therefore strongly recommended to normalize characters and strings to uppercase instead.
\n\nThread.CurrentThread.CurrentCulture = new CultureInfo(\"tr-TR\");\nvar areStringEqual = \"INTEGER\".ToLower() == \"integer\"; // Noncompliant, the result is false as the ToLower will resolve to \"ınteger\"\nvar areCharEqual = char.ToLower('I') == 'i'; // Noncompliant, the result is false as the ToLower will resolve to \"ı\"\n\nvar incorrectRoundtrip = \"İ\".ToLowerInvariant().ToUpper() == \"I\".ToLowerInvariant().ToUpper(); // Noncompliant, because of the lower we lose the information about the correct uppercase character\n\n\nThread.CurrentThread.CurrentCulture = new CultureInfo(\"tr-TR\");\nvar areStringEqual = \"ınteger\".ToUpperInvariant() == \"ıNTEGER\";\nvar areCharEqual = char.ToUpperInvariant('ı') == 'ı';\nvar correctRoundtrip = \"İ\".ToUpperInvariant().ToLower() != \"I\".ToUpperInvariant().ToLower();\n\nWhen a type name matches the name of a publicly defined namespace, for instance one in the .NET framework class library, it leads to confusion and\nmakes the library that much harder to use.
\nThis rule raises an issue when a name of a public type matches the name of a .NET Framework namespace, or a namespace of the project assembly, in a\ncase-insensitive comparison.
\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Text // Noncompliant: Collides with System.Text\n {\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyText\n {\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4041.json",
"content": "{\n \"title\": \"Type names should not match namespaces\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4041\",\n \"sqKey\": \"S4041\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4047.html",
"content": "When a reference parameter (keyword ref) is used, the passed argument type must exactly match the reference parameter type. This means\nthat to be able to pass a derived type, it must be cast and assigned to a variable of the proper type. Use of generic methods eliminates that\ncumbersome down casting and should therefore be preferred.
This rule raises an issue when a method contains a ref parameter of type System.Object.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar(ref object o1, ref object o2) // Noncompliant\n {\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar<T>(ref T ref1, ref T ref2)\n {\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4047.json",
"content": "{\n \"title\": \"Generics should be used when appropriate\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4047\",\n \"sqKey\": \"S4047\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4049.html",
"content": "Properties are accessed like fields which makes them easier to use.
\nThis rule raises an issue when the name of a public or protected method starts with Get, takes no parameter,\nand returns a value that is not an array.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n private string name;\n\n public string GetName() // Noncompliant\n {\n return name;\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n private string name;\n\n public string Name\n {\n get\n {\n return name;\n }\n }\n }\n}\n\nThe rule doesn’t raise an issue when the method:
\noverrideasyncTask, Task<T>GetEnumerator, GetAwaiterWhen overloading some arithmetic operator overloads, it is very important to make sure that all related operators and methods are consistent in\ntheir implementation.
\nThe following guidelines should be followed:
\noperator ==, != you should also provide Equals(Object) and GetHashCode().operator +, -, *, / or % you should also provide operator ==, respecting the previous\n guideline.This rule raises an issue when any of these guidelines are not followed on a publicly-visible class or struct (public,\nprotected or protected internal).
Make sure to implement all related operators.
\n\npublic class Foo // Noncompliant\n{\n private int left;\n private int right;\n\n public Foo(int l, int r)\n {\n this.left = l;\n this.right = r;\n }\n\n public static Foo operator +(Foo a, Foo b)\n {\n return new Foo(a.left + b.left, a.right + b.right);\n }\n\n public static Foo operator -(Foo a, Foo b)\n {\n return new Foo(a.left - b.left, a.right - b.right);\n }\n}\n\n\npublic class Foo\n{\n private int left;\n private int right;\n\n public Foo(int l, int r)\n {\n this.left = l;\n this.right = r;\n }\n\n public override bool Equals(Object obj)\n {\n var a = obj as Foo;\n if (a == null)\n return false;\n return this == a;\n }\n\n public override int GetHashCode()\n {\n return HashCode.Combine(right, left);\n }\n\n public static Foo operator +(Foo a, Foo b)\n {\n return new Foo(a.left + b.left, a.right + b.right);\n }\n\n public static Foo operator -(Foo a, Foo b)\n {\n return new Foo(a.left - b.left, a.right - b.right);\n }\n\n public static bool operator ==(Foo a, Foo b)\n {\n return a.left == b.left && a.right == b.right;\n }\n\n public static bool operator !=(Foo a, Foo b)\n {\n return !(a == b);\n }\n}\n\nWith the advent of .NET Framework 2.0, certain practices and types have become obsolete.
\nIn particular, exceptions should now extend System.Exception instead of System.ApplicationException. Similarly, generic\ncollections should be used instead of the older, non-generic, ones. Finally when creating an XML view, you should not extend\nSystem.Xml.XmlDocument. This rule raises an issue when an externally visible type extends one of these types:
\nusing System;\nusing System.Collections;\n\nnamespace MyLibrary\n{\n public class MyCollection : CollectionBase // Noncompliant\n {\n }\n}\n\n\nusing System;\nusing System.Collections.ObjectModel;\n\nnamespace MyLibrary\n{\n public class MyCollection : Collection<T>\n {\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4052.json",
"content": "{\n \"title\": \"Types should not extend outdated base types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4052\",\n \"sqKey\": \"S4052\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4055.html",
"content": "String literals embedded in the source code will not be localized properly.
\nThis rule raises an issue when a literal string is passed as a parameter or property and one or more of the following cases is true:
\nLocalizableAttribute attribute of the parameter or property is set to true.Console.Write or Console.WriteLine method is either \"value\" or\n \"format\".\nusing System;\nusing System.Globalization;\nusing System.Reflection;\nusing System.Windows.Forms;\n\n[assembly: NeutralResourcesLanguageAttribute(\"en-US\")]\nnamespace MyLibrary\n{\n public class Foo\n {\n public void SetHour(int hour)\n {\n if (hour < 0 || hour > 23)\n {\n MessageBox.Show(\"The valid range is 0 - 23.\"); // Noncompliant\n }\n }\n }\n}\n\n\nusing System;\nusing System.Globalization;\nusing System.Reflection;\nusing System.Resources;\nusing System.Windows.Forms;\n\n\n\n[assembly: NeutralResourcesLanguageAttribute(\"en-US\")]\nnamespace MyLibrary\n{\n public class Foo\n {\n ResourceManager rm;\n public Foo()\n {\n rm = new ResourceManager(\"en-US\", Assembly.GetExecutingAssembly());\n }\n\n public void SetHour(int hour)\n {\n if (hour < 0 || hour > 23)\n {\n MessageBox.Show(\n rm.GetString(\"OutOfRangeMessage\", CultureInfo.CurrentUICulture));\n }\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4055.json",
"content": "{\n \"title\": \"Literals should not be passed as localized parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"localisation\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4055\",\n \"sqKey\": \"S4055\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4056.html",
"content": "When a System.Globalization.CultureInfo or IFormatProvider object is not supplied, the default value that is supplied by\nthe overloaded member might not have the effect that you want in all locales.
You should supply culture-specific information according to the following guidelines:
\nCultureInfo.CurrentCulture.CultureInfo.InvariantCulture.This rule raises an issue when a method or constructor calls one or more members that have overloads that accept a\nSystem.IFormatProvider parameter, and the method or constructor does not call the overload that takes the IFormatProvider\nparameter. This rule ignores calls to .NET Framework methods that are documented as ignoring the IFormatProvider parameter as well as the\nfollowing methods:
Activator.CreateInstanceResourceManager.GetObjectResourceManager.GetString\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar(String string1)\n {\n if(string.Compare(string1, string2, false) == 0) // Noncompliant\n {\n Console.WriteLine(string3.ToLower()); // Noncompliant\n }\n }\n }\n}\n\n\nusing System;\nusing System.Globalization;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar(String string1, String string2, String string3)\n {\n if(string.Compare(string1, string2, false,\n CultureInfo.InvariantCulture) == 0)\n {\n Console.WriteLine(string3.ToLower(CultureInfo.CurrentCulture));\n }\n }\n }\n}\n\nThis rule will not raise an issue when the overload is marked as obsolete.
\n\n" }, { "path": "analyzers/rspec/cs/S4056.json", "content": "{\n \"title\": \"Overloads with a \\\"CultureInfo\\\" or an \\\"IFormatProvider\\\" parameter should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"localisation\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4056\",\n \"sqKey\": \"S4056\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4057.html", "content": "When you create a DataTable or DataSet, you should set the locale explicitly. By default, the locale for these types is\nthe current culture. For data that is stored in a database or file and is shared globally, the locale should ordinarily be set to the invariant\nculture (CultureInfo.InvariantCulture).
This rule raises an issue when System.Data.DataTable or System.Data.DataSet instances are created without explicitly\nsetting the locale property (DataTable.Locale or DataSet.Locale).
\nusing System;\nusing System.Data;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public DataTable CreateTable()\n {\n DataTable table = new DataTable(\"Customers\"); // Noncompliant table.Locale not set\n DataColumn key = table.Columns.Add(\"ID\", typeof(Int32));\n\n key.AllowDBNull = false;\n key.Unique = true;\n table.Columns.Add(\"LastName\", typeof(String));\n table.Columns.Add(\"FirstName\", typeof(String));\n return table;\n }\n }\n}\n\n\nusing System;\nusing System.Data;\nusing System.Globalization;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public DataTable CreateTable()\n {\n DataTable table = new DataTable(\"Customers\");\n table.Locale = CultureInfo.InvariantCulture;\n DataColumn key = table.Columns.Add(\"ID\", typeof(Int32));\n\n key.AllowDBNull = false;\n key.Unique = true;\n table.Columns.Add(\"LastName\", typeof(String));\n table.Columns.Add(\"FirstName\", typeof(String));\n return table;\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4057.json",
"content": "{\n \"title\": \"Locales should be set for data types\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"localisation\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4057\",\n \"sqKey\": \"S4057\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4058.html",
"content": "Many string operations, the Compare and Equals methods in particular, provide an overload that accepts a\nStringComparison enumeration value as a parameter. Calling these overloads and explicitly providing this parameter makes your code\nclearer and easier to maintain.
This rule raises an issue when a string comparison operation doesn’t use the overload that takes a StringComparison parameter.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public bool HaveSameNames(string name1, string name2)\n {\n return string.Compare(name1, name2) == 0; // Noncompliant\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public bool HaveSameNames(string name1, string name2)\n {\n return string.Compare(name1, name2, StringComparison.OrdinalIgnoreCase) == 0;\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4058.json",
"content": "{\n \"title\": \"Overloads with a \\\"StringComparison\\\" parameter should be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4058\",\n \"sqKey\": \"S4058\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4059.html",
"content": "Properties and Get method should have names that makes them clearly distinguishable.
\nThis rule raises an issue when the name of a public or protected member starts with 'Get' and otherwise matches the name of a public or protected\nproperty.
\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public DateTime Date\n {\n get { return DateTime.Today; }\n }\n\n public string GetDate() // Noncompliant\n {\n return this.Date.ToString();\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public DateTime Date\n {\n get { return DateTime.Today; }\n }\n\n public string GetDateAsString()\n {\n return this.Date.ToString();\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4059.json",
"content": "{\n \"title\": \"Property names should not match get methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4059\",\n \"sqKey\": \"S4059\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4060.html",
"content": "The .NET framework class library provides methods for retrieving custom attributes. Sealing the attribute eliminates the search through the\ninheritance hierarchy, and can improve performance.
\nThis rule raises an issue when a public type inherits from System.Attribute, is not abstract, and is not sealed.
\nusing System;\n\npublic class MyAttribute: Attribute // Noncompliant\n{\n public string Name { get; }\n\n public MyAttribute(string name) =>\n Name = name;\n}\n\n\nusing System;\n\npublic sealed class MyAttribute : Attribute\n{\n public string Name { get; }\n\n public MyAttribute(string name) =>\n Name = name;\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4060.json",
"content": "{\n \"title\": \"Non-abstract attributes should be sealed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4060\",\n \"sqKey\": \"S4060\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4061.html",
"content": "A method using the VarArgs calling convention is not Common Language Specification (CLS) compliant and might not be accessible across\nprogramming languages, while the params keyword works the same way and is CLS compliant.
This rule raises an issue when a public or protected type contains a public or protected method\nthat uses the VarArgs calling convention.
\nusing System;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar(__arglist) // Noncompliant\n {\n ArgIterator argumentIterator = new ArgIterator(__arglist);\n for(int i = 0; i < argumentIterator.GetRemainingCount(); i++)\n {\n Console.WriteLine(\n __refvalue(argumentIterator.GetNextArg(), string));\n }\n }\n }\n}\n\n\nusing System;\n\n[assembly: CLSCompliant(true)]\nnamespace MyLibrary\n{\n public class Foo\n {\n public void Bar(params string[] wordList)\n {\n for(int i = 0; i < wordList.Length; i++)\n {\n Console.WriteLine(wordList[i]);\n }\n }\n }\n}\n\nInterop methods using VarArgs calling convention do not raise an issue.
\n[DllImport(\"msvcrt40.dll\")]\npublic static extern int printf(string format, __arglist); // Compliant\n\n\n" }, { "path": "analyzers/rspec/cs/S4061.json", "content": "{\n \"title\": \"\\\"params\\\" should be used instead of \\\"varargs\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4061\",\n \"sqKey\": \"S4061\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4069.html", "content": "
Operator overloading is convenient but unfortunately not portable across languages. To be able to access the same functionality from another\nlanguage you need to provide an alternate named method following the convention:
\n| Operator | \nMethod Name | \n
|---|---|
| \n
| \n \n Add \n | \n
| \n
| \n \n BitwiseAnd \n | \n
| \n
| \n \n BitwiseOr \n | \n
| \n
| \n \n Divide \n | \n
| \n
| \n \n Equals \n | \n
| \n
| \n \n Xor \n | \n
| \n
| \n \n Compare \n | \n
| \n
| \n \n Compare \n | \n
| \n
| \n \n Equals \n | \n
| \n
| \n \n Compare \n | \n
| \n
| \n \n Compare \n | \n
| \n
| \n \n LogicalNot \n | \n
| \n
| \n \n Mod \n | \n
| \n
| \n \n Multiply \n | \n
| \n
| \n \n OnesComplement \n | \n
| \n
| \n \n Subtract \n | \n
| \n
| \n \n Negate \n | \n
| \n
| \n \n Plus \n | \n
This rule raises an issue when there is an operator overload without the expected named alternative method.
\nThis rule does not raise an issue when the class implementing the comparison operators >, <, >= and\n<= contains a method named CompareTo.
This rule raises an issue when an externally visible enumeration is marked with FlagsAttribute and one, or more, of its values is not\na power of 2 or a combination of the other defined values.
\nusing System;\n\nnamespace MyLibrary\n{\n [Flags]\n public enum Color // Noncompliant, Orange is neither a power of two, nor a combination of any of the defined values\n {\n None = 0,\n Red = 1,\n Orange = 3,\n Yellow = 4\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public enum Color // Compliant - no FlagsAttribute\n {\n None = 0,\n Red = 1,\n Orange = 3,\n Yellow = 4\n }\n\n [Flags]\n public enum Days\n {\n None = 0,\n Monday = 1,\n Tuesday = 2,\n Wednesday = 4,\n Thursday = 8,\n Friday = 16,\n All = Monday| Tuesday | Wednesday | Thursday | Friday // Compliant - combination of other values\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4070.json",
"content": "{\n \"title\": \"Non-flags enums should not be marked with \\\"FlagsAttribute\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4070\",\n \"sqKey\": \"S4070\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4136.html",
"content": "For clarity, all overloads of the same method should be grouped together. That lets both users and maintainers quickly understand all the current\navailable options.
\n\ninterface IMyInterface\n{\n int DoTheThing(); // Noncompliant - overloaded method declarations are not grouped together\n string DoTheOtherThing();\n int DoTheThing(string s);\n}\n\n\ninterface IMyInterface\n{\n int DoTheThing();\n int DoTheThing(string s);\n string DoTheOtherThing();\n}\n\nAs it is common practice to group method declarations by implemented interface, no issue will be raised for implicit and explicit interface\nimplementations if grouped together with other members of that interface.
\nAs it is also a common practice to group method declarations by accessibility level, no issue will be raised for method overloads having different\naccess modifiers.
\nExample:
\n\nclass MyClass\n{\n private void DoTheThing(string s) // Ok - this method is declared as private while the other one is public\n {\n // ...\n }\n\n private string DoTheOtherThing(string s)\n {\n // ...\n }\n\n public void DoTheThing()\n {\n // ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4136.json",
"content": "{\n \"title\": \"Method overloads should be grouped together\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4136\",\n \"sqKey\": \"S4136\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4143.html",
"content": "Storing a value inside a collection at a given key or index and then unconditionally overwriting it without reading the initial value is a case of\na \"dead store\".
\n\nlist[index] = \"value 1\";\nlist[index] = \"value 2\"; // Noncompliant\n\ndictionary.Add(key, \"value 1\");\ndictionary[key] = \"value 2\"; // Noncompliant\n\n
This practice is redundant and will cause confusion for the reader. More importantly, it is often an error and not what the developer intended to\ndo.
\n\n" }, { "path": "analyzers/rspec/cs/S4143.json", "content": "{\n \"title\": \"Collection elements should not be replaced unconditionally\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4143\",\n \"sqKey\": \"S4143\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4144.html", "content": "Two methods having the same implementation are suspicious. It might be that something else was intended. Or the duplication is intentional, which\nbecomes a maintenance burden.
\n\nprivate const string CODE = \"secret\";\nprivate int callCount = 0;\n\npublic string GetCode()\n{\n callCount++;\n return CODE;\n}\n\npublic string GetName() // Noncompliant: duplicates GetCode\n{\n callCount++;\n return CODE;\n}\n\nIf the identical logic is intentional, the code should be refactored to avoid duplication. For example, by having both methods call the same method\nor by having one implementation invoke the other.
\n\nprivate const string CODE = \"secret\";\nprivate int callCount = 0;\n\npublic string GetCode()\n{\n callCount++;\n return CODE;\n}\n\npublic string GetName() // Intent is clear\n{\n return GetCode();\n}\n\nEmpty methods, methods with only one line of code and methods with the same name (overload) are ignored.
\n\n" }, { "path": "analyzers/rspec/cs/S4144.json", "content": "{\n \"title\": \"Methods should not have identical implementations\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"DISTINCT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"confusing\",\n \"duplicate\",\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4144\",\n \"sqKey\": \"S4144\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/cs/S4158.html", "content": "When a collection is empty, iterating it has no effect. Doing so anyway is likely a bug; either population was accidentally omitted, or the\niteration needs to be revised.
\n\npublic void Method()\n{\n var values = new List<string>();\n values.Remove(\"bar\"); // Noncompliant\n if (values.Contains(\"foo\")) { } // Noncompliant\n foreach (var str in values) { } // Noncompliant\n}\n\n\npublic void Method()\n{\n var values = LoadValues();\n values.Remove(\"bar\");\n if (values.Contains(\"foo\")) { }\n foreach (var str in values) { }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4158.json",
"content": "{\n \"title\": \"Empty collections should not be accessed or iterated\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"symbolic-execution\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4158\",\n \"sqKey\": \"S4158\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4159.html",
"content": "The Attributed Programming Model,\nalso known as Attribute-oriented programming (@OP), is a programming model\nused to embed attributes within codes.
\nIn this model, objects are required to conform to a specific structure so that they can be used by the
MEF provides a way to discover available components implicitly, via composition. A MEF component, called a part,\ndeclaratively specifies:
\nThe ExportAttribute declares that a part \"exports\",\nor provides to the composition container, an object that fulfills a particular contract.
\nDuring composition, parts with imports that have matching contracts will have those dependencies filled by the exported object.
\nIf the type doesn’t implement the interface it is exporting there will be an issue at runtime (either a cast exception or just a container not\nfilled with the exported type) leading to unexpected behaviors/crashes.
\nThe rule raises an issue when a class doesn’t implement or inherit the type declared in the ExportAttribute.
\n[Export(typeof(ISomeType))]\npublic class SomeType // Noncompliant: doesn't implement 'ISomeType'.\n{\n}\n\n\n[Export(typeof(ISomeType))]\npublic class SomeType : ISomeType\n{\n}\n\nNative methods are functions that reside in libraries outside the .NET runtime. Calling them is helpful for interoperability with applications and\nlibraries written in other programming languages, mainly when performing platform-specific operations. However, doing so comes with additional risks\nsince it means stepping out of the memory-safety model of the runtime. It is therefore highly recommended to take extra steps, like input validation,\nwhen invoking native methods. Making the native method private and providing a wrapper that performs these additional steps is the best\nway to do so.
This rule raises an issue when a native method is declared public or its wrapper is too trivial.
\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n class Foo\n {\n [DllImport(\"mynativelib\")]\n extern public static void Bar(string s, int x); // Noncompliant\n }\n}\n\n\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n class Foo\n {\n [DllImport(\"mynativelib\")]\n extern private static void Bar(string s, int x);\n\n public void BarWrapper(string s, int x)\n {\n if (s != null && x >= 0 && x < s.Length)\n {\n Bar(s, x);\n }\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4200.json",
"content": "{\n \"title\": \"Native methods should be wrapped\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"30min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4200\",\n \"sqKey\": \"S4200\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4201.html",
"content": "There’s no need to null test in conjunction with an is test. null is not an instance of anything, so a null check is\nredundant.
\nif (x != null && x is MyClass) { ... } // Noncompliant\n\nif (x == null || !(x is MyClass)) { ... } // Noncompliant\n\n\nif (x is MyClass) { ... }\n\nif (!(x is MyClass)) { ... }\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4201.json",
"content": "{\n \"title\": \"Null checks should not be combined with \\\"is\\\" operator checks\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"redundant\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4201\",\n \"sqKey\": \"S4201\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4210.html",
"content": "When an assembly uses Windows Forms (classes and interfaces from the System.Windows.Forms namespace) its entry point should be marked\nwith the STAThreadAttribute to indicate that the threading model should be \"Single-Threaded Apartment\" (STA) which is the only one\nsupported by Windows Forms.
This rule raises an issue when the entry point (static void Main method) of an assembly using Windows Forms is not marked as STA.
\nusing System;\nusing System.Windows.Forms;\n\nnamespace MyLibrary\n{\n public class MyForm: Form\n {\n public MyForm()\n {\n this.Text = \"Hello World!\";\n }\n\n public static void Main() // Noncompliant\n {\n var form = new MyForm();\n Application.Run(form);\n }\n }\n}\n\n\nusing System;\nusing System.Windows.Forms;\n\nnamespace MyLibrary\n{\n public class MyForm: Form\n {\n public MyForm()\n {\n this.Text = \"Hello World!\";\n }\n\n [STAThread]\n public static void Main()\n {\n var form = new MyForm();\n Application.Run(form);\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4210.json",
"content": "{\n \"title\": \"Windows Forms entry points should be marked with STAThread\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"winforms\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4210\",\n \"sqKey\": \"S4210\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4211.html",
"content": "Transparency attributes in the .NET Framework, designed to protect security-critical operations, can lead to ambiguities and vulnerabilities when\ndeclared at different levels such as both for the class and a method.
\nTransparency attributes can be declared at several levels. If two different attributes are declared at two different levels, the attribute that\nprevails is the one in the highest level. For example, you can declare that a class is SecuritySafeCritical and that a method of this\nclass is SecurityCritical. In this case, the method will be SecuritySafeCritical and the SecurityCritical\nattribute attached to it is ignored.
Below are some real-world scenarios that illustrate some impacts of an attacker exploiting the vulnerability.
\nAn attacker could potentially exploit conflicting transparency attributes to perform actions with higher privileges than intended.
\nIf a member with conflicting attributes is involved in handling sensitive data, an attacker could exploit the vulnerability to gain unauthorized\naccess to this data. This could lead to breaches of confidentiality and potential data loss.
\n\nusing System;\nusing System.Security;\n\nnamespace MyLibrary\n{\n [SecuritySafeCritical]\n public class Foo\n {\n [SecurityCritical] // Noncompliant\n public void Bar()\n {\n }\n }\n}\n\n\nusing System;\nusing System.Security;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n [SecurityCritical]\n public void Bar()\n {\n }\n }\n}\n\nA class should never have class-level annotations if some functions have different permission levels. Instead, make sure every function has its own\ncorrect annotation.
\nIf no function needs a particularly distinct security annotation in a class, just set a class-level [SecurityCritical].
This rule is deprecated, and will eventually be removed.
\nBecause serialization constructors allocate and initialize objects, security checks that are present on regular constructors must also be present\non a serialization constructor. Failure to do so would allow callers that could not otherwise create an instance to use the serialization constructor\nto do this.
\nThis rule raises an issue when a type implements the System.Runtime.Serialization.ISerializable interface, is not a delegate or\ninterface, is declared in an assembly that allows partially trusted callers and has a constructor that takes a\nSystem.Runtime.Serialization.SerializationInfo object and a System.Runtime.Serialization.StreamingContext object which is\nnot secured by a security check, but one or more of the regular constructors in the type is secured.
\nusing System;\nusing System.IO;\nusing System.Runtime.Serialization;\nusing System.Runtime.Serialization.Formatters.Binary;\nusing System.Security;\nusing System.Security.Permissions;\n\n[assembly: AllowPartiallyTrustedCallersAttribute()]\nnamespace MyLibrary\n{\n [Serializable]\n public class Foo : ISerializable\n {\n private int n;\n\n [FileIOPermissionAttribute(SecurityAction.Demand, Unrestricted = true)]\n public Foo()\n {\n n = -1;\n }\n\n protected Foo(SerializationInfo info, StreamingContext context) // Noncompliant\n {\n n = (int)info.GetValue(\"n\", typeof(int));\n }\n\n void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)\n {\n info.AddValue(\"n\", n);\n }\n }\n}\n\n\nusing System;\nusing System.IO;\nusing System.Runtime.Serialization;\nusing System.Runtime.Serialization.Formatters.Binary;\nusing System.Security;\nusing System.Security.Permissions;\n\n[assembly: AllowPartiallyTrustedCallersAttribute()]\nnamespace MyLibrary\n{\n [Serializable]\n public class Foo : ISerializable\n {\n private int n;\n\n [FileIOPermissionAttribute(SecurityAction.Demand, Unrestricted = true)]\n public Foo()\n {\n n = -1;\n }\n\n [FileIOPermissionAttribute(SecurityAction.Demand, Unrestricted = true)]\n protected Foo(SerializationInfo info, StreamingContext context)\n {\n n = (int)info.GetValue(\"n\", typeof(int));\n }\n\n void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)\n {\n info.AddValue(\"n\", n);\n }\n }\n}\n\nThis rule is deprecated; use {rule:csharpsquid:S4200} instead.
\nMethods marked with the System.Runtime.InteropServices.DllImportAttribute attribute use Platform Invocation Services to access\nunmanaged code and should not be exposed. Keeping them private or internal makes sure that their access is controlled and properly managed.
This rule raises an issue when a method declared with DllImport is public or protected.
\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n [DllImport(\"kernel32.dll\", CharSet = CharSet.Unicode)]\n public static extern bool RemoveDirectory(string name); // Noncompliant\n }\n}\n\n\nusing System;\nusing System.Runtime.InteropServices;\n\nnamespace MyLibrary\n{\n public class Foo\n {\n [DllImport(\"kernel32.dll\", CharSet = CharSet.Unicode)]\n private static extern bool RemoveDirectory(string name);\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4214.json",
"content": "{\n \"title\": \"\\\"P\\/Invoke\\\" methods should not be visible\",\n \"type\": \"CODE_SMELL\",\n \"status\": \"deprecated\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4214\",\n \"sqKey\": \"S4214\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4220.html",
"content": "When raising an event, two arguments are expected by the EventHandler delegate: Sender and event-data. There are three guidelines\nregarding these parameters:
null as the sender when raising a non-static event.null as the sender when raising a static event.null as the event-data. If no data should be passed, then EventArgs.Empty should be used.This rule raises an issue when any of these guidelines is not met.
\n\nusing System;\n\nnamespace MyLibrary\n{\n class Foo\n {\n public event EventHandler ThresholdReached;\n\n protected virtual void OnThresholdReached(EventArgs e)\n {\n ThresholdReached?.Invoke(null, e); // Noncompliant\n }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n class Foo\n {\n public event EventHandler ThresholdReached;\n\n protected virtual void OnThresholdReached(EventArgs e)\n {\n ThresholdReached?.Invoke(this, e);\n }\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4220.json",
"content": "{\n \"title\": \"Events should have proper arguments\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"event\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4220\",\n \"sqKey\": \"S4220\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4225.html",
"content": "Creating an extension method that extends object is not recommended because it makes the method available on every type.\nExtensions should be applied at the most specialized level possible, and that is very unlikely to be object.
\npublic static class MyExtensions\n{\n public static void SomeExtension(this object obj) // Noncompliant\n {\n // ...\n }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4225.json",
"content": "{\n \"title\": \"Extension methods should not extend \\\"object\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4225\",\n \"sqKey\": \"S4225\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4226.html",
"content": "It makes little sense to create an extension method when it is possible to just add that method to the class itself.
\nThis rule raises an issue when an extension is declared in the same namespace as the class it is extending.
\n\nnamespace MyLibrary\n{\n public class Foo\n {\n // ...\n }\n\n public static class MyExtensions\n {\n public static void Bar(this Foo a) // Noncompliant\n {\n // ...\n }\n }\n}\n\nUsing separate namespace:
\n\nnamespace MyLibrary\n{\n public class Foo\n {\n // ...\n }\n}\n\nnamespace Helpers\n{\n public static class MyExtensions\n {\n public static void Bar(this Foo a)\n {\n // ...\n }\n }\n}\n\nMerging the method in the class:
\n\nnamespace MyLibrary\n{\n public class Foo\n {\n // ...\n public void Bar()\n {\n // ...\n }\n }\n}\n\nSystem.CodeDom.Compiler.GeneratedCodeAttribute attribute.When creating a custom Markup Extension\nthat accepts parameters in WPF, the ConstructorArgument markup\nmust be used to identify the discrete properties that match these parameters. However since this is done via a string, the compiler won’t give you any\nwarning in case there are typos.
This rule raises an issue when the string argument to ConstructorArgumentAttribute doesn’t match any parameter of any constructor.
\nusing System;\n\nnamespace MyLibrary\n{\n public class MyExtension : MarkupExtension\n {\n public MyExtension() { }\n\n public MyExtension(object value1)\n {\n Value1 = value1;\n }\n\n [ConstructorArgument(\"value2\")] // Noncompliant\n public object Value1 { get; set; }\n }\n}\n\n\nusing System;\n\nnamespace MyLibrary\n{\n public class MyExtension : MarkupExtension\n {\n public MyExtension() { }\n\n public MyExtension(object value1)\n {\n Value1 = value1;\n }\n\n [ConstructorArgument(\"value1\")]\n public object Value1 { get; set; }\n }\n}\n\nAccording to the Task-based Asynchronous Pattern (TAP), methods returning either a System.Threading.Tasks.Task or a\nSystem.Threading.Tasks.Task<TResult> are considered \"asynchronous\". Such methods should use the Async suffix.\nConversely methods which do not return such Tasks should not have an \"Async\" suffix in their names.
\nusing System;\nusing System.Threading.Tasks;\n\nnamespace myLibrary\n{\n\n public class Foo\n {\n public Task Read(byte [] buffer, int offset, int count, // Noncompliant\n CancellationToken cancellationToken)\n }\n}\n\n\nusing System;\nusing System.Threading.Tasks;\n\nnamespace myLibrary\n{\n\n public class Foo\n {\n public Task ReadAsync(byte [] buffer, int offset, int count, CancellationToken cancellationToken)\n }\n}\n\nThis rule doesn’t raise an issue when the method is an override or part of the implementation of an interface since it can not be renamed.
\nProperties provide a way to enforce encapsulation by providing\naccessors that give controlled access to private fields. However, in classes with multiple fields, it is not unusual that
\nclass C\n{\n private int x;\n private int y;\n public int Y => x; // Noncompliant: The returned field should be 'y'\n}\n\nThis rule raises an issue in any of these cases:
\nFor simple properties, it is better to use
Field and property names are compared as case-insensitive. All underscore characters are ignored.
\n\nclass A\n{\n private int x;\n private int y;\n\n public int X\n {\n get { return x; }\n set { x = value; }\n }\n\n public int Y\n {\n get { return x; } // Noncompliant: field 'y' is not used in the return value\n set { x = value; } // Noncompliant: field 'y' is not updated\n }\n}\n\n\nclass A\n{\n private int x;\n private int y;\n\n public int X\n {\n get { return x; }\n set { x = value; }\n }\n\n public int Y\n {\n get { return y; }\n set { y = value; }\n }\n}\n\nMarking a class with PartCreationPolicy(CreationPolicy.Shared), which is\npart of Managed Extensibility Framework (MEF), means that a single, shared\ninstance of the exported object will be created. Therefore it doesn’t make sense to create new instances using the constructor and it will most likely\nresult in unexpected behaviours.
This rule raises an issue when a constructor of a class marked shared with a PartCreationPolicyAttribute is invoked.
\n[Export(typeof(IFooBar))]\n[PartCreationPolicy(CreationPolicy.Shared)]\npublic class FooBar : IFooBar\n{\n}\n\npublic class Program\n{\n public static void Main()\n {\n var fooBar = new FooBar(); // Noncompliant;\n }\n}\n\n\n[Export(typeof(IFooBar))]\n[PartCreationPolicy(CreationPolicy.Shared)]\npublic class FooBar : IFooBar\n{\n}\n\npublic class Program\n{\n public static void Main()\n {\n var fooBar = serviceProvider.GetService<IFooBar>();\n }\n}\n\nPartCreationPolicyCreationPolicy.SharedCryptographic operations often rely on unpredictable random numbers to enhance security. These random numbers are created by cryptographically\nsecure pseudo-random number generators (CSPRNG). It is important not to use a predictable seed with these random number generators otherwise the\nrandom numbers will also become predictable.
\nRandom number generators are often used to generate random values for cryptographic algorithms. When a random number generator is used for\ncryptographic purposes, the generated numbers must be as random and unpredictable as possible. When the random number generator is improperly seeded\nwith a constant or a predictable value, its output will also be predictable.
\nThis can have severe security implications for cryptographic operations that rely on the randomness of the generated numbers. By using a\npredictable seed, an attacker can potentially guess or deduce the generated numbers, compromising the security of whatever cryptographic algorithm\nrelies on the random number generator.
\nIt is crucial to understand that the strength of cryptographic algorithms heavily relies on the quality of the random numbers used. By improperly\nseeding a CSPRNG, we introduce a significant weakness that can be exploited by attackers.
\nOne of the primary use cases for CSPRNGs is generating cryptographic keys. If an attacker can predict the seed used to initialize the random number\ngenerator, they may be able to derive the same keys. Depending on the use case, this can lead to multiple severe outcomes, such as:
\nAnother scenario where this vulnerability can be exploited is in the generation of session tokens or nonces for secure communication protocols. If\nan attacker can predict the seed used to generate these tokens, they can impersonate legitimate users or intercept sensitive information.
\nBouncyCastle provides several random number generators implementations. Most of these will automatically create unpredictable output.
\nThe remaining random number generators require seeding with an unpredictable value before they will produce unpredictable outputs. These should be\nseeded with at least 16 bytes of random data to ensure unpredictable output and that the random seed cannot be guessed using a brute-force attack.
\nSecureRandom instances created with GetInstance() are seeded by default. Disabling seeding results in predictable\noutput.
\nusing Org.BouncyCastle.Security;\n\nbyte[] random = new byte[8];\n\nSecureRandom sr = SecureRandom.GetInstance(\"SHA256PRNG\", false);\nsr.NextBytes(random); // Noncompliant\n\n
DigestRandomGenerator and VmpcRandomGenerator instances require seeding before use. Predictable seed values will result\nin predictable outputs.
\nusing Org.BouncyCastle.Crypto.Digest;\nusing Org.BouncyCastle.Crypto.Prng;\n\nbyte[] random = new byte[8];\n\nIRandomGenerator digest = new DigestRandomGenerator(new Sha256Digest());\ndigest.AddSeedMaterial(Encoding.UTF8.GetBytes(\"predictable seed value\"));\ndigest.NextBytes(random); // Noncompliant\n\nIRandomGenerator vmpc = new VmpcRandomGenerator();\nvmpc.AddSeedMaterial(Convert.FromBase64String(\"2hq9pkyqLQJkrYTrEv1eNw==\"));\nvmpc.NextBytes(random); // Noncompliant\n\n
When a SecureRandom is created using an unseeded DigestRandomGenerator and VmpcRandomGenerator instance, the\nSecureRandom will create predictable outputs.
\nusing Org.BouncyCastle.Crypto.Digest;\nusing Org.BouncyCastle.Crypto.Prng;\nusing Org.BouncyCastle.Security;\n\nbyte[] random = new byte[8];\n\nIRandomGenerator digest = new DigestRandomGenerator(new Sha256Digest());\nSecureRandom sr = new SecureRandom(digest);\nsr.NextBytes(random); // Noncompliant\n\n
Allow SecureRandom.GetInstance() to automatically seed new SecureRandom instances.
\nusing Org.BouncyCastle.Security;\n\nbyte[] random = new byte[8];\n\nSecureRandom sr = SecureRandom.GetInstance(\"SHA256PRNG\");\nsr.NextBytes(random);\n\n
Use unpredictable values to seed DigestRandomGenerator and VmpcRandomGenerator instances. The\nSecureRandom.GenerateSeed() method is designed for this purpose.
\nusing Org.BouncyCastle.Crypto.Digest;\nusing Org.BouncyCastle.Crypto.Prng;\nusing Org.BouncyCastle.Security;\n\nbyte[] random = new byte[8];\n\nIRandomGenerator digest = new DigestRandomGenerator(new Sha256Digest());\ndigest.AddSeedMaterial(SecureRandom.GenerateSeed(16));\ndigest.NextBytes(random);\n\nIRandomGenerator vmpc = new VmpcRandomGenerator();\nvmpc.AddSeedMaterial(SecureRandom.GenerateSeed(16));\nvmpc.NextBytes(random);\n\n
An overload of the SecureRandom constructor will automatically seed the underlying IRandomGenerator with an unpredictable\nvalue.
\nusing Org.BouncyCastle.Crypto.Digest;\nusing Org.BouncyCastle.Crypto.Prng;\nusing Org.BouncyCastle.Security;\n\nbyte[] random = new byte[8];\n\nIRandomGenerator digest = new DigestRandomGenerator(new Sha256Digest());\nSecureRandom sr = new SecureRandom(digest, 16);\nsr.NextBytes(random);\n\n
(visible only on this page)
\nWhen the random number generator’s output is not predictable by default:
\n\n\nChange this seed value to something unpredictable, or remove the seed.
\n
When the random number generator’s output is predictable by default:
\n\n\nSet an unpredictable seed before generating random values.
\n
When the random number generator’s output is not predictable by default:
\nWhen the random number generator’s output is predictable by default:
\nIf the factory method or constructor is not already highlighted, it should become a secondary highlight.
\n\n" }, { "path": "analyzers/rspec/cs/S4347.json", "content": "{\n \"title\": \"Secure random number generators should not output predictable values\",\n \"type\": \"VULNERABILITY\",\n \"code\": {\n \"impacts\": {\n \"SECURITY\": \"HIGH\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"cwe\",\n \"pitfall\",\n \"symbolic-execution\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-4347\",\n \"sqKey\": \"S4347\",\n \"scope\": \"Main\",\n \"securityStandards\": {\n \"CWE\": [\n 330,\n 332,\n 336,\n 337\n ],\n \"OWASP\": [\n \"A6\"\n ],\n \"OWASP Top 10 2021\": [\n \"A2\"\n ],\n \"ASVS 4.0\": [\n \"2.3.1\",\n \"2.6.2\",\n \"2.9.2\"\n ]\n },\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4423.html", "content": "This vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nTo provide communication security over a network, SSL and TLS are generally used. However, it is important to note that the following protocols are\nall considered weak by the cryptographic community, and are officially deprecated:
\nWhen these unsecured protocols are used, it is best practice to expect a breach: that a user or organization with malicious intent will perform\nmathematical attacks on this data after obtaining it by other means.
\nAfter retrieving encrypted data and performing cryptographic attacks on it on a given timeframe, attackers can recover the plaintext that\nencryption was supposed to protect.
\nDepending on the recovered data, the impact may vary.
\nBelow are some real-world scenarios that illustrate the potential impact of an attacker exploiting the vulnerability.
\nBy modifying the plaintext of the encrypted message, an attacker may be able to trigger additional vulnerabilities in the code. An attacker can\nfurther exploit a system to obtain more information.\n
\n Encrypted values are often considered trustworthy because it would not be possible for a third party to modify them under normal circumstances.
When encrypted data contains personal or sensitive information, its retrieval by an attacker can lead to privacy violations, identity theft,\nfinancial loss, reputational damage, or unauthorized access to confidential systems.
\nIn this scenario, the company, its employees, users, and partners could be seriously affected.
\nThe impact is twofold, as data breaches and exposure of encrypted data can undermine trust in the organization, as customers, clients and\nstakeholders may lose confidence in the organization’s ability to protect their sensitive data.
\nIn many industries and locations, there are legal and compliance requirements to protect sensitive data. If encrypted data is compromised and the\nplaintext can be recovered, companies face legal consequences, penalties, or violations of privacy laws.
\nThese samples use TLSv1.0 as the default TLS algorithm, which is cryptographically weak.
\n\nusing System.Net;\n\npublic void encrypt()\n{\n ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls; // Noncompliant\n}\n\n\nusing System.Net.Http;\nusing System.Security.Authentication;\n\npublic void encrypt()\n{\n new HttpClientHandler\n {\n SslProtocols = SslProtocols.Tls // Noncompliant\n };\n}\n\n\nUsing System.Net;\n\npublic void encrypt()\n{\n ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls13;\n}\n\n\nusing System.Net.Http;\nusing System.Security.Authentication;\n\npublic void encrypt()\n{\n new HttpClientHandler\n {\n SslProtocols = SslProtocols.Tls12\n };\n}\n\nAs a rule of thumb, by default you should use the cryptographic algorithms and mechanisms that are considered strong by the cryptographic\ncommunity.
\nThe best choices at the moment are the following.
\nEven though TLS V1.3 is available, using TLS v1.2 is still considered good and secure practice by the cryptography community.\n
The use of TLS v1.2 ensures compatibility with a wide range of platforms and enables seamless communication between different systems that do not\nyet have TLS v1.3 support.
\nThe only drawback depends on whether the framework used is outdated: its TLS v1.2 settings may enable older and insecure cipher suites that are\ndeprecated as insecure.
\nOn the other hand, TLS v1.3 removes support for older and weaker cryptographic algorithms, eliminates known vulnerabilities from previous TLS\nversions, and improves performance.
\nThis vulnerability exposes encrypted data to attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nIn today’s cryptography, the length of the key directly affects the security level of cryptographic algorithms.
\nNote that depending on the algorithm, the term key refers to a different mathematical property. For example:
\nIf an application uses a key that is considered short and insecure, the encrypted data is exposed to attacks aimed at getting at\nthe plaintext.
\nIn general, it is best practice to expect a breach: that a user or organization with malicious intent will perform cryptographic attacks on this\ndata after obtaining it by other means.
\nAfter retrieving encrypted data and performing cryptographic attacks on it on a given timeframe, attackers can recover the plaintext that\nencryption was supposed to protect.
\nDepending on the recovered data, the impact may vary.
\nBelow are some real-world scenarios that illustrate the potential impact of an attacker exploiting the vulnerability.
\nBy modifying the plaintext of the encrypted message, an attacker may be able to trigger additional vulnerabilities in the code. An attacker can\nfurther exploit a system to obtain more information.\n
\n Encrypted values are often considered trustworthy because it would not be possible for a third party to modify them under normal circumstances.
When encrypted data contains personal or sensitive information, its retrieval by an attacker can lead to privacy violations, identity theft,\nfinancial loss, reputational damage, or unauthorized access to confidential systems.
\nIn this scenario, the company, its employees, users, and partners could be seriously affected.
\nThe impact is twofold, as data breaches and exposure of encrypted data can undermine trust in the organization, as customers, clients and\nstakeholders may lose confidence in the organization’s ability to protect their sensitive data.
\nIn many industries and locations, there are legal and compliance requirements to protect sensitive data. If encrypted data is compromised and the\nplaintext can be recovered, companies face legal consequences, penalties, or violations of privacy laws.
\nThe following code examples either explicitly or implicitly generate keys. Note that there are differences in the size of the keys depending on the\nalgorithm.
\nDue to the mathematical properties of the algorithms, the security requirements for the key size vary depending on the algorithm.\n
\n For example, a 256-bit ECC key provides about the same level of security as a 3072-bit RSA key and a 128-bit symmetric key.
Here is an example of a private key generation with RSA:
\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n var RsaCsp = new RSACryptoServiceProvider(); // Noncompliant\n}\n\nHere is an example of a key generation with the Digital Signature Algorithm (DSA):
\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n var DsaCsp = new DSACryptoServiceProvider(); // Noncompliant\n}\n\nHere is an example of an Elliptic Curve (EC) initialization. It implicitly generates a private key whose size is indicated in the elliptic curve\nname:
\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n ECDsa ecdsa = ECDsa.Create(ECCurve.NamedCurves.brainpoolP160t1); // Noncompliant\n}\n\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n var RsaCsp = new RSACryptoServiceProvider(2048);\n}\n\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n var Dsa = new DSACng(2048);\n}\n\n\nusing System;\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n ECDsa ecdsa = ECDsa.Create(ECCurve.NamedCurves.nistP256);\n}\n\nAs a rule of thumb, use the cryptographic algorithms and mechanisms that are considered strong by the cryptography community.
\nThe appropriate choices are the following.
\nThe security of these algorithms depends on the difficulty of attacks attempting to solve their underlying mathematical problem.
\nIn general, a minimum key size of 2048 bits is recommended for both. It provides 112 bits of security. A key length of\n3072 or 4096 should be preferred when possible.
\nElliptic curve cryptography is also used in various algorithms, such as ECDSA, ECDH, or ECMQV. The length of keys generated with elliptic curve\nalgorithms is mentioned directly in their names. For example, secp256k1 generates a 256-bits long private key.
Currently, a minimum key size of 224 bits is recommended for EC-based algorithms.
\nAdditionally, some curves that theoretically provide sufficiently long keys are still discouraged. This can be because of a flaw in the curve\nparameters, a bad overall design, or poor performance. It is generally advised to use a NIST-approved elliptic curve wherever possible. Such curves\ncurrently include:
\nThe following code is invalid:
\n\n ----\n var RsaCsp = new RSACryptoServiceProvider();\n RsaCsp.KeySize = 2048;\n----\n\n
The KeySize property of CryptoServiceProviders cannot be updated because the setter simply does not exist. This means that this line will not\nperform any update on KeySize, and the compiler won’t raise an Exception when compiling it. This should not be considered a workaround.\n
\n To change the key size, use one of the overloaded constructors with the desired key size instead.
Encrypted data and communications recorded today could be decrypted in the future by an attack from a quantum computer.\n
\n It is important to keep in mind that NIST-approved digital signature schemes, key agreement, and key transport may need to be replaced with secure\n quantum-resistant (or \"post-quantum\") counterpart.
Thus, if data is to remain secure beyond 2030, proactive measures should be taken now to ensure its safety.
\n\nTo customize the default behavior for an export in the Managed Extensibility\nFramework (MEF), applying the PartCreationPolicyAttribute\nis necessary. For the PartCreationPolicyAttribute\nto be meaningful in the context of an export, the class must also be annotated with the ExportAttribute.
This rule raises an issue when a class is annotated with the PartCreationPolicyAttribute but not with the\nExportAttribute.
\nusing System.ComponentModel.Composition;\n\n[PartCreationPolicy(CreationPolicy.Any)] // Noncompliant\npublic class FooBar : IFooBar { }\n\n\nusing System.ComponentModel.Composition;\n\n[Export(typeof(IFooBar))]\n[PartCreationPolicy(CreationPolicy.Any)]\npublic class FooBar : IFooBar { }\n\nLightweight Directory Access Protocol (LDAP) servers provide two main authentication methods: the SASL and Simple ones. The\nSimple Authentication method also breaks down into three different mechanisms:
\nA server that accepts either the Anonymous or Unauthenticated mechanisms will accept connections from clients not providing\ncredentials.
\nWhen configured to accept the Anonymous or Unauthenticated authentication mechanism, an LDAP server will accept connections from clients that do\nnot provide a password or other authentication credentials. Such users will be able to read or modify part or all of the data contained in the hosted\ndirectory.
\nAn attacker exploiting unauthenticated access to an LDAP server can access the data that is stored in the corresponding directory. The impact\nvaries depending on the permission obtained on the directory and the type of data it stores.
\nIf attackers get write access to the directory, they will be able to alter most of the data it stores. This might include sensitive technical data\nsuch as user passwords or asset configurations. Such an attack can typically lead to an authentication bypass on applications and systems that use the\naffected directory as an identity provider.
\nIn such a case, all users configured in the directory might see their identity and privileges taken over.
\nIf attackers get read-only access to the directory, they will be able to read the data it stores. That data might include security-sensitive pieces\nof information.
\nTypically, attackers might get access to user account lists that they can use in further intrusion steps. For example, they could use such lists to\nperform password spraying, or related attacks, on all systems that rely on the affected directory as an identity provider.
\nIf the directory contains some Personally Identifiable Information, an attacker accessing it might represent a violation of regulatory requirements\nin some countries. For example, this kind of security event would go against the European GDPR law.
\nThe following code indicates an anonymous LDAP authentication vulnerability because it binds to a remote server using an Anonymous Simple\nauthentication mechanism.
\n\nDirectoryEntry myDirectoryEntry = new DirectoryEntry(adPath);\nmyDirectoryEntry.AuthenticationType = AuthenticationTypes.None; // Noncompliant\n\nDirectoryEntry myDirectoryEntry = new DirectoryEntry(adPath, \"u\", \"p\", AuthenticationTypes.None); // Noncompliant\n\n
\nDirectoryEntry myDirectoryEntry = new DirectoryEntry(myADSPath); // Compliant; default DirectoryEntry.AuthenticationType property value is \"Secure\" since .NET Framework 2.0\n\nDirectoryEntry myDirectoryEntry = new DirectoryEntry(myADSPath, \"u\", \"p\", AuthenticationTypes.Secure);\n\n
Because of the way yield methods are rewritten by the compiler (they become lazily evaluated state machines) any exceptions thrown\nduring the parameters check will happen only when the collection is iterated over. That could happen far away from the source of the buggy code.
Therefore it is recommended to split the method into two: an outer method handling the validation (no longer lazy) and an inner (lazy) method to\nhandle the iteration.
\nThis rule raises an issue when a method throws any exception derived from ArgumentException and contains the yield\nkeyword.
\npublic static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) // Noncompliant\n{\n if (source == null) { throw new ArgumentNullException(nameof(source)); }\n if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); }\n\n foreach (var element in source)\n {\n if (!predicate(element)) { break; }\n yield return element;\n }\n}\n\n\npublic static async IAsyncEnumerable<TSource> TakeWhileAsync(this IEnumerable<TSource> source, Func<TSource, bool> predicate) // Noncompliant\n{\n if (source == null) { throw new ArgumentNullException(nameof(source)); }\n if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); }\n\n foreach (var element in source)\n {\n await Task.Delay(10);\n if (!predicate(element)) { break; }\n yield return element;\n }\n}\n\n\npublic static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)\n{\n if (source == null) { throw new ArgumentNullException(nameof(source)); }\n if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); }\n return TakeWhileIterator<TSource>(source, predicate);\n}\n\nprivate static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)\n{\n foreach (TSource element in source)\n {\n if (!predicate(element)) break;\n yield return element;\n }\n}\n\n\npublic static IAsyncEnumerable<TSource> TakeWhileAsync(this IEnumerable<TSource> source, Func<TSource, bool> predicate)\n{\n if (source == null) { throw new ArgumentNullException(nameof(source)); }\n if (predicate == null) { throw new ArgumentNullException(nameof(predicate)); }\n\n return TakeWhileAsyncIterator<TSource>(source, predicate);\n}\n\nprivate static async IAsyncEnumerable<TSource> TakeWhileAsyncIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)\n{\n foreach (TSource element in source)\n {\n await Task.Delay(10);\n if (!predicate(element)) break;\n yield return element;\n }\n}\n\nasync/await methods should be wrappedBecause of the way async/await methods are rewritten by the compiler, any exceptions thrown during the parameters check\nare captured in the returned Task and will only be observed when the task is awaited. That could happen far away from the source of the\nbuggy code or never happen for fire-and-forget tasks.
Therefore it is recommended to split the method into two: an outer method handling the parameter checks (without being\nasync/await) and an inner method to handle the iterator block with the async/await pattern.
This rule raises an issue when an async method throws any exception derived from ArgumentException and contains the\nawait keyword.
\npublic static async Task SkipLinesAsync(this TextReader reader, int linesToSkip) // Noncompliant\n{\n if (reader == null) { throw new ArgumentNullException(nameof(reader)); }\n if (linesToSkip < 0) { throw new ArgumentOutOfRangeException(nameof(linesToSkip)); }\n\n for (var i = 0; i < linesToSkip; ++i)\n {\n var line = await reader.ReadLineAsync().ConfigureAwait(false);\n if (line == null) { break; }\n }\n}\n\nvar task = SkipLinesAsync(null, -1); // No exception - captured in the task\nawait task; // ArgumentNullException thrown here\n\n\npublic static Task SkipLinesAsync(this TextReader reader, int linesToSkip)\n{\n if (reader == null) { throw new ArgumentNullException(nameof(reader)); }\n if (linesToSkip < 0) { throw new ArgumentOutOfRangeException(nameof(linesToSkip)); }\n\n return reader.SkipLinesInternalAsync(linesToSkip);\n}\n\nprivate static async Task SkipLinesInternalAsync(this TextReader reader, int linesToSkip)\n{\n for (var i = 0; i < linesToSkip; ++i)\n {\n var line = await reader.ReadLineAsync().ConfigureAwait(false);\n if (line == null) { break; }\n }\n}\n\nvar task = SkipLinesAsync(null, -1); // ArgumentNullException thrown here\nawait task;\n\nMaking blocking calls to async methods transforms code that was intended to be asynchronous into a blocking operation. Doing so can\ncause deadlocks and unexpected blocking of context threads.
According to the MSDN documentation:
\n\n\nThe root cause of this deadlock is due to the way
\nawaithandles contexts. By default, when an incompleteTaskis\n awaited, the current “context” is captured and used to resume the method when theTaskcompletes. This “context” is the current\nSynchronizationContextunless it’s null, in which case it’s the currentTaskScheduler. GUI and ASP.NET applications have a\nSynchronizationContextthat permits only one chunk of code to run at a time. When theawaitcompletes, it attempts to\n execute the remainder of theasyncmethod within the captured context. But that context already has a thread in it, which is\n (synchronously) waiting for theasyncmethod to complete. They’re each waiting for the other, causing a deadlock.
| To Do This … | \nInstead of This … | \nUse This | \n
|---|---|---|
| \n Retrieve the result of a background task \n | \n \n
| \n \n
| \n
| \n Wait for any task to complete \n | \n \n
| \n \n
| \n
| \n Retrieve the results of multiple tasks \n | \n \n
| \n \n
| \n
| \n Wait a period of time \n | \n \n
| \n \n
| \n
\npublic static class DeadlockDemo\n{\n private static async Task DelayAsync()\n {\n await Task.Delay(1000);\n }\n\n // This method causes a deadlock when called in a GUI or ASP.NET context.\n public static void Test()\n {\n // Start the delay.\n var delayTask = DelayAsync();\n // Wait for the delay to complete.\n delayTask.Wait(); // Noncompliant\n }\n}\n\n\npublic static class DeadlockDemo\n{\n private static async Task DelayAsync()\n {\n await Task.Delay(1000);\n }\n\n public static async Task TestAsync()\n {\n // Start the delay.\n var delayTask = DelayAsync();\n // Wait for the delay to complete.\n await delayTask;\n }\n}\n\nThread.Sleep is also ignored when it is used in a non-async method.Task.Run or Task.Factory.StartNew are ignored because they don’t suffer from this deadlock\n issuePrivate fields which are written but never read are a case of \"dead store\". Changing the value of such a field is useless and most probably\nindicates an error in the code.
\n\npublic class Rectangle\n{\n private readonly int length;\n private readonly int width; // Noncompliant: width is written but never read\n\n public Rectangle(int length, int width)\n {\n this.length = length;\n this.width = width;\n }\n\n public int Surface\n {\n get\n {\n return length * length;\n }\n }\n}\n\nRemove this field if it doesn’t need to be read, or fix the code to read it.
\n\npublic class Rectangle\n{\n private readonly int length;\n private readonly int width;\n\n public Rectangle(int length, int width)\n {\n this.length = length;\n this.width = width;\n }\n\n public int Surface\n {\n get\n {\n return length * width;\n }\n }\n}\n\nA cross-site request forgery (CSRF) attack occurs when a trusted user of a web application can be forced, by an attacker, to perform sensitive\nactions that he didn’t intend, such as updating his profile or sending a message, more generally anything that can change the state of the\napplication.
\nThe attacker can trick the user/victim to click on a link, corresponding to the privileged action, or to visit a malicious web site that embeds a\nhidden web request and as web browsers automatically include cookies, the actions can be authenticated and sensitive.
\nThere is a risk if you answered yes to any of those questions.
\nGET which are designed to be\n used only for information retrieval.\npublic void ConfigureServices(IServiceCollection services)\n{\n // ...\n services.AddControllersWithViews(options => options.Filters.Add(new IgnoreAntiforgeryTokenAttribute())); // Sensitive\n // ...\n}\n\n\n[HttpPost, IgnoreAntiforgeryToken] // Sensitive\npublic IActionResult ChangeEmail(ChangeEmailModel model) => View(\"~/Views/...\");\n\n
\npublic void ConfigureServices(IServiceCollection services)\n{\n // ...\n services.AddControllersWithViews(options => options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute()));\n // or\n services.AddControllersWithViews(options => options.Filters.Add(new ValidateAntiForgeryTokenAttribute()));\n // ...\n}\n\n\n[HttpPost]\n[AutoValidateAntiforgeryToken]\npublic IActionResult ChangeEmail(ChangeEmailModel model) => View(\"~/Views/...\");\n\n
Development tools and frameworks usually have options to make debugging easier for developers. Although these features are useful during\ndevelopment, they should never be enabled for applications deployed in production. Debug instructions or error messages can leak detailed information\nabout the system, like the application’s path or file names.
\nThere is a risk if you answered yes to any of those questions.
\nDo not enable debugging features on production servers.
\nThe .Net Core framework offers multiple features which help during debug.\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDeveloperExceptionPage and\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDatabaseErrorPage are two of them. Make sure that those features are disabled in\nproduction.
Use if (env.IsDevelopment()) to disable debug code.
This rule raises issues when the following .Net Core methods are called:\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDeveloperExceptionPage,\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDatabaseErrorPage.
\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.AspNetCore.Hosting;\n\nnamespace mvcApp\n{\n public class Startup2\n {\n public void Configure(IApplicationBuilder app, IHostingEnvironment env)\n {\n // Those calls are Sensitive because it seems that they will run in production\n app.UseDeveloperExceptionPage(); // Sensitive\n app.UseDatabaseErrorPage(); // Sensitive\n }\n }\n}\n\n\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.AspNetCore.Hosting;\n\nnamespace mvcApp\n{\n public class Startup2\n {\n public void Configure(IApplicationBuilder app, IHostingEnvironment env)\n {\n if (env.IsDevelopment())\n {\n // The following calls are ok because they are disabled in production\n app.UseDeveloperExceptionPage(); // Compliant\n app.UseDatabaseErrorPage(); // Compliant\n }\n }\n }\n}\n\nThis rule does not analyze configuration files. Make sure that debug mode is not enabled by default in those files.
\nThe switch\nstatement is a conditional statement that executes a sequence of instructions based on patterns matching the provided value.
\n\nswitch (temperatureInCelsius)\n{\n case < 35.0:\n Console.WriteLine(\"Hypothermia\");\n break;\n case >= 36.5 and <= 37.5:\n Console.WriteLine(\"Normal\");\n break;\n case > 37.5 and <= 40.0:\n Console.WriteLine(\"Fever or hyperthermia\");\n break;\n case > 40.0:\n Console.WriteLine(\"Hyperpyrexia\");\n break;\n}\n\nThe switch statement can optionally contain a default clause, executed when none of the case clauses are\nexecuted (or in presence of a goto default;).
\nswitch (gradeLetter)\n{\n case \"A+\":\n case \"A\":\n case \"A-\":\n Console.WriteLine(\"Excellent\");\n break;\n case \"B+\":\n case \"B\":\n Console.WriteLine(\"Very Good\");\n break;\n case \"B-\":\n case \"C+\":\n Console.WriteLine(\"Good\");\n break;\n case \"C\":\n Console.WriteLine(\"Pass\");\n break;\n case \"F\":\n Console.WriteLine(\"Fail\");\n break;\n default:\n Console.WriteLine(\"Invalid grade letter!\");\n break;\n}\n\nThe default clause can be defined for various reasons:
While C# allows the default clause to appear in any place within a switch statement, and while its position doesn’t alter\nits behavior, it is recommended to put the default clause either at the beginning or at the end of the switch statement.
That improves readability and helps the developer to quickly find the default behavior of a switch statement.
This rule raises an issue if the default clause is neither the first nor the last one of the switch statement.
\nswitch (param)\n{\n case 0:\n DoSomething();\n break;\n default: // Noncompliant: default clause should be the first or last one\n Error();\n break;\n case 1:\n DoSomethingElse();\n break;\n}\n\n\nswitch (param)\n{\n case 0:\n DoSomething();\n break;\n case 1:\n DoSomethingElse();\n break;\n default:\n Error();\n break;\n}\n\nThe DebuggerDisplayAttribute is used to determine how an object is displayed in the debugger window.
The DebuggerDisplayAttribute constructor takes a single mandatory argument: the string to be displayed in the value column for\ninstances of the type. Any text within curly braces is evaluated as the name of a field or property, or any complex expression containing method calls\nand operators.
Naming a non-existent member between curly braces will result in a CS0103 error in the debug window when debugging objects. Although there is no\nimpact on the production code, providing a wrong value can lead to difficulties when debugging the application.
\nThis rule raises an issue when text specified between curly braces refers to members that don’t exist in the current context.
\n\n[DebuggerDisplay(\"Name: {Name}\")] // Noncompliant - Name doesn't exist in this context\npublic class Person\n{\n public string FullName { get; private set; }\n}\n\n\n[DebuggerDisplay(\"Name: {FullName}\")]\npublic class Person\n{\n public string FullName { get; private set; }\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4545.json",
"content": "{\n \"title\": \"\\\"DebuggerDisplayAttribute\\\" strings should reference existing members\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4545\",\n \"sqKey\": \"S4545\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4581.html",
"content": "When the syntax new Guid() (i.e. parameterless instantiation) is used, it must be that one of three things is wanted:
Guid.Empty is clearer.Guid.NewGuid() should be used.This rule raises an issue when a parameterless instantiation of the Guid struct is found.
\npublic void Foo()\n{\n var g1 = new Guid(); // Noncompliant - what's the intent?\n Guid g2 = new(); // Noncompliant\n var g3 = default(Guid); // Noncompliant\n Guid g4 = default; // Noncompliant\n}\n\n\npublic void Foo(byte[] bytes)\n{\n var g1 = Guid.Empty;\n var g2 = Guid.NewGuid();\n var g3 = new Guid(bytes);\n}\n\n\n"
},
{
"path": "analyzers/rspec/cs/S4581.json",
"content": "{\n \"title\": \"\\\"new Guid()\\\" should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5 min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4581\",\n \"sqKey\": \"S4581\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/cs/S4583.html",
"content": "When calling the BeginInvoke method of a delegate,\nresources are allocated that are only freed up when EndInvoke is called. Failing to pair BeginInvoke with\nEndInvoke can lead to resource leaks and incomplete asynchronous calls.
This rule raises an issue in the following scenarios:
\nBeginInvoke method is called without any callback, and it is not paired with a call to EndInvoke in the same\n block.IAsyncResult does not contain a call to EndInvoke in the same block.BeginInvoke without callback:
\npublic delegate string AsyncMethodCaller();\n\npublic static void Main()\n{\n AsyncExample asyncExample = new AsyncExample();\n AsyncMethodCaller caller = new AsyncMethodCaller(asyncExample.MyMethod);\n\n // Initiate the asynchronous call.\n IAsyncResult result = caller.BeginInvoke(null, null); // Noncompliant: not paired with EndInvoke\n}\n\nBeginInvoke with callback:
\npublic delegate string AsyncMethodCaller();\n\npublic static void Main()\n{\n AsyncExample asyncExample = new AsyncExample();\n AsyncMethodCaller caller = new AsyncMethodCaller(asyncExample.MyMethod);\n\n IAsyncResult result = caller.BeginInvoke(\n new AsyncCallback((IAsyncResult ar) => {}),\n null); // Noncompliant: not paired with EndInvoke\n}\n\nBeginInvoke without callback:
\npublic delegate string AsyncMethodCaller();\n\npublic static void Main()\n{\n AsyncExample asyncExample = new AsyncExample();\n AsyncMethodCaller caller = new AsyncMethodCaller(asyncExample.MyMethod);\n\n IAsyncResult result = caller.BeginInvoke(null, null);\n\n string returnValue = caller.EndInvoke(result);\n}\n\nBeginInvoke with callback:
\npublic delegate string AsyncMethodCaller();\n\npublic static void Main()\n{\n AsyncExample asyncExample = new AsyncExample();\n AsyncMethodCaller caller = new AsyncMethodCaller(asyncExample.MyMethod);\n\n IAsyncResult result = caller.BeginInvoke(\n new AsyncCallback((IAsyncResult ar) =>\n {\n // Call EndInvoke to retrieve the results.\n string returnValue = caller.EndInvoke(ar);\n }), null);\n}\n\nReturning null from a non-async Task/Task<TResult> method will cause a\nNullReferenceException at runtime if the method is awaited. This problem can be avoided by returning Task.CompletedTask or Task.FromResult<TResult>(null)\nrespectively.
\npublic Task DoFooAsync()\n{\n return null; // Noncompliant: Causes a NullReferenceException if awaited.\n}\n\npublic async Task Main()\n{\n await DoFooAsync(); // NullReferenceException\n}\n\nInstead of null Task.CompletedTask or Task.FromResult<TResult>(null)\nshould be returned.
A Task returning method can be fixed like so:
\npublic Task DoFooAsync()\n{\n return null; // Noncompliant: Causes a NullReferenceException if awaited.\n}\n\n\npublic Task DoFooAsync()\n{\n return Task.CompletedTask; // Compliant: Method can be awaited.\n}\n\nA Task<TResult> returning method can be fixed like so:
\npublic Task<object> GetFooAsync()\n{\n return null; // Noncompliant: Causes a NullReferenceException if awaited.\n}\n\n\npublic Task<object> GetFooAsync()\n{\n return Task.FromResult<object>(null); // Compliant: Method can be awaited.\n}\n\nTask.CompletedTask PropertyTask.FromResult<TResult>(TResult)\n MethodIt is important to be careful when searching for characters within a substring. Let’s consider the following example:
\n\nif (str.SubString(startIndex).IndexOf(char1) == -1) // Noncompliant: a new string is going to be created by \"Substring\"\n{\n // ...\n}\n\nA new string object is created with every call to the Substring method. When chaining it with any of the\nfollowing methods, it creates a new object for one-time use only:
IndexOfIndexOfAnyLastIndexOfLastIndexOfAnyCreating a new object consumes significant system resources, especially CPU and memory.\nWhen using Substring repeatedly, such as in a loop, it can greatly impact the overall performance of the application or program.
To mitigate the creation of new objects while searching for characters within a substring, it is possible to use an overload of the mentioned\nmethods with a startIndex parameter:
\nif (str.IndexOf(char1, startIndex) == -1) // Compliant: no new instance of string is created\n{\n // ...\n}\n\nUsing these methods gives the same result while avoiding the creation of additional string objects.
String.Substring MethodString.IndexOf MethodString.IndexOfAny MethodString.LastIndexOf MethodString.LastIndexOfAny Method| Method | \nRuntime | \nStringSize | \nMean | \nStdDev | \nRatio | \nAllocated | \n
|---|---|---|---|---|---|---|
| \n SubstringThenIndexOf \n | \n \n .NET 7.0 \n | \n \n 10 \n | \n \n 11.234 ms \n | \n \n 0.1319 ms \n | \n \n 1.00 \n | \n \n 40000008 B \n | \n
| \n IndexOfOnly \n | \n \n .NET 7.0 \n | \n \n 10 \n | \n \n 2.477 ms \n | \n \n 0.0473 ms \n | \n \n 0.22 \n | \n \n 2 B \n | \n
| \n SubstringThenIndexOf \n | \n \n .NET Framework 4.6.2 \n | \n \n 10 \n | \n \n 8.634 ms \n | \n \n 0.4195 ms \n | \n \n 1.00 \n | \n \n 48141349 B \n | \n
| \n IndexOfOnly \n | \n \n .NET Framework 4.6.2 \n | \n \n 10 \n | \n \n 1.724 ms \n | \n \n 0.0346 ms \n | \n \n 0.19 \n | \n \n - \n | \n
| \n SubstringThenIndexOf \n | \n \n .NET 7.0 \n | \n \n 100 \n | \n \n 14.651 ms \n | \n \n 0.2977 ms \n | \n \n 1.00 \n | \n \n 176000008 B \n | \n
| \n IndexOfOnly \n | \n \n .NET 7.0 \n | \n \n 100 \n | \n \n 2.464 ms \n | \n \n 0.0501 ms \n | \n \n 0.17 \n | \n \n 2 B \n | \n
| \n SubstringThenIndexOf \n | \n \n .NET Framework 4.6.2 \n | \n \n 100 \n | \n \n 13.363 ms \n | \n \n 0.2044 ms \n | \n \n 1.00 \n | \n \n 176518761 B \n | \n
| \n IndexOfOnly \n | \n \n .NET Framework 4.6.2 \n | \n \n 100 \n | \n \n 1.689 ms \n | \n \n 0.0290 ms \n | \n \n 0.13 \n | \n \n - \n | \n
| \n SubstringThenIndexOf \n | \n \n .NET 7.0 \n | \n \n 1000 \n | \n \n 78.688 ms \n | \n \n 2.4727 ms \n | \n \n 1.00 \n | \n \n 1528000072 B \n | \n
| \n IndexOfOnly \n | \n \n .NET 7.0 \n | \n \n 1000 \n | \n \n 2.456 ms \n | \n \n 0.0397 ms \n | \n \n 0.03 \n | \n \n 2 B \n | \n
| \n SubstringThenIndexOf \n | \n \n .NET Framework 4.6.2 \n | \n \n 1000 \n | \n \n 75.994 ms \n | \n \n 1.2650 ms \n | \n \n 1.00 \n | \n \n 1532637240 B \n | \n
| \n IndexOfOnly \n | \n \n .NET Framework 4.6.2 \n | \n \n 1000 \n | \n \n 1.699 ms \n | \n \n 0.0216 ms \n | \n \n 0.02 \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate string theString;\nprivate int iteration = 1_000_000;\n\n[Params(10, 100, 1_000)]\npublic int StringSize { get; set; }\n\n[GlobalSetup]\npublic void Setup() =>\n theString = new string('a', StringSize);\n\n[Benchmark(Baseline = true)]\npublic void SubstringThenIndexOf()\n{\n for (var i = 0; i < iteration; i++)\n {\n _ = theString.Substring(StringSize / 4).IndexOf('a');\n }\n}\n\n[Benchmark]\npublic void IndexOfOnly()\n{\n for (var i = 0; i < iteration; i++)\n {\n _ = theString.IndexOf('a', StringSize / 4) - StringSize / 4;\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2965/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S4635.json", "content": "{\n \"title\": \"Start index should be used instead of calling Substring\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-4635\",\n \"sqKey\": \"S4635\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S4663.html", "content": "
Empty comments, as shown in the example, hurt readability and might indicate an oversight.
\n\n//\n\n/*\n*/\n\n///\n\n/**\n*/\n\n
Some meaningful text should be added to the comment, or the comment markers should be removed.
\n\n" }, { "path": "analyzers/rspec/cs/S4663.json", "content": "{\n \"title\": \"Comments should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4663\",\n \"sqKey\": \"S4663\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S4790.html", "content": "Cryptographic hash algorithms such as MD2, MD4, MD5, MD6, HAVAL-128,\nDSA (which uses SHA-1), RIPEMD, RIPEMD-128, RIPEMD-160and SHA-1 are no\nlonger considered secure, because it is possible to have collisions (little computational effort is enough to find two or more different\ninputs that produce the same hash).
Message authentication code (MAC) algorithms such as HMAC-MD5 or HMAC-SHA1 use weak hash functions as building blocks.\nAlthough they are not all proven to be weak, they are considered legacy algorithms and should be avoided.
The hashed value is used in a security context like:
\nThere is a risk if you answered yes to any of those questions.
\nSafer alternatives, such as SHA-256, SHA-512, SHA-3 are recommended, and for password hashing, it’s even\nbetter to use algorithms that do not compute too \"quickly\", like bcrypt, scrypt, argon2 or pbkdf2\nbecause it slows down brute force attacks.
\nvar hashProvider1 = new MD5CryptoServiceProvider(); // Sensitive\nvar hashProvider2 = (HashAlgorithm)CryptoConfig.CreateFromName(\"MD5\"); // Sensitive\nvar hashProvider3 = new SHA1Managed(); // Sensitive\nvar hashProvider4 = HashAlgorithm.Create(\"SHA1\"); // Sensitive\n\n
\nvar hashProvider1 = new SHA512Managed(); // Compliant\nvar hashProvider2 = (HashAlgorithm)CryptoConfig.CreateFromName(\"SHA512Managed\"); // Compliant\nvar hashProvider3 = HashAlgorithm.Create(\"SHA512Managed\"); // Compliant\n\n
This rule is deprecated, and will eventually be removed.
\nConfiguring loggers is security-sensitive. It has led in the past to the following vulnerabilities:
\nLogs are useful before, during and after a security incident.
\nLogs are also a target for attackers because they might contain sensitive information. Configuring loggers has an impact on the type of information\nlogged and how they are logged.
\nThis rule flags for review code that initiates loggers configuration. The goal is to guide security code reviews.
\nThere is a risk if you answered yes to any of those questions.
\nRemember that configuring loggers properly doesn’t make them bullet-proof. Here is a list of recommendations explaining on how to use your\nlogs:
\n.Net Core: configure programmatically
\n\nusing System;\nusing System.Collections;\nusing System.Collections.Generic;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.AspNetCore.Hosting;\nusing Microsoft.Extensions.Configuration;\nusing Microsoft.Extensions.DependencyInjection;\nusing Microsoft.Extensions.Logging;\nusing Microsoft.Extensions.Options;\nusing Microsoft.AspNetCore;\n\nnamespace MvcApp\n{\n public class ProgramLogging\n {\n public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>\n WebHost.CreateDefaultBuilder(args)\n .ConfigureLogging((hostingContext, logging) => // Sensitive\n {\n // ...\n })\n .UseStartup<StartupLogging>();\n }\n\n public class StartupLogging\n {\n public void ConfigureServices(IServiceCollection services)\n {\n services.AddLogging(logging => // Sensitive\n {\n // ...\n });\n }\n\n public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)\n {\n IConfiguration config = null;\n LogLevel level = LogLevel.Critical;\n Boolean includeScopes = false;\n Func<string,Microsoft.Extensions.Logging.LogLevel,bool> filter = null;\n Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings consoleSettings = null;\n Microsoft.Extensions.Logging.AzureAppServices.AzureAppServicesDiagnosticsSettings azureSettings = null;\n Microsoft.Extensions.Logging.EventLog.EventLogSettings eventLogSettings = null;\n\n // An issue will be raised for each call to an ILoggerFactory extension methods adding loggers.\n loggerFactory.AddAzureWebAppDiagnostics(); // Sensitive\n loggerFactory.AddAzureWebAppDiagnostics(azureSettings); // Sensitive\n loggerFactory.AddConsole(); // Sensitive\n loggerFactory.AddConsole(level); // Sensitive\n loggerFactory.AddConsole(level, includeScopes); // Sensitive\n loggerFactory.AddConsole(filter); // Sensitive\n loggerFactory.AddConsole(filter, includeScopes); // Sensitive\n loggerFactory.AddConsole(config); // Sensitive\n loggerFactory.AddConsole(consoleSettings); // Sensitive\n loggerFactory.AddDebug(); // Sensitive\n loggerFactory.AddDebug(level); // Sensitive\n loggerFactory.AddDebug(filter); // Sensitive\n loggerFactory.AddEventLog(); // Sensitive\n loggerFactory.AddEventLog(eventLogSettings); // Sensitive\n loggerFactory.AddEventLog(level); // Sensitive\n loggerFactory.AddEventSourceLogger(); // Sensitive\n\n IEnumerable<ILoggerProvider> providers = null;\n LoggerFilterOptions filterOptions1 = null;\n IOptionsMonitor<LoggerFilterOptions> filterOptions2 = null;\n\n LoggerFactory factory = new LoggerFactory(); // Sensitive\n new LoggerFactory(providers); // Sensitive\n new LoggerFactory(providers, filterOptions1); // Sensitive\n new LoggerFactory(providers, filterOptions2); // Sensitive\n }\n }\n}\n\nLog4Net
\n\nusing System;\nusing System.IO;\nusing System.Xml;\nusing log4net.Appender;\nusing log4net.Config;\nusing log4net.Repository;\n\nnamespace Logging\n{\n class Log4netLogging\n {\n void Foo(ILoggerRepository repository, XmlElement element, FileInfo configFile, Uri configUri, Stream configStream,\n IAppender appender, params IAppender[] appenders) {\n log4net.Config.XmlConfigurator.Configure(repository); // Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, element); // Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configFile); // Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configUri); // Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configStream); // Sensitive\n log4net.Config.XmlConfigurator.ConfigureAndWatch(repository, configFile); // Sensitive\n\n log4net.Config.DOMConfigurator.Configure(); // Sensitive\n log4net.Config.DOMConfigurator.Configure(repository); // Sensitive\n log4net.Config.DOMConfigurator.Configure(element); // Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, element); // Sensitive\n log4net.Config.DOMConfigurator.Configure(configFile); // Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, configFile); // Sensitive\n log4net.Config.DOMConfigurator.Configure(configStream); // Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, configStream); // Sensitive\n log4net.Config.DOMConfigurator.ConfigureAndWatch(configFile); // Sensitive\n log4net.Config.DOMConfigurator.ConfigureAndWatch(repository, configFile); // Sensitive\n\n log4net.Config.BasicConfigurator.Configure(); // Sensitive\n log4net.Config.BasicConfigurator.Configure(appender); // Sensitive\n log4net.Config.BasicConfigurator.Configure(appenders); // Sensitive\n log4net.Config.BasicConfigurator.Configure(repository); // Sensitive\n log4net.Config.BasicConfigurator.Configure(repository, appender); // Sensitive\n log4net.Config.BasicConfigurator.Configure(repository, appenders); // Sensitive\n }\n }\n}\n\nNLog: configure programmatically
\n\nnamespace Logging\n{\n class NLogLogging\n {\n void Foo(NLog.Config.LoggingConfiguration config) {\n NLog.LogManager.Configuration = config; // Sensitive, this changes the logging configuration.\n }\n }\n}\n\nSerilog
\n\nnamespace Logging\n{\n class SerilogLogging\n {\n void Foo() {\n new Serilog.LoggerConfiguration(); // Sensitive\n }\n }\n}\n\nThis vulnerability makes it possible that an encrypted communication is intercepted.
\nTransport Layer Security (TLS) provides secure communication between systems over the internet by encrypting the data sent between them.\nCertificate validation adds an extra layer of trust and security to this process to ensure that a system is indeed the one it claims to be.
\nWhen certificate validation is disabled, the client skips a critical security check. This creates an opportunity for attackers to pose as a trusted\nentity and intercept, manipulate, or steal the data being transmitted.
\nEstablishing trust in a secure way is a non-trivial task. When you disable certificate validation, you are removing a key mechanism designed to\nbuild this trust in internet communication, opening your system up to a number of potential threats.
\nIf a system does not validate certificates, it cannot confirm the identity of the other party involved in the communication. An attacker can\nexploit this by creating a fake server and masquerading as a legitimate one. For example, they might set up a server that looks like your bank’s\nserver, tricking your system into thinking it is communicating with the bank. This scenario, called identity spoofing, allows the attacker to collect\nany data your system sends to them, potentially leading to significant data breaches.
\nWhen TLS certificate validation is disabled, the integrity of the data you send and receive cannot be guaranteed. An attacker could modify the data\nin transit, and you would have no way of knowing. This could range from subtle manipulations of the data you receive to the injection of malicious\ncode or malware into your system. The consequences of such breaches of data integrity can be severe, depending on the nature of the data and the\nsystem.
\nIn the following example, the callback change impacts the entirety of HTTP requests made by the application.
\nThe certificate validation gets disabled by overriding ServerCertificateValidationCallback with an empty implementation. It is highly\nrecommended to use the original implementation.
\nusing System.Net;\nusing System.Net.Http;\n\npublic static void connect()\n{\n ServicePointManager.ServerCertificateValidationCallback +=\n\t (sender, certificate, chain, errors) => {\n\t return true; // Noncompliant\n };\n\n HttpClient httpClient = new HttpClient();\n HttpResponseMessage response = httpClient.GetAsync(\"https://example.com\").Result;\n}\n\nAddressing the vulnerability of disabled TLS certificate validation primarily involves re-enabling the default validation.
\nTo avoid running into problems with invalid certificates, consider the following sections.
\nIf possible, always use a certificate issued by a well-known, trusted CA for your server. Most programming environments come with a predefined list\nof trusted root CAs, and certificates issued by these authorities are validated automatically. This is the best practice, and it requires no\nadditional code or configuration.
\nIn some cases, you might need to work with a server using a self-signed certificate, or a certificate issued by a CA not included in your trusted\nroots. Rather than disabling certificate validation in your code, you can add the necessary certificates to your trust store.
\nValueTask<TResult> provides a value type that wraps a TResult.\nIt was introduced in .NET Core 2.0 to optimize\nmemory allocation when functions return their results synchronously.
Using ValueTask and ValueTask<TResult> in the following ways is discouraged as it could result in a race\ncondition:
await multiple times on a ValueTask/ValueTask<TResult>. The wrapped object may have been\n reused by another operation. This differs from Task/Task<TResult>, on which you can await multiple times and always\n get the same result.await concurrently on a ValueTask/ValueTask<TResult>. The underlying object is not thread\n safe. What’s more, it has the same effect as awaiting multiple times a ValueTask/ValueTask<TResult>. This again\n differs from Task/Task<TResult>, which support concurrent await..Result or .GetAwaiter().GetResult() without checking if the operation is completed.\n IValueTaskSource/IValueTaskSource<TResult> implementations are not required to block until the operation completes.\n On the other hand, Task/Task<TResult> blocks the call until the task completes.It is recommended to use ValueTask/ValueTask<TResult> either by calling await on the function\nreturning it, optionally calling ConfigureAwait(false) on it, or by calling .AsTask() on it.
This rule raises an issue when the following operations are performed on a ValueTask/ValueTask<TResult> instance\nunless it happens in a loop:
AsTask multiple times..Result or .GetAwaiter().GetResult() multiple times.Result or .GetAwaiter().GetResult() when the operation has not yet completed\nValueTask<int> vt = ComputeAsync();\nint result = await vt;\nresult = await vt; // Noncompliant, variable is awaited multiple times\n\nint value = ComputeAsync()).GetAwaiter().GetResult(); // Noncompliant, uses GetAwaiter().GetResult() when it's not known to be done\n\n
\nValueTask<int> vt = ComputeAsync();\nint result = await vt;\n\nint value = await ComputeAsync().AsTask();\n\n
Successful Zip Bomb attacks occur when an application expands untrusted archive files without controlling the size of the expanded data, which can\nlead to denial of service. A Zip bomb is usually a malicious archive file of a few kilobytes of compressed data but turned into gigabytes of\nuncompressed data. To achieve this extreme compression ratio, attackers will\ncompress irrelevant data (eg: a long string of repeated bytes).
\nArchives to expand are untrusted and:
\nThere is a risk if you answered yes to any of those questions.
\n\nusing var zipToOpen = new FileStream(@\"ZipBomb.zip\", FileMode.Open);\nusing var archive = new ZipArchive(zipToOpen, ZipArchiveMode.Read);\nforeach (ZipArchiveEntry entry in archive.Entries)\n{\n entry.ExtractToFile(\"./output_onlyfortesting.txt\", true); // Sensitive\n}\n\n\nint THRESHOLD_ENTRIES = 10000;\nint THRESHOLD_SIZE = 1000000000; // 1 GB\ndouble THRESHOLD_RATIO = 10;\nint totalSizeArchive = 0;\nint totalEntryArchive = 0;\n\nusing var zipToOpen = new FileStream(@\"ZipBomb.zip\", FileMode.Open);\nusing var archive = new ZipArchive(zipToOpen, ZipArchiveMode.Read);\nforeach (ZipArchiveEntry entry in archive.Entries)\n{\n totalEntryArchive ++;\n\n using (Stream st = entry.Open())\n {\n byte[] buffer = new byte[1024];\n int totalSizeEntry = 0;\n int numBytesRead = 0;\n\n do\n {\n numBytesRead = st.Read(buffer, 0, 1024);\n totalSizeEntry += numBytesRead;\n totalSizeArchive += numBytesRead;\n double compressionRatio = totalSizeEntry / entry.CompressedLength;\n\n if(compressionRatio > THRESHOLD_RATIO) {\n // ratio between compressed and uncompressed data is highly suspicious, looks like a Zip Bomb Attack\n break;\n }\n }\n while (numBytesRead > 0);\n }\n\n if(totalSizeArchive > THRESHOLD_SIZE) {\n // the uncompressed data size is too much for the application resource capacity\n break;\n }\n\n if(totalEntryArchive > THRESHOLD_ENTRIES) {\n // too much entries in this archive, can lead to inodes exhaustion of the system\n break;\n }\n}\n\nHaving a permissive Cross-Origin Resource Sharing policy is security-sensitive. It has led in the past to the following vulnerabilities:
\nSame origin policy in browsers prevents, by default and for\nsecurity-reasons, a javascript frontend to perform a cross-origin HTTP request to a resource that has a different origin (domain, protocol, or port)\nfrom its own. The requested target can append additional HTTP headers in response, called
Access-Control-Allow-Origin: untrustedwebsite.com.Access-Control-Allow-Origin: *origin header.There is a risk if you answered yes to any of those questions.
\nAccess-Control-Allow-Origin header should be set only for a trusted origin and for specific resources.Access-Control-Allow-Origin header. Prefer whitelisting domains over blacklisting or\n allowing any domain (do not use * wildcard nor blindly return the Origin header content without any checks).ASP.NET Core MVC:
\n\n[HttpGet]\npublic string Get()\n{\n Response.Headers.Add(\"Access-Control-Allow-Origin\", \"*\"); // Sensitive\n Response.Headers.Add(HeaderNames.AccessControlAllowOrigin, \"*\"); // Sensitive\n}\n\n\npublic void ConfigureServices(IServiceCollection services)\n{\n services.AddCors(options =>\n {\n options.AddDefaultPolicy(builder =>\n {\n builder.WithOrigins(\"*\"); // Sensitive\n });\n\n options.AddPolicy(name: \"EnableAllPolicy\", builder =>\n {\n builder.WithOrigins(\"*\"); // Sensitive\n });\n\n options.AddPolicy(name: \"OtherPolicy\", builder =>\n {\n builder.AllowAnyOrigin(); // Sensitive\n });\n });\n\n services.AddControllers();\n}\n\nASP.NET MVC:
\n\npublic class HomeController : ApiController\n{\n public HttpResponseMessage Get()\n {\n var response = HttpContext.Current.Response;\n\n response.Headers.Add(\"Access-Control-Allow-Origin\", \"*\"); // Sensitive\n response.Headers.Add(HeaderNames.AccessControlAllowOrigin, \"*\"); // Sensitive\n response.AppendHeader(HeaderNames.AccessControlAllowOrigin, \"*\"); // Sensitive\n }\n}\n\n\n[EnableCors(origins: \"*\", headers: \"*\", methods: \"GET\")] // Sensitive\npublic HttpResponseMessage Get() => new HttpResponseMessage()\n{\n Content = new StringContent(\"content\")\n};\n\nUser-controlled origin:
\n\nString origin = Request.Headers[\"Origin\"];\nResponse.Headers.Add(\"Access-Control-Allow-Origin\", origin); // Sensitive\n\n
ASP.NET Core MVC:
\n\n[HttpGet]\npublic string Get()\n{\n Response.Headers.Add(\"Access-Control-Allow-Origin\", \"https://trustedwebsite.com\"); // Safe\n Response.Headers.Add(HeaderNames.AccessControlAllowOrigin, \"https://trustedwebsite.com\"); // Safe\n}\n\n\npublic void ConfigureServices(IServiceCollection services)\n{\n services.AddCors(options =>\n {\n options.AddDefaultPolicy(builder =>\n {\n builder.WithOrigins(\"https://trustedwebsite.com\", \"https://anothertrustedwebsite.com\"); // Safe\n });\n\n options.AddPolicy(name: \"EnableAllPolicy\", builder =>\n {\n builder.WithOrigins(\"https://trustedwebsite.com\"); // Safe\n });\n });\n\n services.AddControllers();\n}\n\nASP.Net MVC:
\n\npublic class HomeController : ApiController\n{\n public HttpResponseMessage Get()\n {\n var response = HttpContext.Current.Response;\n\n response.Headers.Add(\"Access-Control-Allow-Origin\", \"https://trustedwebsite.com\");\n response.Headers.Add(HeaderNames.AccessControlAllowOrigin, \"https://trustedwebsite.com\");\n response.AppendHeader(HeaderNames.AccessControlAllowOrigin, \"https://trustedwebsite.com\");\n }\n}\n\n\n[EnableCors(origins: \"https://trustedwebsite.com\", headers: \"*\", methods: \"GET\")]\npublic HttpResponseMessage Get() => new HttpResponseMessage()\n{\n Content = new StringContent(\"content\")\n};\n\nUser-controlled origin validated with an allow-list:
\n\nString origin = Request.Headers[\"Origin\"];\n\nif (trustedOrigins.Contains(origin))\n{\n Response.Headers.Add(\"Access-Control-Allow-Origin\", origin);\n}\n\nClear-text protocols such as ftp, telnet, or http lack encryption of transported data, as well as the\ncapability to build an authenticated connection. It means that an attacker able to sniff traffic from the network can read, modify, or corrupt the\ntransported content. These protocols are not secure as they expose applications to an extensive range of risks:
Even in the context of isolated networks like offline environments or segmented cloud environments, the insider threat exists. Thus, attacks\ninvolving communications being sniffed or tampered with can still happen.
\nFor example, attackers could successfully compromise prior security layers by:
\nIn such cases, encrypting communications would decrease the chances of attackers to successfully leak data or steal credentials from other network\ncomponents. By layering various security practices (segmentation and encryption, for example), the application will follow the\ndefense-in-depth principle.
\nNote that using the http protocol is being deprecated by
In the past, it has led to the following vulnerabilities:
\nThere is a risk if you answered yes to any of those questions.
\nssh as an alternative to telnet.sftp, scp, or ftps instead of ftp.https instead of http.SMTP over SSL/TLS or SMTP with STARTTLS instead of clear-text SMTP.It is recommended to secure all transport channels, even on local networks, as it can take a single non-secure connection to compromise an entire\napplication or system.
\n\nvar urlHttp = \"http://example.com\"; // Noncompliant\nvar urlFtp = \"ftp://anonymous@example.com\"; // Noncompliant\nvar urlTelnet = \"telnet://anonymous@example.com\"; // Noncompliant\n\n
\nusing var smtp = new SmtpClient(\"host\", 25); // Noncompliant, EnableSsl is not set\nusing var telnet = new MyTelnet.Client(\"host\", port); // Noncompliant, rule raises Security Hotspot on any member containing \"Telnet\"\n\n
\nvar urlHttps = \"https://example.com\";\nvar urlSftp = \"sftp://anonymous@example.com\";\nvar urlSsh = \"ssh://anonymous@example.com\";\n\n
\nusing var smtp = new SmtpClient(\"host\", 25) { EnableSsl = true };\nusing var ssh = new MySsh.Client(\"host\", port);\n\nNo issue is reported for the following cases because they are not considered sensitive:
\nlocalhost.The improper storage of passwords poses a significant security risk to software applications. This vulnerability arises when passwords are stored\nin plaintext or with a fast hashing algorithm. To exploit this vulnerability, an attacker typically requires access to the stored passwords.
\nAttackers who would get access to the stored passwords could reuse them without further attacks or with little additional effort.\n
\n Obtaining the plaintext passwords, they could then gain unauthorized access to user accounts, potentially leading to various malicious\n activities.
Plaintext or weakly hashed password storage poses a significant security risk to software applications.
\nWhen passwords are stored in plaintext or with weak hashing algorithms, an attacker who gains access to the password database can easily retrieve\nand use the passwords to gain unauthorized access to user accounts. This can lead to various malicious activities, such as unauthorized data access,\nidentity theft, or even financial fraud.
\nMany users tend to reuse passwords across multiple platforms. If an attacker obtains plaintext or weakly hashed passwords, they can potentially use\nthese credentials to gain unauthorized access to other accounts held by the same user. This can have far-reaching consequences, as sensitive personal\ninformation or critical systems may be compromised.
\nMany industries and jurisdictions have specific regulations and standards to protect user data and ensure its confidentiality. Storing passwords in\nplaintext or with weak hashing algorithms can lead to non-compliance with these regulations, potentially resulting in legal consequences, financial\npenalties, and damage to the reputation of the software application and its developers.
\nUsing Microsoft.AspNetCore.Cryptography.KeyDerivation:
\nusing Microsoft.AspNetCore.Cryptography.KeyDerivation;\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\n\nstring hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(\n password: password!,\n salt: salt,\n prf: KeyDerivationPrf.HMACSHA256,\n iterationCount: 1, // Noncompliant\n numBytesRequested: 256 / 8));\n\n
Using System.Security.Cryptography:
\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\nRfc2898DeriveBytes kdf = new Rfc2898DeriveBytes(password, 128/8); // Noncompliant\nstring hashed = Convert.ToBase64String(kdf.GetBytes(256 / 8));\n\n
Using Microsoft.AspNetCore.Identity:
\nusing Microsoft.AspNetCore.Identity;\nusing Microsoft.Extensions.Options;\n\nstring password = Request.Query[\"password\"];\nIOptions<PasswordHasherOptions> options = Options.Create(new PasswordHasherOptions() {\n IterationCount = 1 // Noncompliant\n});\nPasswordHasher<User> hasher = new PasswordHasher<User>(options);\nstring hash = hasher.HashPassword(new User(\"test\"), password);\n\nUsing Microsoft.AspNetCore.Cryptography.KeyDerivation:
\nusing Microsoft.AspNetCore.Cryptography.KeyDerivation;\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\n\nstring hashed = Convert.ToBase64String(KeyDerivation.Pbkdf2(\n password: password!,\n salt: salt,\n prf: KeyDerivationPrf.HMACSHA256,\n iterationCount: 100_000,\n numBytesRequested: 256 / 8));\n\n
Using System.Security.Cryptography
\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\nRfc2898DeriveBytes kdf = new Rfc2898DeriveBytes(password, salt, 100_000, HashAlgorithmName.SHA256);\nstring hashed = Convert.ToBase64String(kdf.GetBytes(256 / 8));\n\n
Using Microsoft.AspNetCore.Identity:
\nusing Microsoft.AspNetCore.Identity;\nusing Microsoft.Extensions.Options;\n\nstring password = Request.Query[\"password\"];\nPasswordHasher<User> hasher = new PasswordHasher<User>();\nstring hash = hasher.HashPassword(new User(\"test\"), password);\n\n
If PBKDF2 must be used, be aware that default values might not be considered secure.\n
\n Depending on the algorithm used, the number of iterations should be adjusted to ensure that the derived key is secure. The following are the\n recommended number of iterations for PBKDF2:
Note that PBKDF2-HMAC-SHA256 is recommended by NIST.\n
\n Iterations are also called \"rounds\" depending on the library used.
When recommended cost factors are too high in the context of the application or if the performance cost is unacceptable, a cost factor reduction\nmight be considered. In that case, it should not be chosen under 100,000.
\nIn a defense-in-depth security approach, peppering can also be used. This is a security technique where an external secret value\nis added to a password before it is hashed.\n
\n This makes it more difficult for an attacker to crack the hashed passwords, as they would need to know the secret value to generate the correct\n hash.\n
\n Learn more here.
\nusing System.Security.Cryptography;\n\nRNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();\nbyte[] salt = new byte[32];\nrngCsp.GetBytes(salt);\nRfc2898DeriveBytes kdf = new Rfc2898DeriveBytes(password, salt, 100, HashAlgorithmName.SHA256); // Noncompliant\nstring hashed = Convert.ToBase64String(kdf.GetBytes(256 / 8));\n\n
Using using Microsoft.AspNet.Identity:
\nusing Microsoft.AspNet.Identity;\n\nstring password = \"NotSoSecure\";\nPasswordHasher hasher = new PasswordHasher();\nstring hash = hasher.HashPassword(password); // Noncompliant\n\n
\nusing System.Security.Cryptography;\n\nRNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();\nbyte[] salt = new byte[32];\nrngCsp.GetBytes(salt);\nRfc2898DeriveBytes kdf = new Rfc2898DeriveBytes(password, salt, 100_000, HashAlgorithmName.SHA256); // Compliant\nstring hashed = Convert.ToBase64String(kdf.GetBytes(256 / 8));\n\n
If PBKDF2 must be used, be aware that default values might not be considered secure.\n
\n Depending on the algorithm used, the number of iterations should be adjusted to ensure that the derived key is secure. The following are the\n recommended number of iterations for PBKDF2:
Note that PBKDF2-HMAC-SHA256 is recommended by NIST.\n
\n Iterations are also called \"rounds\" depending on the library used.
When recommended cost factors are too high in the context of the application or if the performance cost is unacceptable, a cost factor reduction\nmight be considered. In that case, it should not be chosen under 100,000.
\nIn a defense-in-depth security approach, peppering can also be used. This is a security technique where an external secret value\nis added to a password before it is hashed.\n
\n This makes it more difficult for an attacker to crack the hashed passwords, as they would need to know the secret value to generate the correct\n hash.\n
\n Learn more here.
Using SCrypt:
\n\nusing Org.BouncyCastle.Crypto.Generators;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8); // divide by 8 to convert bits to bytes\n\nstring hashed = Convert.ToBase64String(SCrypt.Generate(Encoding.Unicode.GetBytes(password), salt, 4, 2, 1, 32)); // Noncompliant\n\n
Using BCrypt:
\n\nusing Org.BouncyCastle.Crypto.Generators;\nusing Org.BouncyCastle.Crypto.Parameters;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\n\nstring hashed = OpenBsdBCrypt.Generate(password.ToCharArray(), salt, 4); // Noncompliant\n\n
Using PBKDF2:
\n\nusing Org.BouncyCastle.Crypto.Generators;\nusing Org.BouncyCastle.Crypto.Parameters;\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\nPkcs5S2ParametersGenerator gen = new Pkcs5S2ParametersGenerator();\ngen.Init(Encoding.Unicode.GetBytes(password), salt, 100); // Noncompliant\nKeyParameter keyParam = (KeyParameter) gen.GenerateDerivedMacParameters(256);\nstring hashed = Convert.ToBase64String(keyParam.GetKey());\n\n
Using SCrypt:
\n\nusing Org.BouncyCastle.Crypto.Generators;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8); // divide by 8 to convert bits to bytes\n\nstring hashed = Convert.ToBase64String(SCrypt.Generate(Encoding.Unicode.GetBytes(password), salt, 1<<12, 8, 1, 32)); // Noncompliant\n\n
Using BCrypt:
\n\nusing Org.BouncyCastle.Crypto.Generators;\nusing Org.BouncyCastle.Crypto.Parameters;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\n\nstring hashed = OpenBsdBCrypt.Generate(password.ToCharArray(), salt, 14); // Noncompliant\n\n
Using PBKDF2:
\n\nusing Org.BouncyCastle.Crypto.Generators;\nusing Org.BouncyCastle.Crypto.Parameters;\nusing System.Security.Cryptography;\n\nstring password = Request.Query[\"password\"];\nbyte[] salt = RandomNumberGenerator.GetBytes(128 / 8);\nPkcs5S2ParametersGenerator gen = new Pkcs5S2ParametersGenerator();\ngen.Init(Encoding.Unicode.GetBytes(password), salt, 100_000); // Noncompliant\nKeyParameter keyParam = (KeyParameter) gen.GenerateDerivedMacParameters(256);\nstring hashed = Convert.ToBase64String(keyParam.GetKey());\n\n
When bcrypt’s hashing function is used, it is important to select a round count that is high enough to make the function slow enough to prevent\nbrute force: More than 12 rounds.
\nFor bcrypt’s key derivation function, the number of rounds should likewise be high enough to make the function slow enough to prevent brute force:\nMore than 4096 rounds (2^12).\n
\n This number is not the same coefficient as the first one because it uses a different algorithm.
If scrypt must be used, the default values of scrypt are considered secure.
\nLike Argon2id, scrypt has three different parameters that can be configured. N is the CPU/memory cost parameter and must be a power of two. r is\nthe block size and p is the parallelization factor.
\nAll three parameters affect the memory and CPU usage of the algorithm. Higher values of N, r and p result in safer hashes, but come at the cost of\nhigher resource usage.
\nFor scrypt, OWASP recommends to have a hash length of at least 64 bytes, and to set N, p and r to the values of one of the following rows:
\n| N (cost parameter) | \np (parallelization factor) | \nr (block size) | \n
|---|---|---|
| \n 217 ( | \n \n 1 \n | \n \n 8 \n | \n
| \n 216 ( | \n \n 2 \n | \n \n 8 \n | \n
| \n 215 ( | \n \n 3 \n | \n \n 8 \n | \n
| \n 214 ( | \n \n 5 \n | \n \n 8 \n | \n
| \n 213 ( | \n \n 10 \n | \n \n 8 \n | \n
Every row provides the same level of defense. They only differ in the amount of CPU and RAM used: the top row has low CPU usage and high memory\nusage, while the bottom row has high CPU usage and low memory usage.
\nIf PBKDF2 must be used, be aware that default values might not be considered secure.\n
\n Depending on the algorithm used, the number of iterations should be adjusted to ensure that the derived key is secure. The following are the\n recommended number of iterations for PBKDF2:
Note that PBKDF2-HMAC-SHA256 is recommended by NIST.\n
\n Iterations are also called \"rounds\" depending on the library used.
When recommended cost factors are too high in the context of the application or if the performance cost is unacceptable, a cost factor reduction\nmight be considered. In that case, it should not be chosen under 100,000.
\nIn a defense-in-depth security approach, peppering can also be used. This is a security technique where an external secret value\nis added to a password before it is hashed.\n
\n This makes it more difficult for an attacker to crack the hashed passwords, as they would need to know the secret value to generate the correct\n hash.\n
\n Learn more here.
Operating systems have global directories where any user has write access. Those folders are mostly used as temporary storage areas like\n/tmp in Linux based systems. An application manipulating files from these folders is exposed to race conditions on filenames: a malicious\nuser can try to create a file with a predictable name before the application does. A successful attack can result in other files being accessed,\nmodified, corrupted or deleted. This risk is even higher if the application runs with elevated permissions.
In the past, it has led to the following vulnerabilities:
\nThis rule raises an issue whenever it detects a hard-coded path to a publicly writable directory like /tmp (see examples bellow). It\nalso detects access to environment variables that point to publicly writable directories, e.g., TMP, TMPDIR and\nTEMP.
/tmp/var/tmp/usr/tmp/dev/shm/dev/mqueue/run/lock/var/run/lock/Library/Caches/Users/Shared/private/tmp/private/var/tmp\\Windows\\Temp\\Temp\\TMP%USERPROFILE%\\AppData\\Local\\TempThere is a risk if you answered yes to any of those questions.
\nOut of the box, .NET is missing secure-by-design APIs to create temporary files. To overcome this, one of the following options can be used:
\n\nusing var writer = new StreamWriter(\"/tmp/f\"); // Sensitive\n\n
\nvar tmp = Environment.GetEnvironmentVariable(\"TMP\"); // Sensitive\n\n
\nvar randomPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());\n\n// Creates a new file with write, non inheritable permissions which is deleted on close.\nusing var fileStream = new FileStream(randomPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.DeleteOnClose);\nusing var writer = new StreamWriter(fileStream);\n\n
Temporary files are considered insecurely created when the file existence check is performed separately from the actual file creation. Such a\nsituation can occur when creating temporary files using normal file handling functions or when using dedicated temporary file handling functions that\nare not atomic.
\nCreating temporary files in a non-atomic way introduces race condition issues in the application’s behavior. Indeed, a third party can create a\ngiven file between when the application chooses its name and when it creates it.
\nIn such a situation, the application might use a temporary file that it does not entirely control. In particular, this file’s permissions might be\ndifferent than expected. This can lead to trust boundary issues.
\nAttackers with control over a temporary file used by a vulnerable application will be able to modify it in a way that will affect the application’s\nlogic. By changing this file’s Access Control List or other operating system-level properties, they could prevent the file from being deleted or\nemptied. They may also alter the file’s content before or while the application uses it.
\nDepending on why and how the affected temporary files are used, the exploitation of a race condition in an application can have various\nconsequences. They can range from sensitive information disclosure to more serious application or hosting infrastructure compromise.
\nBecause attackers can control the permissions set on temporary files and prevent their removal, they can read what the application stores in them.\nThis might be especially critical if this information is sensitive.
\nFor example, an application might use temporary files to store users' session-related information. In such a case, attackers controlling those\nfiles can access session-stored information. This might allow them to take over authenticated users' identities and entitlements.
\nAn application might use temporary files to store technical data for further reuse or as a communication channel between multiple components. In\nthat case, it might consider those files part of the trust boundaries and use their content without additional security validation or sanitation. In\nsuch a case, an attacker controlling the file content might use it as an attack vector for further compromise.
\nFor example, an application might store serialized data in temporary files for later use. In such a case, attackers controlling those files'\ncontent can change it in a way that will lead to an insecure deserialization exploitation. It might allow them to execute arbitrary code on the\napplication hosting server and take it over.
\nThe following code example is vulnerable to a race condition attack because it creates a temporary file using an unsafe API function.
\n\nusing System.IO;\n\npublic void Example()\n{\n var tempPath = Path.GetTempFileName(); // Noncompliant\n\n using (var writer = new StreamWriter(tempPath))\n {\n writer.WriteLine(\"content\");\n }\n}\n\n\nusing System.IO;\n\npublic void Example()\n{\n var randomPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());\n\n using (var fileStream = new FileStream(randomPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.DeleteOnClose))\n using (var writer = new StreamWriter(fileStream))\n {\n writer.WriteLine(\"content\");\n }\n}\n\nApplications should create temporary files so that no third party can read or modify their content. It requires that the files' name, location, and\npermissions are carefully chosen and set. This can be achieved in multiple ways depending on the applications' technology stacks.
\nTemporary files can be created using unsafe functions and API as long as strong security controls are applied. Non-temporary file-handling\nfunctions and APIs can also be used for that purpose.
\nIn general, applications should ensure that attackers can not create a file before them. This turns into the following requirements when creating\nthe files:
\nMoreover, when possible, it is recommended that applications destroy temporary files after they have finished using them.
\nHere the example compliant code uses the Path.GetTempPath and Path.GetRandomFileName functions to generate a unique\nrandom file name. The file is then open with the FileMode.CreateNew option that will ensure the creation fails if the file already\nexists. The FileShare.None option will additionally prevent the file from being opened again by any process. To finish, this code ensures\nthe file will get destroyed once the application has finished using it with the FileOptions.DeleteOnClose option.
This vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nFor AES, the weakest mode is ECB (Electronic Codebook). Repeated blocks of data are encrypted to the same value, making them easy to identify and\nreducing the difficulty of recovering the original cleartext.
\nUnauthenticated modes such as CBC (Cipher Block Chaining) may be used but are prone to attacks that manipulate the ciphertext. They must be used\nwith caution.
\nFor RSA, the weakest algorithms are either using it without padding or using the PKCS1v1.5 padding scheme.
\nThe cleartext of an encrypted message might be recoverable. Additionally, it might be possible to modify the cleartext of an encrypted message.
\nBelow are some real-world scenarios that illustrate possible impacts of an attacker exploiting the vulnerability.
\nThe encrypted message might contain data that is considered sensitive and should not be known to third parties.
\nBy using a weak algorithm the likelihood that an attacker might be able to recover the cleartext drastically increases.
\nBy modifying the cleartext of the encrypted message it might be possible for an attacker to trigger other vulnerabilities in the code. Encrypted\nvalues are often considered trusted, since under normal circumstances it would not be possible for a third party to modify them.
\nExample with a symmetric cipher, AES:
\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n AesManaged aes = new AesManaged\n {\n keysize = 128,\n blocksize = 128,\n mode = ciphermode.ecb, // Noncompliant\n padding = paddingmode.pkcs7\n };\n}\n\nNote that Microsoft has marked derived cryptographic types like AesManaged as no longer recommended for use.
Example with an asymmetric cipher, RSA:
\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n RSACryptoServiceProvider RsaCsp = new RSACryptoServiceProvider();\n byte[] encryptedData = RsaCsp.Encrypt(dataToEncrypt, false); // Noncompliant\n}\n\nFor the AES symmetric cipher, use the GCM mode:
\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n AesGcm aes = AesGcm(key);\n}\n\nFor the RSA asymmetric cipher, use the Optimal Asymmetric Encryption Padding (OAEP):
\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n RSACryptoServiceProvider RsaCsp = new RSACryptoServiceProvider();\n byte[] encryptedData = RsaCsp.Encrypt(dataToEncrypt, true);\n}\n\nAs a rule of thumb, use the cryptographic algorithms and mechanisms that are considered strong by the cryptographic community.
\nAppropriate choices are currently the following.
\nThe best-known authenticated encryption mode for AES is Galois/Counter mode (GCM).
\nGCM mode combines encryption with authentication and integrity checks using a cryptographic hash function and provides both confidentiality and\nauthenticity of data.
\nOther similar modes are:
\nCounter with CBC-MACCipher Block Chaining with Message Authentication CodeEncrypt-and-AuthenticateInteger Authenticated Parallelizable ModeOffset Codebook ModeIt is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly\ninstead.
\nThe Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of\nRSA.
\nThis vulnerability makes it possible that the cleartext of the encrypted message might be recoverable without prior knowledge of the key.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communication in various domains. They are used for\nseveral important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nThe cleartext of an encrypted message might be recoverable. Additionally, it might be possible to modify the cleartext of an encrypted message.
\nBelow are some real-world scenarios that illustrate some impacts of an attacker exploiting the vulnerability.
\nThe encrypted message might contain data that is considered sensitive and should not be known to third parties.
\nBy using a weak algorithm the likelihood that an attacker might be able to recover the cleartext drastically increases.
\nBy modifying the cleartext of the encrypted message it might be possible for an attacker to trigger other vulnerabilities in the code. Encrypted\nvalues are often considered trusted, since under normal circumstances it would not be possible for a third party to modify them.
\nThe following code contains examples of algorithms that are not considered highly resistant to cryptanalysis and thus should be avoided.
\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n var simpleDES = new DESCryptoServiceProvider(); // Noncompliant\n}\n\n\nusing System.Security.Cryptography;\n\npublic void encrypt()\n{\n using (Aes aes = Aes.Create())\n {\n // ...\n }\n}\n\nIt is highly recommended to use an algorithm that is currently considered secure by the cryptographic community. A common choice for such an\nalgorithm is the Advanced Encryption Standard (AES).
\nFor block ciphers, it is not recommended to use algorithms with a block size that is smaller than 128 bits.
\nThe following code contains examples of algorithms that are not considered highly resistant to cryptanalysis and thus should be avoided.
\n\nusing Org.BouncyCastle.Crypto.Engines;\nusing Org.BouncyCastle.Crypto.Parameters;\n\npublic void encrypt()\n{\n AesFastEngine aesFast = new AesFastEngine(); // Noncompliant\n}\n\n\nusing Org.BouncyCastle.Crypto.Engines;\nusing Org.BouncyCastle.Crypto.Parameters;\n\npublic void encrypt()\n{\n var AES = new AESEngine();\n}\n\nIt is highly recommended to use an algorithm that is currently considered secure by the cryptographic community. A common choice for such an\nalgorithm is the Advanced Encryption Standard (AES).
\nFor block ciphers, it is not recommended to use algorithms with a block size that is smaller than 128 bits.
\nThis vulnerability allows forging of JSON Web Tokens to impersonate other users.
\nJSON Web Tokens (JWTs), a popular method of securely transmitting information between parties as a JSON object, can become a significant security\nrisk when they are not properly signed with a robust cipher algorithm, left unsigned altogether, or if the signature is not verified. This\nvulnerability class allows malicious actors to craft fraudulent tokens, effectively impersonating user identities. In essence, the integrity of a JWT\nhinges on the strength and presence of its signature.
\nWhen a JSON Web Token is not appropriately signed with a strong cipher algorithm or if the signature is not verified, it becomes a significant\nthreat to data security and the privacy of user identities.
\nJWTs are commonly used to represent user authorization claims. They contain information about the user’s identity, user roles, and access rights.\nWhen these tokens are not securely signed, it allows an attacker to forge them. In essence, a weak or missing signature gives an attacker the power to\ncraft a token that could impersonate any user. For instance, they could create a token for an administrator account, gaining access to high-level\npermissions and sensitive data.
\nWhen a JWT is not securely signed, it can be tampered with by an attacker, and the integrity of the data it carries cannot be trusted. An attacker\ncan manipulate the content of the token and grant themselves permissions they should not have, leading to unauthorized data access.
\nThe following code contains an example of JWT decoding without verification of the signature.
\n\nusing JWT;\n\npublic static void decode(IJwtDecoder decoder)\n{\n decoder.Decode(token, secret, verify: false); // Noncompliant\n}\n\n\nusing JWT;\n\npublic static void decode()\n{\n var jwt = new JwtBuilder()\n .WithSecret(secret)\n .Decode(token); // Noncompliant\n}\n\n\nusing JWT;\n\npublic static void decode(IJwtDecoder decoder)\n{\n decoder.Decode(token, secret, verify: true);\n}\n\nWhen using JwtBuilder, make sure to call MustVerifySignature().
\nusing JWT;\n\npublic static void decode()\n{\n var jwt = new JwtBuilder()\n .WithSecret(secret)\n .MustVerifySignature()\n .Decode(token);\n}\n\nResolving a vulnerability concerning the validation of JWT token signatures is mainly about incorporating a critical step into your process:\nvalidating the signature every time a token is decoded. Just having a signed token using a secure algorithm is not enough. If you are not validating\nsignatures, they are not serving their purpose.
\nEvery time your application receives a JWT, it needs to decode the token to extract the information contained within. It is during this decoding\nprocess that the signature of the JWT should also be checked.
\nTo resolve the issue, follow these instructions:
\nBy following these practices, you can ensure the security of your application’s JWT handling process, making it resistant to attacks that rely on\ntampering with tokens. Validation of the signature needs to be an integral and non-negotiable part of your token handling process.
\nEnsure that your secret keys are stored securely. They should not be hard-coded into your application code or checked into your version control\nsystem. Instead, consider using environment variables, secure key management systems, or vault services.
\nEven with the strongest cipher algorithms, there is a risk that your secret keys may be compromised. Therefore, it is a good practice to\nperiodically rotate your secret keys. By doing so, you limit the amount of time that an attacker can misuse a stolen key. When you rotate keys, be\nsure to allow a grace period where tokens signed with the old key are still accepted to prevent service disruptions.
\nRejecting requests with significant content length is a good practice to control the network traffic intensity and thus resource consumption in\norder to prevent DoS attacks.
\nThere is a risk if you answered yes to any of those questions.
\nIt is recommended to customize the rule with the limit values that correspond to the web application.
\n\nusing Microsoft.AspNetCore.Mvc;\n\npublic class MyController : Controller\n{\n [HttpPost]\n [DisableRequestSizeLimit] // Sensitive: No size limit\n [RequestSizeLimit(10485760)] // Sensitive: 10485760 B = 10240 KB = 10 MB is more than the recommended limit of 8MB\n public IActionResult PostRequest(Model model)\n {\n // ...\n }\n\n [HttpPost]\n [RequestFormLimits(MultipartBodyLengthLimit = 10485760)] // Sensitive: 10485760 B = 10240 KB = 10 MB is more than the recommended limit of 8MB\n public IActionResult MultipartFormRequest(Model model)\n {\n // ...\n }\n}\n\nIn Web.config:
\n\n<configuration>\n <system.web>\n <httpRuntime maxRequestLength=\"81920\" executionTimeout=\"3600\" />\n <!-- Sensitive: maxRequestLength is expressed in KB, so 81920 KB = 80 MB -->\n </system.web>\n <system.webServer>\n <security>\n <requestFiltering>\n <requestLimits maxAllowedContentLength=\"83886080\" />\n <!-- Sensitive: maxAllowedContentLength is expressed in bytes, so 83886080 B = 81920 KB = 80 MB -->\n </requestFiltering>\n </security>\n </system.webServer>\n</configuration>\n\n
\nusing Microsoft.AspNetCore.Mvc;\n\npublic class MyController : Controller\n{\n [HttpPost]\n [RequestSizeLimit(8388608)] // Compliant: 8388608 B = 8192 KB = 8 MB\n public IActionResult PostRequest(Model model)\n {\n // ...\n }\n\n [HttpPost]\n [RequestFormLimits(MultipartBodyLengthLimit = 8388608)] // Compliant: 8388608 B = 8192 KB = 8 MB\n public IActionResult MultipartFormRequest(Model model)\n {\n // ...\n }\n}\n\nIn Web.config:
\n\n<configuration>\n <system.web>\n <httpRuntime maxRequestLength=\"8192\" executionTimeout=\"3600\" />\n <!-- Compliant: maxRequestLength is expressed in KB, so 8192 KB = 8 MB -->\n </system.web>\n <system.webServer>\n <security>\n <requestFiltering>\n <requestLimits maxAllowedContentLength=\"8388608\" />\n <!-- Compliant: maxAllowedContentLength is expressed in bytes, so 8388608 B = 8192 KB = 8 MB -->\n </requestFiltering>\n </security>\n </system.webServer>\n</configuration>\n\n
ASP.NET 1.1+ comes with a feature called Request Validation, preventing the server to accept content containing un-encoded HTML. This\nfeature comes as a first protection layer against Cross-Site Scripting (XSS) attacks and act as a simple Web Application Firewall (WAF) rejecting\nrequests potentially containing malicious content.
\nWhile this feature is not a silver bullet to prevent all XSS attacks, it helps to catch basic ones. It will for example prevent <script\ntype=\"text/javascript\" src=\"https://malicious.domain/payload.js\"> to reach your Controller.
Note: Request Validation feature being only available for ASP.NET, no Security Hotspot is raised on ASP.NET Core applications.
\nThere is a risk if you answered yes to any of those questions.
\nAt Controller level:
\n\n[ValidateInput(false)]\npublic ActionResult Welcome(string name)\n{\n ...\n}\n\nAt application level, configured in the Web.config file:
\n\n<configuration>\n <system.web>\n <pages validateRequest=\"false\" />\n ...\n <httpRuntime requestValidationMode=\"0.0\" />\n </system.web>\n</configuration>\n\n
At Controller level:
\n\n[ValidateInput(true)]\npublic ActionResult Welcome(string name)\n{\n ...\n}\n\nor
\n\npublic ActionResult Welcome(string name)\n{\n ...\n}\n\nAt application level, configured in the Web.config file:
\n\n<configuration>\n <system.web>\n <pages validateRequest=\"true\" />\n ...\n <httpRuntime requestValidationMode=\"4.5\" />\n </system.web>\n</configuration>\n\n
When an object is created via deserialization, its constructor is often not executed: the object is instead built directly from its serialized\ndata.\n
\n This means an attacker can create a malicious object and completely bypass security checks.
Serializable class lack relevant security checks.There is a risk if you answered yes to any of those questions.
\nIn the following examples, Serializable classes either omit validation or apply different validation logic during instantiation than\nduring deserialization.
For classes inheriting
\n[Serializable]\npublic class InternalUrl : ISerializable\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n if(!tmpUrl.StartsWith(\"http://localhost/\"))\n {\n url = \"http://localhost/default\";\n }\n else\n {\n url = tmpUrl;\n }\n }\n\n // Special Deserialization constructor\n protected InternalUrl(SerializationInfo info, StreamingContext context)\n {\n url = (string) info.GetValue(\"url\", typeof(string));\n // Sensitive - no validation\n }\n\n void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)\n {\n info.AddValue(\"url\", url);\n }\n}\n\nFor classes inheriting
\n[Serializable]\npublic class InternalUrl : IDeserializationCallback\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n if(!tmpUrl.StartsWith(\"http://localhost/\"))\n {\n url = \"http://localhost/default\";\n }\n else\n {\n url = tmpUrl;\n }\n }\n\n void IDeserializationCallback.OnDeserialization(object sender)\n {\n // Sensitive - no validation\n }\n}\n\nFor classes inheriting from neither of previous types:
\n\n[Serializable]\npublic class InternalUrl\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n // Sensitive - no validation\n url = tmpUrl;\n }\n}\n\nFor classes inheriting
\n[Serializable]\npublic class InternalUrl : ISerializable\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n url = tmpUrl;\n validate();\n }\n\n // Special Deserialization constructor\n protected InternalUrl(SerializationInfo info, StreamingContext context)\n {\n url = (string) info.GetValue(\"url\", typeof(string));\n validate();\n }\n\n void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)\n {\n info.AddValue(\"url\", url);\n }\n\n void validate()\n {\n if(!url.StartsWith(\"http://localhost/\"))\n {\n url = \"http://localhost/default\";\n }\n }\n}\n\nFor classes inheriting
\n[Serializable]\npublic class InternalUrl : IDeserializationCallback\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n url = tmpUrl;\n validate();\n }\n\n void IDeserializationCallback.OnDeserialization(object sender)\n {\n validate();\n }\n}\n\nFor classes inheriting from neither of previous types:
\n\n[Serializable]\npublic class InternalUrl\n{\n private string url;\n\n public InternalUrl(string tmpUrl)\n {\n if(!tmpUrl.StartsWith(\"http://localhost/\"))\n {\n url = \"http://localhost/default\";\n }\n else\n {\n url = tmpUrl;\n }\n }\n}\n\nDeserialization is the process of converting serialized data (such as objects or data structures) back into their original form. Types allowed to\nbe unserialized should be strictly controlled.
\nDuring the deserialization process, the state of an object will be reconstructed from the serialized data stream. By allowing unrestricted\ndeserialization of types, the application makes it possible for attackers to use types with dangerous or otherwise sensitive behavior during the\ndeserialization process.
\nWhen an application deserializes untrusted data without proper restrictions, an attacker can craft malicious serialized objects. Depending on the\naffected objects and properties, the consequences can vary.
\nIf attackers can craft malicious serialized objects that contain executable code, this code will run within the application’s context, potentially\ngaining full control over the system. This can lead to unauthorized access, data breaches, or even complete system compromise.
\nFor example, a well-known attack vector consists in serializing an object of type
Unrestricted deserialization can also enable attackers to escalate their privileges within the application. By manipulating the serialized data, an\nattacker can modify object properties or bypass security checks, granting them elevated privileges that they should not have. This can result in\nunauthorized access to sensitive data, unauthorized actions, or even administrative control over the application.
\nIn some cases, an attacker can abuse the deserialization process to cause a denial of service (DoS) condition. By providing specially crafted\nserialized data, the attacker can trigger excessive resource consumption, leading to system instability or unresponsiveness. This can disrupt the\navailability of the application, impacting its functionality and causing inconvenience to users.
\nWith BinaryFormatter,\nNetDataContractSerializer\nor SoapFormatter:
\nvar myBinaryFormatter = new BinaryFormatter();\nmyBinaryFormatter.Deserialize(stream); // Noncompliant\n\n
With JavaScriptSerializer:
\nJavaScriptSerializer serializer1 = new JavaScriptSerializer(new SimpleTypeResolver()); // Noncompliant\nserializer1.Deserialize<ExpectedType>(json);\n\n
With BinaryFormatter,\nNetDataContractSerializer\nor SoapFormatter:
\nsealed class CustomBinder : SerializationBinder\n{\n public override Type BindToType(string assemblyName, string typeName)\n {\n if (!(typeName == \"type1\" || typeName == \"type2\" || typeName == \"type3\"))\n {\n throw new SerializationException(\"Only type1, type2 and type3 are allowed\");\n }\n return Assembly.Load(assemblyName).GetType(typeName);\n }\n}\n\nvar myBinaryFormatter = new BinaryFormatter();\nmyBinaryFormatter.Binder = new CustomBinder();\nmyBinaryFormatter.Deserialize(stream);\n\nWith JavaScriptSerializer:
\npublic class CustomSafeTypeResolver : JavaScriptTypeResolver\n{\n public override Type ResolveType(string id)\n {\n if(id != \"ExpectedType\") {\n throw new ArgumentNullException(\"Only ExpectedType is allowed during deserialization\");\n }\n return Type.GetType(id);\n }\n}\n\nJavaScriptSerializer serializer = new JavaScriptSerializer(new CustomSafeTypeResolver());\nserializer.Deserialize<ExpectedType>(json);\n\nInstead of using BinaryFormatter\nand similar serializers, it is recommended to use safer alternatives in most of the cases, such as XmlSerializer or DataContractSerializer.
If it’s not possible then try to mitigate the risk by restricting the types allowed to be deserialized:
\nRegular expressions have their own syntax that is\nunderstood by regular expression engines. Those engines will throw an exception at runtime if they are given a regular expression that does not\nconform to that syntax.
\nTo avoid syntax errors, special characters should be
Negative
\nvoid Regexes(string input)\n{\n var regex = new Regex(\"[A\"); // Noncompliant\n var match = Regex.Match(input, \"[A\"); // Noncompliant\n var negativeLookahead = new Regex(\"a(?!b)\", RegexOptions.NonBacktracking); // Noncompliant\n var negativeLookbehind = new Regex(\"(?<!a)b\", RegexOptions.NonBacktracking); // Noncompliant\n}\n\n\nvoid Regexes(string input)\n{\n var regex = new Regex(\"[A-Z]\");\n var match = Regex.Match(input, \"[A-Z]\");\n var negativeLookahead = new Regex(\"a(?!b)\");\n var negativeLookbehind = new Regex(\"(?<!a)b\");\n}\n\nOne of the principles of a unit test is that it must have full control of the system under test. This is problematic when production code includes\ncalls to static methods, which cannot be changed or controlled. Date/time functions are usually provided by system libraries as static methods.
\nThis can be improved by wrapping the system calls in an object or service that can be controlled inside the unit test.
\n\npublic class Foo\n{\n public string HelloTime() =>\n $\"Hello at {DateTime.UtcNow}\";\n}\n\nThere are different approaches to solve this problem. One of them is suggested below. There are also open source libraries (such as NodaTime) which\nalready implement an IClock interface and a FakeClock testing class.
\npublic interface IClock\n{\n DateTime UtcNow();\n}\n\npublic class Foo\n{\n public string HelloTime(IClock clock) =>\n $\"Hello at {clock.UtcNow()}\";\n}\n\npublic class FooTest\n{\n public record TestClock(DateTime now) : IClock\n {\n public DateTime UtcNow() => now;\n }\n\n [Fact]\n public void HelloTime_Gives_CorrectTime()\n {\n var dateTime = new DateTime(2017, 06, 11);\n Assert.Equal((new Foo()).HelloTime(new TestClock(dateTime)), $\"Hello at {dateTime}\");\n }\n}\n\nAnother possible solution is using an adaptable static class, ideally supports an IDisposable method, that not only adjusts the time behaviour for\nthe current thread only, but also for scope of the using.
\n\npublic static class Clock\n{\n public static DateTime UtcNow() { /* ... */ }\n public static IDisposable SetTimeForCurrentThread(Func<DateTime> time) { /* ... */ }\n}\n\npublic class Foo\n{\n public string HelloTime() =>\n $\"Hello at {Clock.UtcNow()}\";\n}\n\npublic class FooTest\n{\n [Fact]\n public void HelloTime_Gives_CorrectTime()\n {\n var dateTime = new DateTime(2017, 06, 11);\n using (Clock.SetTimeForCurrentThread(() => dateTime))\n {\n Assert.Equal((new Foo()).HelloTime(), $\"Hello at {dateTime}\");\n }\n }\n}\n\nXML signatures are a method used to ensure the integrity and authenticity of XML documents. However, if XML signatures are not validated securely,\nit can lead to potential vulnerabilities.
\nXML can be used for a wide variety of purposes. Using a signature on an XML message generally indicates this message requires authenticity and\nintegrity. However, if the signature validation is not properly implemented this authenticity can not be guaranteed.
\nBy not enforcing secure validation, the XML Digital Signature API is more susceptible to attacks such as signature spoofing and injections.
\nBy disabling secure validation, the application becomes more susceptible to signature spoofing attacks. Attackers can potentially manipulate the\nXML signature in a way that bypasses the validation process, allowing them to forge or tamper with the signature. This can lead to the acceptance of\ninvalid or maliciously modified signatures, compromising the integrity and authenticity of the XML documents.
\nDisabling secure validation can expose the application to injection attacks. Attackers can inject malicious code or entities into the XML document,\ntaking advantage of the weakened validation process. In some cases, it can also expose the application to denial-of-service attacks. Attackers can\nexploit vulnerabilities in the validation process to cause excessive resource consumption or system crashes, leading to service unavailability or\ndisruption.
\nThe following noncompliant code example verifies an XML signature without providing a trusted public key. This code will validate the signature\nagainst the embedded public key, accepting any forged signature.
\n\nXmlDocument xmlDoc = new()\n{\n PreserveWhitespace = true\n};\nxmlDoc.Load(\"/data/login.xml\");\nSignedXml signedXml = new(xmlDoc);\nXmlNodeList nodeList = xmlDoc.GetElementsByTagName(\"Signature\");\nsignedXml.LoadXml((XmlElement?)nodeList[0]);\nif (signedXml.CheckSignature()) {\n // Process the XML content\n} else {\n // Raise an error\n}\n\n\nCspParameters cspParams = new()\n{\n KeyContainerName = \"MY_RSA_KEY\"\n};\nRSACryptoServiceProvider rsaKey = new(cspParams);\n\nXmlDocument xmlDoc = new()\n{\n PreserveWhitespace = true\n};\nxmlDoc.Load(\"/data/login.xml\");\nSignedXml signedXml = new(xmlDoc);\nXmlNodeList nodeList = xmlDoc.GetElementsByTagName(\"Signature\");\nsignedXml.LoadXml((XmlElement?)nodeList[0]);\nif (signedXml.CheckSignature(rsaKey)) {\n // Process the XML content\n} else {\n // Raise an error\n}\n\nHere, the compliant solution provides an RSA public key to the signature validation function. This will ensure only signatures computed with the\nassociated private key will be accepted, preventing signature forgery attacks.
\nUsing the CheckSignature method without providing a key can be risky because it may search the AddressBook store for\ncertificates, which includes all trusted root CA certificates on the machine. This broad trust base can be exploited by attackers. Additionally, if\nthe document is not signed with an X.509 signature, the method will use the key embedded in the signature element, which can lead to accepting\nsignatures from untrusted sources.
Hard-coding secrets in source code or binaries makes it easy for attackers to extract sensitive information, especially in distributed or\nopen-source applications. This practice exposes credentials and tokens, increasing the risk of unauthorized access and data breaches.
\nThis rule detects variables/fields/properties having a name matching a list of words (secret, token, credential, auth, api[_.-]?key) being assigned\na pseudorandom hard-coded value. The pseudorandomness of the hard-coded value is based on its entropy and the probability to be human-readable. The\nrandomness sensibility can be adjusted if needed. Lower values will detect less random values, raising potentially more false positives.
\nSecrets should be stored in a configuration file that is not committed to the code repository, in a database, or managed by your cloud provider’s\nsecrets management service. If a secret is exposed in the source code, it must be rotated immediately.
\n\nconst string mySecret = \"47828a8dd77ee1eb9dde2d5e93cb221ce8c32b37\";\n\n
\nstatic readonly string mySecret = Environment.GetEnvironmentVariable(\"MY_APP_SECRET\");\n\n
An Azure Function should be stateless as there’s no control over where and when function instances are provisioned and de-provisioned. Managing and\nstoring data/state between requests can lead to inconsistencies. If, for any reason, you need to have a stateful function, consider using the Durable\nFunctions extension of Azure Functions.
\n\n public static class HttpExample\n {\n private static readonly int port = 2000;\n private static int numOfRequests = 1;\n\n [FunctionName(\"HttpExample\")]\n public static async Task<IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, \"get\", Route = null)] HttpRequest request, ILogger log)\n {\n numOfRequests += 1; // Noncompliant\n log.LogInformation($\"Number of POST requests is {numOfRequests}.\");\n\n string responseMessage = $\"HttpRequest was made on port {port}.\"; // Compliant, state is only read.\n\n return new OkObjectResult(responseMessage);\n }\n }\n\n\n public static class HttpExample\n {\n private static readonly int port = 2000;\n\n [FunctionName(\"HttpExample\")]\n public static async Task<IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, \"get\", Route = null)] HttpRequest request, ILogger log)\n {\n // A compliant solution would be to manage the `numOfRequests` with an entity function or would use storage (e.g., Azure Blob storage, Azure Queue Storage)\n // to share the state between functions.\n\n string responseMessage = $\"HttpRequest was made on port {port}.\";\n\n return new OkObjectResult(responseMessage);\n }\n }\n\nTo avoid holding more connections than necessary and to avoid potentially exhausting the number of available sockets when using\nHttpClient, DocumentClient, QueueClient, ConnectionMultiplexer or Azure Storage clients,\nconsider:
These classes typically manage their own connections to the resource, and thus are intended to be instantiated once and reused throughout the\nlifetime of an application.
\n\n public class HttpExample\n {\n [FunctionName(\"HttpExample\")]\n public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, \"get\", Route = null)] HttpRequest request)\n {\n HttpClient httpClient = new HttpClient(); // Noncompliant\n\n var response = await httpClient.GetAsync(\"https://example.com\");\n // rest of the function\n }\n }\n\n\n public class HttpExample\n {\n [FunctionName(\"HttpExample\")]\n public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Anonymous, \"get\", Route = null)] HttpRequest request, IHttpClientFactory clientFactory)\n {\n var httpClient = clientFactory.CreateClient();\n var response = await httpClient.GetAsync(\"https://example.com\");\n // rest of the function\n }\n }\n\nThe top-most level of an Azure Function code should include a try/catch block to capture and log all errors so you can monitor the health of the\napplication effectively. In case a retry policy has been defined for your Azure Function, you should rethrow any errors that should result in a\nretry.
\n\n[FunctionName(\"HttpExample\")]\npublic static async Task<IActionResult> Run(\n [HttpTrigger(AuthorizationLevel.Function, \"get\", \"post\", Route = null)] HttpRequest req)\n{\n // Noncompliant\n string requestBody = await new StreamReader(req.Body).ReadToEndAsync();\n dynamic data = JsonConvert.DeserializeObject(requestBody);\n // do stuff\n}\n\n\n[FunctionName(\"HttpExample\")]\npublic static async Task<IActionResult> Run(\n [HttpTrigger(AuthorizationLevel.Function, \"get\", \"post\", Route = null)] HttpRequest req)\n{\n try\n {\n string requestBody = await new StreamReader(req.Body).ReadToEndAsync();\n dynamic data = JsonConvert.DeserializeObject(requestBody);\n // do stuff\n }\n catch (Exception ex)\n {\n // do stuff\n }\n}\n\nMaking blocking calls to async methods transforms the code into a\nsynchronous operation. Doing so inside an Azure Function can lead to thread pool exhaustion.
Thread pool exhaustion refers to a situation where all available threads in a thread pool are occupied, and new tasks or work items cannot be\nscheduled for execution due to the lack of available threads. This can lead to delayed execution and degraded performance.
\n\nclass RequestParser\n{\n\t[FunctionName(nameof(ParseRequest))]\n\tpublic static async Task<IActionResult> ParseRequest([HttpTrigger(AuthorizationLevel.Function, \"get\", \"post\", Route = null)] HttpRequest req)\n\t{\n\t\t// This can lead to thread exhaustion\n\t\tstring requestBody = new StreamReader(req.Body).ReadToEndAsync().Result;\n\t\t// do stuff...\n\t}\n}\n\nInstead, asynchronous mechanisms should be used:
\n\nclass RequestParser\n{\n\t[FunctionName(nameof(ParseRequest))]\n\tpublic static async Task<IActionResult> ParseRequest([HttpTrigger(AuthorizationLevel.Function, \"get\", \"post\", Route = null)] HttpRequest req)\n\t{\n\t\t// Non-blocking, asynchronous operation\n\t\tstring requestBody = await new StreamReader(req.Body).ReadToEndAsync();\n\t\t// do stuff...\n\t}\n}\n\nThis applies to multiple methods that are available when working with tasks:
\n| Goal | \nBlocking | \nAsynchronous | \n
|---|---|---|
| \n Wait for the result of a task \n | \n \n
| \n \n
| \n
| \n Wait for any of many task to complete \n | \n \n
| \n \n
| \n
| \n Wait for all of many tasks to complete \n | \n \n
| \n \n
| \n
| \n Wait a period of time \n | \n \n
| \n \n
| \n
Capturing and logging errors is critical to monitoring the health of your Azure Functions application.
\nEach catch block inside an Azure Function should log helpful details about the failure. Moreover, the logging should not be done at\nDebug or Trace level.
Consider using the built-in integration with Application Insights for better monitoring of your Application.
\n\n[FunctionName(\"Foo\")]\npublic static async Task<IActionResult> Run(\n\t[HttpTrigger(AuthorizationLevel.Anonymous, \"get\", \"post\", Route = null)] HttpRequest req,\n\tILogger log)\n{\n\ttry\n\t{\n\t\t// do stuff that can fail\n\t}\n\tcatch (Exception ex)\n\t{\n\t\t// the failure is not logged at all OR is logged at DEBUG/TRACE level\n\t}\n}\n\n\n[FunctionName(\"Foo\")]\npublic static async Task<IActionResult> Run(\n\t[HttpTrigger(AuthorizationLevel.Anonymous, \"get\", \"post\", Route = null)] HttpRequest req,\n\tILogger log)\n{\n\ttry\n\t{\n\t\t// do stuff that can fail\n\t}\n\tcatch (Exception ex)\n\t{\n\t\tlog.LogError(ex, \"Give details that will help investigations\");\n\t}\n}\n\nThe recommended way to access Azure Durable Entities is through generated proxy objects with the help of interfaces.
\nThe following restrictions, during interface design, are enforced:
\nIf any of these rules are violated, an InvalidOperationException is thrown at runtime when the interface is used as a type argument to\nIDurableEntityContext.SignalEntity<TEntityInterface>, IDurableEntityClient.SignalEntityAsync<TEntityInterface>\nor IDurableOrchestrationContext.CreateEntityProxy<TEntityInterface>. The exception message explains which rule was broken.
This rule raises an issue in case any of the restrictions above is not respected.
\n\nnamespace Foo // Noncompliant, must be defined in the same assembly as the entity class that implements it\n{\n public interface ICounter<T> // Noncompliant, interfaces cannot contain generic parameters\n {\n string Name { get; set; } // Noncompliant, interface must only define methods\n void Add(int amount, int secondParameter); // Noncompliant, methods must not have more than one parameter\n int Get(); // Noncompliant, methods must return void, Task, or Task<T>\n }\n}\n\nnamespace Bar\n{\n public class Counter : ICounter\n {\n // do stuff\n }\n\n public static class AddToCounterFromQueue\n {\n [FunctionName(\"AddToCounterFromQueue\")]\n public static Task Run(\n [QueueTrigger(\"durable-function-trigger\")] string input,\n [DurableClient] IDurableEntityClient client)\n {\n var entityId = new EntityId(\"Counter\", \"myCounter\");\n int amount = int.Parse(input);\n return client.SignalEntityAsync<ICounter>(entityId, proxy => proxy.Add(amount, 10));\n }\n }\n}\n\n\nnamespace Bar\n{\n public interface ICounter\n {\n void Add(int amount);\n Task<int> Get();\n }\n}\n\nnamespace Bar\n{\n public class Counter : ICounter\n {\n // do stuff\n }\n\n public static class AddToCounterFromQueue\n {\n [FunctionName(\"AddToCounterFromQueue\")]\n public static Task Run(\n [QueueTrigger(\"durable-function-trigger\")] string input,\n [DurableClient] IDurableEntityClient client)\n {\n var entityId = new EntityId(\"Counter\", \"myCounter\");\n int amount = int.Parse(input);\n return client.SignalEntityAsync<ICounter>(entityId, proxy => proxy.Add(amount));\n }\n }\n}\n\nNot specifying a timeout for regular expressions can lead to a Denial-of-Service attack. Pass a timeout when using\nSystem.Text.RegularExpressions to process untrusted input because a malicious user might craft a value for which the evaluation lasts\nexcessively long.
There is a risk if you answered yes to any of those questions.
\nmatchTimeout when executing a\n regular expression.RegexOptions.NonBacktracking.\npublic void RegexPattern(string input)\n{\n var emailPattern = new Regex(\".+@.+\", RegexOptions.None);\n var isNumber = Regex.IsMatch(input, \"[0-9]+\");\n var isLetterA = Regex.IsMatch(input, \"(a+)+\");\n}\n\n\npublic void RegexPattern(string input)\n{\n var emailPattern = new Regex(\".+@.+\", RegexOptions.None, TimeSpan.FromMilliseconds(100));\n var isNumber = Regex.IsMatch(input, \"[0-9]+\", RegexOptions.None, TimeSpan.FromMilliseconds(100));\n var isLetterA = Regex.IsMatch(input, \"(a+)+\", RegexOptions.NonBacktracking); // .Net 7 and above\n AppDomain.CurrentDomain.SetData(\"REGEX_DEFAULT_MATCH_TIMEOUT\", TimeSpan.FromMilliseconds(100)); // process-wide setting\n}\n\nLocking on a local variable can undermine synchronization because two different threads running the same method in parallel will potentially lock\non different instances of the same object, allowing them to access the synchronized block at the same time.
\n\nprivate void DoSomething()\n{\n object local = new object();\n // Code potentially modifying the local variable ...\n\n lock (local) // Noncompliant\n {\n // ...\n }\n}\n\n\nprivate readonly object lockObj = new object();\n\nprivate void DoSomething()\n{\n lock (lockObj)\n {\n //...\n }\n}\n\nThe Justification property was added to\nthe ExcludeFromCodeCoverageAttribute as an opportunity to document the rationale for the exclusion. This rule raises an issue when no\nsuch justification is given.
\npublic struct Coordinates\n{\n public int X { get; }\n public int Y { get; }\n\n [ExcludeFromCodeCoverage] // Noncompliant\n public override bool Equals(object obj) => obj is Coordinates coordinates && X == coordinates.X && Y == coordinates.Y;\n\n [ExcludeFromCodeCoverage] // Noncompliant\n public override int GetHashCode()\n {\n var hashCode = 1861411795;\n hashCode = hashCode * -1521134295 + X.GetHashCode();\n hashCode = hashCode * -1521134295 + Y.GetHashCode();\n return hashCode;\n }\n}\n\n\npublic struct Coordinates\n{\n public int X { get; }\n public int Y { get; }\n\n [ExcludeFromCodeCoverage(Justification = \"Code generated by Visual Studio refactoring\")] // Compliant\n public override bool Equals(object obj) => obj is Coordinates coordinates && X == coordinates.X && Y == coordinates.Y;\n\n [ExcludeFromCodeCoverage(Justification = \"Code generated by Visual Studio refactoring\")] // Compliant\n public override int GetHashCode()\n {\n var hashCode = 1861411795;\n hashCode = hashCode * -1521134295 + X.GetHashCode();\n hashCode = hashCode * -1521134295 + Y.GetHashCode();\n return hashCode;\n }\n}\n\nThe rule targets the use of DateTime.Now call followed by some arithmetic operation.
Using DateTime.Now calls within a subtraction operation to measure elapsed time is not recommended. This property is subject to\nchanges such as daylight savings transitions, which can invalidate the calculation if the change occurs during the benchmark session, or when updating\na timer. Moreover, DateTime.Now is dependent on the system clock, which may have low resolution on older systems (as low as 15\nmilliseconds).
If the purpose is to benchmark something then, instead of the DateTime.Now property, it’s recommended to use Stopwatch,\nwhich is not affected by changes in time such as daylight savings (DST) and automatically checks for the existence of high-precision timers. As a\nbonus, the StopWatch class is also lightweight and computationally faster than DateTime.
\nvar start = DateTime.Now; // First call, on March 26th 2:59 am\nMethodToBeBenchmarked();\n\nConsole.WriteLine($\"{(DateTime.Now - start).TotalMilliseconds} ms\"); // Second call happens 2 minutes later but `Now` is March 26th, 4:01 am as there's a shift to summer time\n\n\nvar stopWatch = Stopwatch.StartNew(); // Compliant\nMethodToBeBenchmarked();\nstopWatch.Stop();\n\nConsole.WriteLine($\"{stopWatch.ElapsedMilliseconds} ms\");\n\nIf, on the other hand, the goal is to refresh a timer prefer using the DateTime.UtcNow property, which guarantees reliable results\nwhen doing arithmetic operations during DST transitions.
\nif ((DateTime.Now - lastRefresh).TotalMilliseconds > MinRefreshInterval)\n{\n lastRefresh = DateTime.Now;\n // Refresh\n}\n\n\nif ((DateTime.UtcNow - lastRefresh).TotalMilliseconds > MinRefreshInterval)\n{\n lastRefresh = DateTime.UtcNow;\n // Refresh\n}\n\nNot knowing the Kind of the DateTime object that an application is using can lead to misunderstandings when displaying or\ncomparing them. Explicitly setting the Kind property helps the application to stay consistent, and its maintainers understand what kind\nof date is being managed. To achieve this, when instantiating a new DateTime object you should always use a constructor overload that\nallows you to define the Kind property.
Creating the DateTime object without specifying the property Kind will set it to the default value of\nDateTimeKind.Unspecified. In this case, calling the method ToUniversalTime will assume that Kind is\nDateTimeKind.Local and calling the method ToLocalTime will assume that it’s DateTimeKind.Utc. As a result, you\nmight have mismatched DateTime objects in your application.
To resolve this issue, use a constructor overload that lets you\nspecify the DateTimeKind when creating the\nDateTime object. From .Net 6 onwards, use the DateOnly type if the time portion of the date is not\nrelevant.
\nvoid CreateNewTime()\n{\n var birthDate = new DateTime(1994, 7, 5, 16, 23, 42);\n}\n\n\nvoid CreateNewTime()\n{\n var birthDate = new DateTime(1994, 7, 5, 16, 23, 42, DateTimeKind.Utc);\n // or from .Net 6 onwards, use DateOnly:\n var birthDate = new DateOnly(1994, 7, 5);\n}\n\nYou should avoid recording time instants with the use of property DateTime.Now. The property DateTime.Now returns the\ncurrent date and time expressed in the machine’s local time without containing any timezone-related information (for example, the offset from\nCoordinated Universal Time). Not having this information means that if you need to display this DateTime object or use it for\ncomputations in another machine placed in a different time zone, you won’t be able to reconstruct it in the second machine’s local time without\nknowing the origin’s offset. This will likely lead to confusion and potential bugs.
Instead, you should record the DateTime instants in UTC, which gives you the date and time as it is in the Coordinated Universal Time.\nUTC is a time standard for all time zones and is not subjected to Daylight Saving Time (DST).
Similarly, the use of the DateTime.Today property should also be avoided, as it can return different date values depending on the time\nzone.
Generally, unless the purpose is to only display the Date and Time to a user on their local machine, you should always use UTC (for example, when\nstoring dates in a datebase or using them for calculations).
\nYou can end up with DateTime instants that have no meaning for anyone except the machine they were recorded on. Using UTC gives an\nunambiguous representation of an instant, and this UTC instant can be transformed into any equivalent local time. This operation isn’t reversible as\nsome local times are ambiguous and can be matched to more than one UTC instant (for example, due to daylight savings).
Instead of DateTime.Now use any of the following:
DateTime.UtcNow,DateTimeOffSet.Now (as it contains offset information)DateTimeOffSet.UtcNowInstead of DateTime.Today use any of the following:
DateTime.UtcNow.Date,DateOnly.FromDateTime(DateTime.UtcNow) (.NET 6.0+)\nvoid LogDateTime()\n{\n using var streamWriter = new StreamWriter(\"logs.txt\", true);\n streamWriter.WriteLine($\"DateTime:{DateTime.Now.ToString(\"o\")}\"); // This log won't have any meaning if it's reconstructed in a machine in a different timezone.\n}\n\n\nvoid LogDateTime()\n{\n using var streamWriter = new StreamWriter(\"logs.txt\", true);\n streamWriter.WriteLine($\"DateTime:{DateTime.UtcNow.ToString(\"o\")}\");\n}\n\nThis rule recommends using DateTimeOffset instead of DateTime for projects targeting .NET Framework 2.0 or later.
You should use DateTimeOffset instead of DateTime as it provides all the information that the DateTime\nstruct has, and additionally, the offset from Coordinated Universal Time (UTC). This way you can avoid potential problems created by the lack of\ntimezone awareness (see the \"Pitfalls\" section below for more information).
However, it’s important to note that although DateTimeOffset contains more information than DateTime by storing the\noffset to UTC, it isn’t tied to a specific time zone. This information must be stored separately to have a full picture of the moment in time with the\nuse of TimeZoneInfo.
In most cases, you can directly replace DateTime with DateTimeOffset. When hardcoding dates with local kind, remember\nthat the offset is timezone dependent, so it should be set according to which timezone that data represents. For more information, refer to\nDateTime and DateTimeOffset documentation from Microsoft (see the \"Resources\" section below).
\nDateTime myDate = new DateTime(2008, 6, 19, 7, 0, 0, DateTimeKind.Local); // Noncompliant\n\nvar now = DateTime.Now; // Noncompliant\n\n
\nDateTimeOffset myDate = new DateTimeOffset(2008, 6, 19, 7, 0, 0, TimeSpan.FromHours(-7)); // Compliant\n\nvar now = DateTimeOffset.Now; // Compliant\n\n
Common DateTime pitfalls include:
DateTime of kind Local consider the time offset of the machine where the program is running. Not\n storing the offset from UTC separately can result in meaningless data when retrieved from a different location.DateTime of kind Unknown, calling ToUniversalTime() presumes the\n DateTime.Kind is local and converts to UTC, if you call the method ToLocalTime(), it assumes the\n DateTime.Kind is UTC and converts it to local.DateTimes objects, the user must ensure they are within the same time zone. DateTime doesn’t consider\n UTC/Local when comparing; it only cares about the number of Ticks on the objects.Since .NET 6 you don’t have to use the TimeZoneConverter library to manually do the conversion between IANA and Windows timezones. The\n.NET 6.0 introduced new Time Zone enhancements, one being the TimeZoneInfo.FindSystemTimeZoneById(string timezone) method now accepts as\ninput both IANA and Windows time zone IDs on any operating system with installed time zone data. TimeZoneInfo.FindSystemTimeZoneById will\nautomatically convert its input from IANA to Windows and vice versa if the requested time zone is not found on the system.
The method TimeZoneInfo.FindSystemTimeZoneById(string timezone) can get both IANA and Windows timezones as input and automatically\nconvert one to the other if the requested time zone is not found on the system. Because one does not need to handle the conversion, the code will be\nless complex and easier to maintain.
There’s no need to translate manually between time zones; it is enough to call TimeZoneInfo.FindSystemTimeZoneById(string timezone),\nwhere the timezone can be IANA or Windows format. Depending on the OS, the equivalent time zone will be returned (Windows Time Zones for Windows and\nIANA timezones for Linux, macOS).
\n// Assuming we are in Windows OS and we need to get the Tokyo Time Zone.\nvar ianaTimeZone = \"Asia/Tokyo\";\nvar windowsTimeZone = TZConvert.IanaToWindows(ianaTimeZone);\nTimeZoneInfo tokyoWindowsTimeZone = TimeZoneInfo.FindSystemTimeZoneById(windowsTimeZone);\n\n
\n// Assuming we are in Windows OS and we need to get the Tokyo Time Zone.\nvar ianaTimeZone = \"Asia/Tokyo\";\nTimeZoneInfo tokyoWindowsTimeZone = TimeZoneInfo.FindSystemTimeZoneById(ianaTimeZone);\n\n
When converting a string representation of a date and time to a DateTime object or any other temporal type with one of the available\nsystem parsing methods, you should always provide an IFormatProvider parameter.
If you try to parse a string representation of a date or time without a format provider, the method will use the machine’s\nCultureInfo; if the given string does not follow it, you’ll have an object that does not match the string representation or an unexpected\nruntime error.
This rule raises an issue for the following date and time string representation parsing methods:
\nParseParseExactTryParseTryParseExactOf the following types:
\nSystem.DateOnlySystem.DateTimeSystem.DateTimeOffsetSystem.TimeOnlySystem.TimeSpanAlway use an overload of the parse method, where you can provide an IFormatProvider parameter.
\nvar dateTimeString = \"4/12/2023 4:05:48 PM\"; // This is an en-US format string - 12 of April 2023\nvar dateTimeObject = DateTime.Parse(dateTimeString); // This is wrongly parsed as 4th of December, when it's read in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe)\n\nvar dateTimeString2 = \"4/13/2023 4:05:48 PM\"; // This is an en-US format string - 13 of April 2023\nvar dateTimeObject2 = DateTime.Parse(dateTimeString2); // Runtime Error, when it's parsed in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe).\n\nvar timeInSaudiArabia = new TimeOnly(16, 23).ToString(new CultureInfo(\"ar-SA\"));\nvar timeObject = TimeOnly.Parse(timeInSaudiArabia); // Runtime Error, when it's parsed in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe).\n\n
\nvar dateTimeString = \"4/12/2023 4:05:48 PM\"; // This is an en-US format string - 12 of April 2023\nvar dateTimeObject = DateTime.Parse(dateTimeString, new CultureInfo(\"en-US\"));\n\nvar dateTimeString2 = \"4/13/2023 4:05:48 PM\"; // This is an en-US format string - 13 of April 2023\nvar dateTimeObject2 = DateTime.Parse(dateTimeString2, new CultureInfo(\"en-US\"))\n\nvar timeInSaudiArabia = new TimeOnly(16, 23).ToString(new CultureInfo(\"ar-SA\"));\nvar timeObject = TimeOnly.Parse(timeInSaudiArabia, new CultureInfo(\"ar-SA\"));\n\n
Hardcoding the date and time format strings can lead to formats that consumers misunderstand. Also, if the same format is meant to be used in\nmultiple places, it is easier to make a mistake when it’s hardcoded instead of using a format provided by an IFormatProvider or using one\nof the standard format strings.
If a non-conventional format is used, the formatted date and time can be misunderstood. Also, if a mistake is made in the format, the formatted\ndate can be incomplete. For example, you might switch the place of the minutes and month parts of a date or simply forget to print the year.
\nInstead of hardcoding the format, provide one from the available formats through an IFormatProvider or use one of the standard format\nstrings.
\nvoid PrintTime()\n{\n Console.WriteLine(DateTime.UtcNow.ToString(\"dd/MM/yyyy HH:mm:ss\"));\n\n Console.WriteLine(DateTime.UtcNow.ToString(\"dd/mm/yyyy HH:MM:ss\")); // Months and minutes have changed their places\n}\n\n\nvoid PrintTime()\n{\n Console.WriteLine(DateTime.UtcNow.ToString(CultureInfo.GetCultureInfo(\"es-MX\")));\n\n Console.WriteLine(DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)); // Better provide a well known culture, so this kind of issues do not pop up\n}\n\nWith .NET Core the UnixEpoch field was introduced to DateTime and DateTimeOffset types. Using this field\nclearly states that the intention is to use the beginning of the Unix epoch.
You should not use the DateTime or DateTimeOffset constructors to set the time to the 1st of January 1970 to represent\nthe beginning of the Unix epoch. Not everyone is familiar with what this particular date is representing and it can be misleading.
To fix this issue, use the UnixEpoch field of DateTime or DateTimeOffset instead of the constructor.
\nvoid GetEpochTime()\n{\n var epochTime = new DateTime(1970, 1, 1);\n}\n\n\nvoid GetEpochTime()\n{\n var epochTime = DateTime.UnixEpoch;\n}\n\nBoth the List.Find method and the Enumerable.FirstOrDefault method can be used to locate the first element that meets a\nspecified condition within a collection. However, for List objects, List.Find may offer superior performance compared to\nEnumerable.FirstOrDefault. While the performance difference might be negligible for small collections, it can become significant for\nlarger collections. This observation also holds true for ImmutableList and arrays.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the FirstOrDefault closer to the performance of collection-specific Find methods in most scenarios.
Applies to
\nWe measured at least 2x improvement in the execution time. For more details see the Benchmarks section from the More info\ntab.
The Find method is defined on the collection class, and it has the same signature as FirstOrDefault extension method. The\nfunction can be replaced in place.
\nint GetValue(List<int> data) =>\n data.FirstOrDefault(x => x % 2 == 0);\n\n
\nint GetValue(int[] data) =>\n data.FirstOrDefault(x => x % 2 == 0);\n\n
\nint GetValue(List<int> data) =>\n data.Find(x => x % 2 == 0);\n\n
\nint GetValue(int[] data) =>\n Array.Find(data, x => x % 2 == 0);\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 10.515 μs \n | \n \n 0.1410 μs \n | \n \n 32 B \n | \n
| \n ArrayFind \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 4.417 μs \n | \n \n 0.0729 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 2.262 μs \n | \n \n 0.0135 μs \n | \n \n - \n | \n
| \n ArrayFind \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 3.428 μs \n | \n \n 0.0206 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 45.074 μs \n | \n \n 0.7517 μs \n | \n \n 32 B \n | \n
| \n ArrayFind \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 13.948 μs \n | \n \n 0.1496 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 83.796 μs \n | \n \n 1.3199 μs \n | \n \n 72 B \n | \n
| \n ImmutableListFind \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 59.720 μs \n | \n \n 1.0723 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 81.984 μs \n | \n \n 1.0886 μs \n | \n \n 72 B \n | \n
| \n ImmutableListFind \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 58.288 μs \n | \n \n 0.8079 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 446.893 μs \n | \n \n 9.8430 μs \n | \n \n 76 B \n | \n
| \n ImmutableListFind \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 427.476 μs \n | \n \n 3.3371 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 14.808 μs \n | \n \n 0.1723 μs \n | \n \n 40 B \n | \n
| \n ListFind \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 6.040 μs \n | \n \n 0.1104 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 2.233 μs \n | \n \n 0.0154 μs \n | \n \n - \n | \n
| \n ListFind \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 4.458 μs \n | \n \n 0.0745 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 57.290 μs \n | \n \n 1.0494 μs \n | \n \n 40 B \n | \n
| \n ListFind \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 18.476 μs \n | \n \n 0.0504 μs \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == 1;\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == 1;\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate int[] array;\npublic const int N = 10_000;\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic int ListFirstOrDefault() =>\n list.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic int ListFind() =>\n list.Find(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic int ImmutableListFirstOrDefault() =>\n immutableList.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic int ImmutableListFind() =>\n immutableList.Find(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic int ArrayFirstOrDefault() =>\n array.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic int ArrayFind() =>\n Array.Find(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6602.json", "content": "{\n \"title\": \"\\\"Find\\\" method should be used instead of the \\\"FirstOrDefault\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6602\",\n \"sqKey\": \"S6602\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6603.html", "content": "
Both the List.TrueForAll method and the IEnumerable.All method can be used to check if all list elements satisfy a given\ncondition in a collection. However, List.TrueForAll can be faster than IEnumerable.All for List objects. The\nperformance difference may be minor for small collections, but for large collections, it can be noticeable.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the All closer to the performance of collection-specific TrueForAll methods in most scenarios.
Applies to
\nWe measured at least 4x improvement both in execution time. For more details see the Benchmarks section from the More\ninfo tab.
The TrueForAll method is defined on the collection class, and it has the same signature as the All extension method. The\nmethod can be replaced in place.
\npublic bool AreAllEven(List<int> data) =>\n data.All(x => x % 2 == 0);\n\n
\npublic bool AreAllEven(int[] data) =>\n data.All(x => x % 2 == 0);\n\n
\npublic bool AreAllEven(List<int> data) =>\n data.TrueForAll(x => x % 2 == 0);\n\n
\npublic bool AreAllEven(int[] data) =>\n Array.TrueForAll(data, x => x % 2 == 0);\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayAll \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 109.25 μs \n | \n \n 1.767 μs \n | \n \n 32 B \n | \n
| \n ArrayTrueForAll \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 45.01 μs \n | \n \n 0.547 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAll \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 22.28 μs \n | \n \n 0.254 μs \n | \n \n - \n | \n
| \n ArrayTrueForAll \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 37.60 μs \n | \n \n 0.382 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAll \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 495.90 μs \n | \n \n 4.342 μs \n | \n \n 40 B \n | \n
| \n ArrayTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 164.52 μs \n | \n \n 2.030 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 940.29 μs \n | \n \n 5.600 μs \n | \n \n 72 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 679.46 μs \n | \n \n 2.371 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 922.43 μs \n | \n \n 14.564 μs \n | \n \n 72 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 692.31 μs \n | \n \n 8.897 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 4,578.72 μs \n | \n \n 77.920 μs \n | \n \n 128 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 4,393.49 μs \n | \n \n 122.061 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 970.45 μs \n | \n \n 13.598 μs \n | \n \n 73 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 687.82 μs \n | \n \n 6.142 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 981.17 μs \n | \n \n 12.966 μs \n | \n \n 72 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 710.19 μs \n | \n \n 16.195 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T>.Builder \n | \n \n 4,780.50 μs \n | \n \n 43.282 μs \n | \n \n 128 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T>.Builder \n | \n \n 4,493.82 μs \n | \n \n 76.530 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 151.12 μs \n | \n \n 2.028 μs \n | \n \n 40 B \n | \n
| \n ListTrueForAll \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 58.03 μs \n | \n \n 0.493 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 22.14 μs \n | \n \n 0.327 μs \n | \n \n - \n | \n
| \n ListTrueForAll \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 46.01 μs \n | \n \n 0.327 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 619.86 μs \n | \n \n 6.037 μs \n | \n \n 48 B \n | \n
| \n ListTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 208.49 μs \n | \n \n 2.340 μs \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == Math.Abs(x);\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == Math.Abs(x);\n\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate ImmutableList<int>.Builder immutableListBuilder;\nprivate int[] array;\n\n[Params(100_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n immutableListBuilder = ImmutableList.CreateBuilder<int>();\n immutableListBuilder.AddRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic bool ListAll() =>\n list.All(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic bool ListTrueForAll() =>\n list.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic bool ImmutableListAll() =>\n immutableList.All(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic bool ImmutableListTrueForAll() =>\n immutableList.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>.Builder\"), Benchmark(Baseline = true)]\npublic bool ImmutableListBuilderAll() =>\n immutableListBuilder.All(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>.Builder\"), Benchmark]\npublic bool ImmutableListBuilderTrueForAll() =>\n immutableListBuilder.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic bool ArrayAll() =>\n array.All(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic bool ArrayTrueForAll() =>\n Array.TrueForAll(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6603.json", "content": "{\n \"title\": \"The collection-specific \\\"TrueForAll\\\" method should be used instead of the \\\"All\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6603\",\n \"sqKey\": \"S6603\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6605.html", "content": "
Both the List.Exists method and IEnumerable.Any method can be used to find the first element that satisfies a predicate\nin a collection. However, List.Exists can be faster than IEnumerable.Any for List objects, as well as requires\nsignificantly less memory. For small collections, the performance difference may be negligible, but for large collections, it can be noticeable. The\nsame applies to ImmutableList and arrays too.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the Any closer to the performance of collection-specific Exists methods in most scenarios.
Applies to
\nWe measured at least 3x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
Also, no memory allocations were needed for the Exists method, since the search is done in-place.
Since LINQ to\nEntities relies a lot on System.Linq for
The Exists method is defined on the collection class, and it has the same signature as Any extension method if a\npredicate is used. The method can be replaced in place.
\nbool ContainsEven(List<int> data) =>\n data.Any(x => x % 2 == 0);\n\n
\nbool ContainsEven(int[] data) =>\n data.Any(x => x % 2 == 0);\n\n
\nbool ContainsEven(List<int> data) =>\n data.Exists(x => x % 2 == 0);\n\n
\nbool ContainsEven(int[] data) =>\n Array.Exists(data, x => x % 2 == 0);\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayAny \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 1,174.0 ns \n | \n \n 16.44 ns \n | \n \n 32 B \n | \n
| \n ArrayExists \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 570.6 ns \n | \n \n 7.12 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAny \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 358.5 ns \n | \n \n 5.57 ns \n | \n \n - \n | \n
| \n ArrayExists \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 581.6 ns \n | \n \n 6.17 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAny \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 4,896.0 ns \n | \n \n 102.83 ns \n | \n \n 32 B \n | \n
| \n ArrayExists \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 1,649.4 ns \n | \n \n 29.81 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 7,859.3 ns \n | \n \n 91.45 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 5,898.1 ns \n | \n \n 81.69 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 7,748.9 ns \n | \n \n 119.10 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 5,705.0 ns \n | \n \n 31.53 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 45,118.5 ns \n | \n \n 168.72 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 41,966.0 ns \n | \n \n 631.59 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 1,643.5 ns \n | \n \n 13.09 ns \n | \n \n 40 B \n | \n
| \n ListExists \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 726.2 ns \n | \n \n 11.99 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 398.6 ns \n | \n \n 8.20 ns \n | \n \n - \n | \n
| \n ListExists \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 612.4 ns \n | \n \n 18.73 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 5,621.5 ns \n | \n \n 35.80 ns \n | \n \n 40 B \n | \n
| \n ListExists \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 1,748.0 ns \n | \n \n 11.76 ns \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == -1 * Math.Abs(x);\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == -1 * Math.Abs(x);\n\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate int[] array;\n\n[Params(1_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic bool ListAny() =>\n list.Any(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic bool ListExists() =>\n list.Exists(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic bool ImmutableListAny() =>\n immutableList.Any(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic bool ImmutableListExists() =>\n immutableList.Exists(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic bool ArrayAny() =>\n array.Any(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic bool ArrayExists() =>\n Array.Exists(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6605.json", "content": "{\n \"title\": \"Collection-specific \\\"Exists\\\" method should be used instead of the \\\"Any\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6605\",\n \"sqKey\": \"S6605\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6607.html", "content": "
When working with LINQ in C#, it is recommended to pay attention to the order in which methods are chained, especially when using\nWhere and OrderBy methods. It is advised to call the Where method before OrderBy because\nWhere filters the elements of the sequence based on a given condition and returns a new sequence containing only the elements that\nsatisfy that condition. Calling OrderBy before Where, may end up sorting elements that will be later discarded, which can\nlead to inefficiency. Conversely, calling Where before OrderBy, will first filter the sequence to include only the elements\nof interest, and then sort them based on the specified order.
We measured at least 2x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
The issue can be fixed by calling Where before OrderBy.
\npublic IEnumerable<int> GetSortedFilteredList(IEnumerable<int> data) =>\n data.OrderBy(x => x).Where(x => x % 2 == 0);\n\n
\npublic IEnumerable<int> GetSortedFilteredList(IEnumerable<int> data) =>\n data.Where(x => x % 2 == 0).OrderBy(x => x);\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n OrderByThenWhere \n | \n \n .NET 7.0 \n | \n \n 175.36 ms \n | \n \n 5.101 ms \n | \n
| \n WhereThenOrderBy \n | \n \n .NET 7.0 \n | \n \n 85.58 ms \n | \n \n 1.697 ms \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate IList<int> data;\nprivate static readonly Random Random = new Random();\n\n[Params(1_000_000)]\npublic int NumberOfEntries;\n\n[GlobalSetup]\npublic void Setup() =>\n data = Enumerable.Range(0, NumberOfEntries).Select(x => Random.Next(0, NumberOfEntries)).ToList();\n\n[Benchmark(Baseline = true)]\npublic void OrderByThenWhere() =>\n _ = data.OrderBy(x => x).Where(x => x % 2 == 0 ).ToList(); // OrderBy followed by Where\n\n[Benchmark]\npublic void WhereThenOrderBy() =>\n _ = data.Where(x => x % 2 == 0 ).OrderBy(x => x).ToList(); // Where followed by OrderBy\n\n
Hardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S6607.json", "content": "{\n \"title\": \"The collection should be filtered before sorting by using \\\"Where\\\" before \\\"OrderBy\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6607\",\n \"sqKey\": \"S6607\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6608.html", "content": "
Indexes in C# provide direct access to an element at a specific position within an array or collection. When compared to Enumerable\nmethods, indexing can be more efficient for certain scenarios, such as iterating over a large collection, due to avoiding the overhead of checking the\nunderlying collection type before accessing it.
This applies to types that implement one of these interfaces:
\nWe measured a significant improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
If the type you are using implements IList, IList<T> or IReadonlyList<T>, it implements\nthis[int index]. This means calls to First, Last, or ElementAt(index) can be replaced with\nindexing at 0, Count-1 and index respectively.
\nint GetAt(List<int> data, int index)\n => data.ElementAt(index);\n\n
\nint GetFirst(List<int> data)\n => data.First();\n\n
\nint GetLast(List<int> data)\n => data.Last();\n\n
\nint GetAt(List<int> data, int index)\n => data[index];\n\n
\nint GetFirst(List<int> data)\n => data[0];\n\n
\nint GetLast(List<int> data)\n => data[data.Count-1];\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n ElementAt \n | \n \n 3,403.4 ns \n | \n \n 28.52 ns \n | \n \n 26.67 ns \n | \n
| \n Index \n | \n \n 478.0 ns \n | \n \n 6.93 ns \n | \n \n 6.48 ns \n | \n
| \n First \n | \n \n 6,160.0 ns \n | \n \n 57.66 ns \n | \n \n 53.93 ns \n | \n
| \n First_Index \n | \n \n 485.7 ns \n | \n \n 5.81 ns \n | \n \n 5.15 ns \n | \n
| \n Last \n | \n \n 6,034.3 ns \n | \n \n 20.34 ns \n | \n \n 16.98 ns \n | \n
| \n Last_Index \n | \n \n 408.3 ns \n | \n \n 2.54 ns \n | \n \n 2.38 ns \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate List<byte> data;\nprivate Random random;\n\n[Params(1_000_000)]\npublic int SampleSize;\n\n[Params(1_000)]\npublic int LoopSize;\n\n[GlobalSetup]\npublic void Setup()\n{\n random = new Random(42);\n\n var bytes = new byte[SampleSize];\n random.NextBytes(bytes);\n data = bytes.ToList();\n}\n\n[Benchmark]\npublic int ElementAt()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.ElementAt(i);\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[i];\n }\n\n return result;\n}\n\n[Benchmark]\npublic int First()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.First();\n }\n\n return result;\n}\n\n[Benchmark]\npublic int First_Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[0];\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Last()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.Last();\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Last_Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[data.Count - 1];\n }\n\n return result;\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.4412/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=8.0.301\n [Host] : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2\n .NET 8.0 : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S6608.json", "content": "{\n \"title\": \"Prefer indexing instead of \\\"Enumerable\\\" methods on types implementing \\\"IList\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6608\",\n \"sqKey\": \"S6608\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6609.html", "content": "
Both the Enumerable.Max extension method and the SortedSet<T>.Max property can be used to find the maximum value in\na SortedSet<T>. However, SortedSet<T>.Max is much faster than Enumerable.Max. For small\ncollections, the performance difference may be minor, but for large collections, it can be noticeable. The same applies for the Min\nproperty as well.
Max and Min in SortedSet<T> exploit the fact that the set is implemented via a Red-Black\ntree. The algorithm to find the Max/Min is \"go left/right whenever possible\". The operation has the time complexity\nof O(h) which becomes O(ln(n)) due to the fact that the tree is balanced. This is much better than the O(n)\ntime complexity of extension methods.
Max and Min in ImmutableSortedSet<T> exploits a tree augmentation technique, storing the\nMin, Max and Count values on each node of the data structure. The time complexity in this case is\nO(1) that is significantly better than O(n) of extension methods.
Applies to:
\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
The Min and Max properties are defined on the following classes, and the extension method call can be replaced by calling\nthe propery instead:
SortedSet<T>ImmutableSortedSet<T>ImmutableSortedSet<T>.Builder\nint GetMax(SortedSet<int> data) =>\n data.Max();\n\n
\nint GetMin(SortedSet<int> data) =>\n data.Min();\n\n
\nint GetMax(SortedSet<int> data) =>\n data.Max;\n\n
\nint GetMin(SortedSet<int> data) =>\n data.Min;\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n MaxMethod \n | \n \n .NET 7.0 \n | \n \n 68,961.483 us \n | \n \n 499.6623 us \n | \n \n 248063 B \n | \n
| \n MaxProperty \n | \n \n .NET 7.0 \n | \n \n 4.638 us \n | \n \n 0.0634 us \n | \n \n - \n | \n
| \n MaxMethod \n | \n \n .NET Framework 4.6.2 \n | \n \n 85,827.359 us \n | \n \n 1,531.1611 us \n | \n \n 281259 B \n | \n
| \n MaxProperty \n | \n \n .NET Framework 4.6.2 \n | \n \n 67.682 us \n | \n \n 0.3757 us \n | \n \n 312919 B \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate SortedSet<string> data;\n\n[Params(1_000)]\npublic int Iterations;\n\n[GlobalSetup]\npublic void Setup() =>\n data = new SortedSet<string>(Enumerable.Range(0, Iterations).Select(x => Guid.NewGuid().ToString()));\n\n[Benchmark(Baseline = true)]\npublic void MaxMethod()\n{\n for (var i = 0; i < Iterations; i++)\n {\n _ = data.Max(); // Max() extension method\n }\n}\n\n[Benchmark]\npublic void MaxProperty()\n{\n for (var i = 0; i < Iterations; i++)\n {\n _ = data.Max; // Max property\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6609.json", "content": "{\n \"title\": \"\\\"Min\\/Max\\\" properties of \\\"Set\\\" types should be used instead of the \\\"Enumerable\\\" extension methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6609\",\n \"sqKey\": \"S6609\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6610.html", "content": "
With string.StartsWith(char) and string.EndsWith(char), only the first character of the string is compared to the\nprovided character, whereas the string versions of those methods have to do checks about the current StringComparison and\nCultureInfo. Thus, the char overloads are significantly faster for default comparison scenarios.
These overloads were introduced in .NET Core 2.0.
We measured at least 3.5x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
If you are targeting a runtime version equal or greater than .NET Core 2.0, the string.StartsWith and\nstring.EndsWith overloads are available, with the argument’s type being char instead of string. Thus, an\nargument of char type can be provided.
\nbool StartsWithSlash(string s) =>\n s.StartsWith(\"/\");\n\n
\nbool EndsWithSlash(string s) =>\n s.EndsWith(\"/\");\n\n
\nbool StartsWithSlash(string s) =>\n s.StartsWith('/');\n\n\nbool EndsWithSlash(string s) =>\n s.EndsWith('/');\n\n| Method | \nMean | \nStandard Deviation | \n
|---|---|---|
| \n StartsWith_String \n | \n \n 30.965 ms \n | \n \n 3.2732 ms \n | \n
| \n StartsWith_Char \n | \n \n 7.568 ms \n | \n \n 0.3235 ms \n | \n
| \n EndsWith_String \n | \n \n 30.421 ms \n | \n \n 5.1136 ms \n | \n
| \n EndsWith_Char \n | \n \n 8.067 ms \n | \n \n 0.7092 ms \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate List<string> data;\n\n[Params(1_000_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void Setup() =>\n data = Enumerable.Range(0, N).Select(_ => Guid.NewGuid().ToString()).ToList();\n\n[Benchmark]\npublic void StartsWith_String()\n{\n _ = data.Where(guid => guid.StartsWith(\"d\")).ToList();\n}\n\n[Benchmark]\npublic void StartsWith_Char()\n{\n _ = data.Where(guid => guid.StartsWith('d')).ToList();\n}\n\n[Benchmark]\npublic void EndsWith_String()\n{\n _ = data.Where(guid => guid.EndsWith(\"d\")).ToList();\n}\n\n[Benchmark]\npublic void EndsWith_Char()\n{\n _ = data.Where(guid => guid.EndsWith('d')).ToList();\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S6610.json", "content": "{\n \"title\": \"\\\"StartsWith\\\" and \\\"EndsWith\\\" overloads that take a \\\"char\\\" should be used instead of the ones that take a \\\"string\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6610\",\n \"sqKey\": \"S6610\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S6612.html", "content": "
When using the ConcurrentDictionary, there are many overloads of the GetOrAdd and AddOrUpdate methods that\ntake both a TKey argument and a lambda that expects a TKey parameter. This means that the right side of the lambda can be\nwritten using either the lambda’s parameter or the method’s argument. However, using the method’s argument leads to the lambda capturing it, and the\ncompiler will need to generate a class and instantiate it before the call. This means memory allocations, as well as more time spend during Garbage\nCollection.
We measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
When you are using the ConcurrentDictionary methods GetOrAdd or AddOrUpdate, reference the key by using the\nlambda’s parameter instead of the method’s one.
\nint UpdateValue(ConcurrentDictionary<int, int> dict, int key) =>\n dict.GetOrAdd(key, _ => key + 42);\n\n
\nint UpdateValue(ConcurrentDictionary<int, int> dict, int key) =>\n dict.GetOrAdd(key, x => x + 42);\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n Capture \n | \n \n .NET 7.0 \n | \n \n 68.52 ms \n | \n \n 4.450 ms \n | \n \n 88000063 B \n | \n
| \n Lambda \n | \n \n .NET 7.0 \n | \n \n 39.29 ms \n | \n \n 3.712 ms \n | \n \n 50 B \n | \n
| \n Capture \n | \n \n .NET Framework 4.6.2 \n | \n \n 74.58 ms \n | \n \n 5.199 ms \n | \n \n 88259787 B \n | \n
| \n Lambda \n | \n \n .NET Framework 4.6.2 \n | \n \n 42.03 ms \n | \n \n 2.752 ms \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate ConcurrentDictionary<int, string> dict;\nprivate List<int> data;\n\n[Params(1_000_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void Setup()\n{\n dict = new ConcurrentDictionary<int, string>();\n data = Enumerable.Range(0, N).OrderBy(_ => Guid.NewGuid()).ToList();\n}\n\n[Benchmark(baseline=true)]\npublic void Capture()\n{\n foreach (var guid in data)\n {\n dict.GetOrAdd(guid, _ => $\"{guid}\"); // \"guid\" is captured\n }\n}\n\n[Benchmark]\npublic void Lambda()\n{\n foreach (var guid in data)\n {\n dict.GetOrAdd(guid, x => $\"{x}\"); // no capture\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8.1 (4.8.9139.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6612.json", "content": "{\n \"title\": \"The lambda parameter should be used instead of capturing arguments in \\\"ConcurrentDictionary\\\" methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6612\",\n \"sqKey\": \"S6612\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6613.html", "content": "
Both the Enumerable.First extension method and the LinkedList<T>.First property can be used to find the first value\nin a LinkedList<T>. However, LinkedList<T>.First is much faster than Enumerable.First. For small\ncollections, the performance difference may be minor, but for large collections, it can be noticeable. The same applies for the Last\nproperty as well.
Applies to:
\n\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
The First and Last properties are defined on the LinkedList class, and the extension method call can be\nreplaced by calling the propery instead.
\nint GetFirst(LinkedList<int> data) =>\n data.First();\n\n
\nint GetLast(LinkedList<int> data) =>\n data.Last();\n\n
\nint GetFirst(LinkedList<int> data) =>\n data.First.Value;\n\n
\nint GetLast(LinkedList<int> data) =>\n data.Last.Value;\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n LastMethod \n | \n \n .NET 7.0 \n | \n \n 919,577,629.0 ns \n | \n \n 44,299,688.61 ns \n | \n \n 48504 B \n | \n
| \n LastProperty \n | \n \n .NET 7.0 \n | \n \n 271.8 ns \n | \n \n 15.63 ns \n | \n \n - \n | \n
| \n LastMethod \n | \n \n .NET Framework 4.6.2 \n | \n \n 810,316,427.1 ns \n | \n \n 47,768,482.31 ns \n | \n \n 57344 B \n | \n
| \n LastProperty \n | \n \n .NET Framework 4.6.2 \n | \n \n 372.0 ns \n | \n \n 13.38 ns \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate LinkedList<int> data;\nprivate Random random = new Random();\n\n[Params(100_000)]\npublic int Size { get; set; }\n\n[Params(1_000)]\npublic int Runs { get; set; }\n\n[GlobalSetup]\npublic void Setup() =>\n data = new LinkedList<int>(Enumerable.Range(0, Size).Select(x => random.Next()));\n\n[Benchmark(Baseline = true)]\npublic void LastMethod()\n{\n for (var i = 0; i < Runs; i++)\n {\n _ = data.Last(); // Enumerable.Last()\n }\n}\n\n[Benchmark]\npublic void LastProperty()\n{\n for (var i = 0; i < Runs; i++)\n {\n _ = data.Last; // Last property\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6613.json", "content": "{\n \"title\": \"\\\"First\\\" and \\\"Last\\\" properties of \\\"LinkedList\\\" should be used instead of the \\\"First()\\\" and \\\"Last()\\\" extension methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6613\",\n \"sqKey\": \"S6613\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S6617.html", "content": "
When testing if a collection contains a specific item by simple equality, both ICollection.Contains(T item) and\nIEnumerable.Any(x ⇒ x == item) can be used. However, Any searches the data structure in a linear manner using a foreach\nloop, whereas Contains is considerably faster in some collection types, because of the underlying implementation. More specifically:
HashSet<T> is a hashtable, and therefore has an O(1) lookupSortedSet<T> is a red-black tree, and therefore has a O(logN) lookupList<T> is a linear search, and therefore has an O(N) lookup, but the EqualityComparer is optimized for the T\n type, which is not the case for AnyFor small collections, the performance difference may be negligible, but for large collections, it can be noticeable.
\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
Since LINQ to\nEntities relies a lot on System.Linq for
Contains is a method defined on the ICollection<T> interface and takes a T item argument.\nAny is an extension method defined on the IEnumerable<T> interface and takes a predicate argument. Therefore, calls\nwith simple equality checks like Any(x ⇒ x == item) can be replaced by Contains(item).
This applies to the following collection types:
\n\nbool ValueExists(HashSet<int> data) =>\n data.Any(x => x == 42);\n\n
\nbool ValueExists(List<int> data) =>\n data.Any(x => x == 42);\n\n
\nbool ValueExists(HashSet<int> data) =>\n data.Contains(42);\n\n
\nbool ValueExists(List<int> data) =>\n data.Contains(42);\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n HashSet_Any \n | \n \n .NET 7.0 \n | \n \n 35,388.333 us \n | \n \n 620.1863 us \n | \n \n 40132 B \n | \n
| \n HashSet_Contains \n | \n \n .NET 7.0 \n | \n \n 3.799 us \n | \n \n 0.1489 us \n | \n \n - \n | \n
| \n List_Any \n | \n \n .NET 7.0 \n | \n \n 32,851.509 us \n | \n \n 667.1658 us \n | \n \n 40130 B \n | \n
| \n List_Contains \n | \n \n .NET 7.0 \n | \n \n 375.132 us \n | \n \n 8.0764 us \n | \n \n - \n | \n
| \n HashSet_Any \n | \n \n .NET Framework 4.6.2 \n | \n \n 28,979.763 us \n | \n \n 678.0093 us \n | \n \n 40448 B \n | \n
| \n HashSet_Contains \n | \n \n .NET Framework 4.6.2 \n | \n \n 5.987 us \n | \n \n 0.1090 us \n | \n \n - \n | \n
| \n List_Any \n | \n \n .NET Framework 4.6.2 \n | \n \n 25,830.221 us \n | \n \n 487.2470 us \n | \n \n 40448 B \n | \n
| \n List_Contains \n | \n \n .NET Framework 4.6.2 \n | \n \n 5,935.812 us \n | \n \n 57.7569 us \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n[Params(10_000)]\npublic int SampleSize;\n\n[Params(1_000)]\npublic int Iterations;\n\nprivate static HashSet<int> hashSet;\nprivate static List<int> list;\n\n[GlobalSetup]\npublic void Setup()\n{\n hashSet = new HashSet<int>(Enumerable.Range(0, SampleSize));\n list = Enumerable.Range(0, SampleSize).ToList();\n}\n\n[Benchmark]\npublic void HashSet_Any() =>\n CheckAny(hashSet, SampleSize / 2);\n\n[Benchmark]\npublic void HashSet_Contains() =>\n CheckContains(hashSet, SampleSize / 2);\n\n[Benchmark]\npublic void List_Any() =>\n CheckAny(list, SampleSize / 2);\n\n[Benchmark]\npublic void List_Contains() =>\n CheckContains(list, SampleSize / 2);\n\nvoid CheckAny(IEnumerable<int> values, int target)\n{\n for (int i = 0; i < Iterations; i++)\n {\n _ = values.Any(x => x == target); // Enumerable.Any\n }\n}\n\nvoid CheckContains(ICollection<int> values, int target)\n{\n for (int i = 0; i < Iterations; i++)\n {\n _ = values.Contains(target); // ICollection<T>.Contains\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8.1 (4.8.9139.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/cs/S6617.json", "content": "{\n \"title\": \"\\\"Contains\\\" should be used instead of \\\"Any\\\" for simple equality checks\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6617\",\n \"sqKey\": \"S6617\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6618.html", "content": "
In order to produce a formatted string, both string.Create and either FormattableString.Invariant or\nFormattableString.CurrentCulture can be used. However, string.Create rents array buffers from\nArrayPool<char> making it more performant, as well as preventing unnecessary allocations and future stress on the Garbage\nCollector.
This applies to .NET versions after .NET 6, when these string.Create overloads were introduced.
We measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
Replace calls to FormattableString.CurrentCulture or FormattableString.Invariant with calls to\nstring.Create(CultureInfo.CurrentCulture, …) or string.Create(CultureInfo.InvariantCulture, …) respectively.
\nstring Interpolate(string value) =>\n FormattableString.Invariant($\"Value: {value}\");\n\n\nstring Interpolate(string value) =>\n FormattableString.CurrentCulture($\"Value: {value}\");\n\n\nstring Interpolate(string value) =>\n string.Create(CultureInfo.InvariantCulture, $\"Value: {value}\");\n\n\nstring Interpolate(string value) =>\n string.Create(CultureInfo.CurrentCulture, $\"Value: {value}\");\n\nThe results were generated by running the following snippet with BenchmarkDotNet:
\n| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n StringCreate \n | \n \n .NET 7.0 \n | \n \n 152.5 ms \n | \n \n 3.09 ms \n | \n \n 83.92 MB \n | \n
| \n FormattableString \n | \n \n .NET 7.0 \n | \n \n 191.8 ms \n | \n \n 6.92 ms \n | \n \n 198.36 MB \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nint Value = 42;\nDateTime Now = DateTime.UtcNow;\n\n[Params(1_000_000)]\npublic int N;\n\n[Benchmark]\npublic void StringCreate()\n{\n for (int i = 0; i < N; i++)\n {\n _ = string.Create(CultureInfo.InvariantCulture, $\"{Now}: Value is {Value}\");\n }\n}\n\n[Benchmark]\npublic void FormattableStringInvariant()\n{\n for (int i = 0; i < N; i++)\n {\n _ = FormattableString.Invariant($\"{Now}: Value is {Value}\");\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2728/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S6618.json", "content": "{\n \"title\": \"\\\"string.Create\\\" should be used instead of \\\"FormattableString\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6618\",\n \"sqKey\": \"S6618\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/cs/S6640.html", "content": "
Using unsafe code blocks can lead to unintended security or stability risks.
unsafe code blocks allow developers to use features such as pointers, fixed buffers, function calls through pointers and manual memory\nmanagement. Such features may be necessary for interoperability with native libraries, as these often require pointers. It may also increase\nperformance in some critical areas, as certain bounds checks are not executed in an unsafe context.
unsafe code blocks aren’t necessarily dangerous, however, the contents of such blocks are not verified by the Common Language Runtime.\nTherefore, it is up to the programmer to ensure that no bugs are introduced through manual memory management or casting. If not done correctly, then\nthose bugs can lead to memory corruption vulnerabilities such as stack overflows. unsafe code blocks should be used with caution because\nof these security and stability risks.
unsafe code block.There is a risk if you answered yes to the question.
\nUnless absolutely necessary, do not use unsafe code blocks. If unsafe is used to increase performance, then the
If it is not possible to remove the code block, then it should be kept as short as possible. Doing so reduces risk, as there is less code that can\npotentially introduce new bugs. Within the unsafe code block, make sure that:
\npublic unsafe int SubarraySum(int[] array, int start, int end) // Sensitive\n{\n var sum = 0;\n\n // Skip array bound checks for extra performance\n fixed (int* firstNumber = array)\n {\n for (int i = start; i < end; i++)\n sum += *(firstNumber + i);\n }\n\n return sum;\n}\n\n\npublic int SubarraySum(int[] array, int start, int end)\n{\n var sum = 0;\n\n Span<int> span = array.AsSpan();\n for (int i = start; i < end; i++)\n sum += span[i];\n\n return sum;\n}\n\nA code block should not contain too many logging statements of a specific level.
\nExcessive logging within a code block can lead to several problems:
\nOnly the logging statements that are directly within the
\nvoid MyMethod(List<MyObject> items)\n{\n logger.Debug(\"The operation started\");\n foreach(var item in items)\n {\n logger.Debug($\"Evaluating {item.Name}\");\n var result = Evaluate(item);\n logger.Debug($\"Evaluating resulted in {result}\");\n }\n logger.Debug(\"The operation ended\");\n}\n\nThe rule will count 2 logging statements that are within the method block (namely logger.Debug(\"The operation started\") and\nlogger.Debug(\"The operation ended\")). Any statements within nested blocks, such as the foreach block will be counted\nseparately. The rule considers the log level of the calls, as follows:
The most popular logging frameworks are supported:
\nReduce the number of specific logging level calls within the code block by identifying and selecting essential log statements with relevant\ninformation, necessary for understanding the flow of execution or diagnosing issues.
\nWith the default Information threshold parameter value 2:
\n\nvoid MyMethod(List<MyObject> items)\n{\n logger.Debug(\"The operation started\");\n foreach(var item in items)\n {\n logger.Information($\"Evaluating {item.Name}\"); // Noncompliant\n var result = Evaluate(item);\n logger.Information($\"Evaluating resulted in {result}\"); // Secondary 1\n if (item.Name is string.Empty)\n {\n logger.Error(\"Invalid item name\");\n }\n logger.Information(\"End item evaluation\"); // Secondary 2\n }\n logger.Debug(\"The operation ended\");\n}\n\nWith the default Information threshold parameter value 2:
\n\nvoid MyMethod(List<MyObject> items)\n{\n logger.Debug(\"The operation started\");\n foreach(var item in items)\n {\n logger.Information($\"Evaluating {item.Name}\");\n var result = Evaluate(item);\n if (item.Name is string.Empty)\n {\n logger.Error(\"Invalid item name\");\n }\n logger.Information($\"End item evaluation with result: {result}\");\n }\n logger.Debug(\"The operation ended\");\n}\n\nThis rule raises an issue on logging calls inside a catch clause that does not pass the raised Exception.
A log entry should contain all the relevant information about the current execution context. The
Logging methods provide overloads that\naccept an Exception as a parameter and logging\nproviders persist the Exception in a structured way to facilitate the tracking of system failures. Therefore Exceptions\nshould be passed to the logger.
The rule covers the following logging frameworks:
\n\npublic bool Save()\n{\n try\n {\n DoSave();\n return true;\n }\n catch(IOException)\n {\n logger.LogError(\"Saving failed.\"); // Noncompliant: No specifics about the error are logged\n return false;\n }\n}\n\n\npublic bool Save()\n{\n try\n {\n DoSave();\n return true;\n }\n catch(IOException exception)\n {\n logger.LogError(exception, \"Saving failed.\"); // Compliant: Exception details are logged\n return false;\n }\n}\n\ntry-catch statementSerilog001: Exception\n UsageMost logging frameworks have methods that take a log level, an event ID or an exception as a separate input next to the log format and its\narguments. There is a high chance that if the log level, the event ID or the exception are passed as the arguments to the message format, it was a\nmistake. This rule is going to raise in that scenario.
\nThe rule covers the following logging frameworks:
\nUse the dedicated overload that takes the log level, event id, and/or exception as arguments.
\n\ntry { }\ncatch (Exception ex)\n{\n logger.LogDebug(\"An exception occured {Exception} with {EventId}.\", ex, eventId); // Noncompliant\n}\n\n\ntry { }\ncatch (Exception ex)\n{\n logger.LogDebug(eventId, ex, \"An exception occured.\");\n}\n\nThis rule will not raise an issue if one of the parameters mentioned above is passed twice, once as a separate argument to the invocation and once\nas an argument to the message format.
\n\ntry { }\ncatch (Exception ex)\n{\n logger.LogDebug(ex, \"An exception occured {Exception}.\", ex); // Compliant\n}\n\nSharing some naming conventions is a key point to make it possible for a team to efficiently collaborate. This rule checks that the logger field or\nproperty name matches a provided regular expression.
\nThe rule supports the most popular logging frameworks:
\nUpdate the name of the field or property to follow the configured naming convention. By default, the following names are considered compliant:
\n{logger} {_logger} {Logger} {_Logger} {log} {_log} \nprivate readonly ILogger myLogger; // Noncompliant\n\npublic ILogger MyLogger { get; set; } // Noncompliant\n\n\nprivate readonly ILogger logger; // Compliant\n\npublic ILogger Logger { get; set; } // Compliant\n\nTrace.Write and
Use the Trace.TraceError,
\ntry\n{\n var message = RetrieveMessage();\n Trace.Write($\"Message received: {message}\"); // Noncompliant\n}\ncatch (Exception ex)\n{\n Trace.WriteLine(ex); // Noncompliant\n}\n\n\ntry\n{\n var message = RetrieveMessage();\n Trace.TraceInformation($\"Message received: {message}\");\n}\ncatch (Exception ex)\n{\n Trace.TraceError(ex);\n}\n\nIn most logging frameworks, it’s good practice to set the logger name to match its enclosing type, as enforced by {rule:csharpsquid:S3416}.
\nLogging frameworks can define or use Generic interfaces for the\nlogger, such as ILogger<TCategoryName>.
The use of a logger of a generic type parameter A (e.g. ILogger<A>) in a type different than A, say\nB, goes against the convention.
Because the instance of type A would log with a logger named after B, log items would appear as if they were logged by\nB instead, resulting in confusion and logging misconfiguration:
A would not take effect for entries logged in the type AA\n from entries logged in the type BFurther details and examples are provided in {rule:csharpsquid:S3416}.
\nThis rule specifically targets the generic logging interface ILogger<TCategoryName> Interface\ndefined by Microsoft Extensions Logging.
Change the generic type parameter of the ILogger interface to match the enclosing type.
\nclass EnclosingType\n{\n public EnclosingType(ILogger<AnotherType> logger) // Noncompliant\n {\n // ...\n }\n}\n\n\nclass EnclosingType\n{\n public EnclosingType(ILogger<EnclosingType> logger) // Compliant\n {\n // ...\n }\n}\n\nILogger<TCategoryName>\n InterfaceThe positions of arguments in a logging call should match the positions of their message template\nplaceholders.
\nThe placeholders of a message template are defined by their name and their position. Log methods specify\nthe values for the placeholder at runtime by passing them in a
\nlogger.LogError(\"{First} placeholder and {Second} one.\", first, second);\n\nThis rule raises an issue if the position of an argument does not match the position of the corresponding placeholder:
\n\n// 'first' and 'second' are swapped\nlogger.LogError(\"{First} placeholder and {Second} one.\", second, first);\n// ^^^^^^ ^^^^^\n\nLogging providers use placeholder names to create key/value pairs in the log entry. The key corresponds to the placeholder and the value is the\nargument passed in the log call.
\nIf the positions of the placeholder and the argument do not match, the value is associated with the wrong key. This corrupts the logs entry and\nmakes log analytics unreliable.
\nMake sure that the placeholder positions and the argument positions match. Use local variables, fields, or properties for the arguments and name\nthe placeholders accordingly.
\n'path' and 'fileName' are swapped and therefore assigned to the wrong placeholders.
\n\nlogger.LogError(\"File {FileName} not found in folder {Path}\", path, fileName);\n// ^^^^ ^^^^^^^^\n\nSwap the arguments.
\n\nlogger.LogError(\"File {FileName} not found in folder {Path}\", fileName, path);\n\n'Name' is detected but 'Folder' is not. The placeholder’s name should correspond to the name from the argument.
\n\nlogger.LogError(\"File {Name} not found in folder {Folder}\", file.DirectoryName, file.Name);\n// ^^^^\n\nSwap the arguments and rename the placeholder to 'DirectoryName'.
\n\nlogger.LogError(\"File {Name} not found in folder {DirectoryName}\", file.Name, file.DirectoryName);\n\nNot detected: A name for the arguments can not be inferred. Use locals to support detection.
\n\nlogger.LogError(\"Sum is {Sum} and product is {Product}\", x * y, x + y); // Not detected\n\nHelp detection by using arguments with a name.
\n\nvar sum = x + y;\nvar product = x * y;\nlogger.LogError(\"Sum is {Sum} and product is {Product}\", sum, product);\n\nA message template must conform to the specification. The rule raises an issue if the template string\nviolates the template string grammar.
\nA message template needs to comply with a set of rules.
The rule covers the following logging frameworks:
\nFollow the syntax described on https://messagetemplates.org/.
\n\nlogger.LogError(\"Login failed for {User\", user); // Noncompliant: Syntactically incorrect\nlogger.LogError(\"Login failed for {}\", user); // Noncompliant: Empty placeholder\nlogger.LogError(\"Login failed for {User-Name}\", user); // Noncompliant: Only letters, numbers, and underscore are allowed for placeholders\nlogger.LogDebug(\"Retry attempt {Cnt,r}\", cnt); // Noncompliant: The alignment specifier must be numeric\nlogger.LogDebug(\"Retry attempt {Cnt:}\", cnt); // Noncompliant: Empty format specifier is not allowed\n\n\nlogger.LogError(\"Login failed for {User}\", user);\nlogger.LogError(\"Login failed for {User}\", user);\nlogger.LogError(\"Login failed for {User_Name}\", user);\nlogger.LogDebug(\"Retry attempt {Cnt,-5}\", cnt);\nlogger.LogDebug(\"Retry attempt {Cnt:000}\", cnt);\n\nSerilog002:\n Message template syntax verifierThe Trace.WriteLineIf Method from the\nSystem.Diagnostic.Trace facility writes a trace if\nthe condition passed as the first parameter is true.
TraceSwitch allows trace control via\nbool properties for each relevant TraceLevel, such as TraceSwitch.TraceError.
Using Trace.WriteLineIf with such properties should be avoided since it can lead to misinterpretation and produce confusion.
In particular, Trace.WriteLineIf may appear as equivalent to the level-specific tracing methods provided by Trace, such\nas Trace.Error, but it is not.
The difference is that Trace.WriteLineIf(switch.TraceError, …) conditionally writes the trace, based on the switch, whereas\nTrace.TraceError always writes the trace, no matter whether switch.TraceError is true or\nfalse.
Moreover, unlike Trace.TraceError, Trace.WriteLineIf(switch.TraceError, …) would behave like\nTrace.WriteLine(…) when switch.TraceError is true, writing unfiltered to the underlying trace listeners and\nnot categorizing the log entry by level, as described more in detail in {rule:csharpsquid:S6670}.
The fix depends on the intent behind the use of TraceSwitch levels with Trace.WriteLineIf.
If it is trace categorization, level-specific tracing methods, such as Trace.TraceError or Trace.TraceWarning, should be used\ninstead.
If it is trace filtering, TraceSource should be used instead.
If it is log filtering, Trace should be replaced by logging APIs, such as the ILogger API.
Modern logging APIs are also more suitable than Trace when
Trace.WriteLineIf\n MethodTraceSwitchTraceSourceTrace.WriteLine\n MethodNamed placeholders in message templates should be unique. The meaning of the named placeholders is to\nstore the value of the provided argument under that name, enabling easier log querying. Since the named placeholder is used multiple times, it cannot\nstore the different values uniquely with each name hence not serving its original purpose. There can be different behaviours when using the same named\nplaceholder multiple times:
\n_indexThe rule covers the following logging frameworks:
\nAssign unique names to each template placeholder.
\n\npublic void Checkout(ILogger logger, User user, Order order)\n{\n logger.LogDebug(\"User {Id} purchased order {Id}\", user.Id, order.Id);\n}\n\n\npublic void Checkout(ILogger logger, User user, Order order)\n{\n logger.LogDebug(\"User {UserId} purchased order {OrderId}\", user.Id, order.Id);\n}\n\nSerilog005: Unique\n Property Name VerifierWithin a message template each named placeholder should be in PascalCase.
\nUsing consistent naming conventions is important for the readability and maintainability of code. In the case of message templates, using\nPascalCase for named placeholders ensures consistency with structured logging conventions, where each named placeholder is used as a property name in\nthe structured data.
\nThe rule covers the following logging frameworks:
\nUse PascalCase for named placeholders.
\n\nlogger.LogDebug(\"User {firstName} logged in\", firstName); // Noncompliant\n\n\nlogger.LogDebug(\"User {FirstName} logged in\", firstName); // Compliant\n\nSecret leaks often occur when a sensitive piece of authentication data is stored with the source code of an application. Considering the source\ncode is intended to be deployed across multiple assets, including source code repositories or application hosting servers, the secrets might get\nexposed to an unintended audience.
\nIn most cases, trust boundaries are violated when a secret is exposed in a source code repository or an uncontrolled deployment environment.\nUnintended people who don’t need to know the secret might get access to it. They might then be able to use it to gain unwanted access to associated\nservices or resources.
\nThe trust issue can be more or less severe depending on the people’s role and entitlement.
\nIf a JWT secret key leaks to an unintended audience, it can have serious security implications for the corresponding application. The secret key is\nused to encode and decode JWTs when using a symmetric signing algorithm, and an attacker could potentially use it to perform malicious actions.
\nFor example, an attacker could use the secret key to create their own authentication tokens that appear to be legitimate, allowing them to bypass\nauthentication and gain access to sensitive data or functionality.
\nIn the worst-case scenario, an attacker could be able to execute arbitrary code on the application by abusing administrative features, and take\nover its hosting server.
\nSecrets stored in appsettings.json can be read by anyone with access to the file.
\n[ApiController]\n[Route(\"login-example\")]\npublic class LoginExampleController : ControllerBase\n{\n private readonly IConfiguration _config;\n public LoginExampleController(IConfiguration config)\n {\n _config = config;\n }\n\n [HttpPost]\n public IActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var key = _config[\"Jwt:Key\"] ??\n throw new ApplicationException(\"JWT key is not configured.\");\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key)); // Noncompliant\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var Sectoken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials);\n\n var token = new JwtSecurityTokenHandler().WriteToken(Sectoken);\n return Ok(token);\n }\n}\n\nSecrets that are hard-coded into the application can be read by anyone with access to the source code or can be decompiled from the application\nbinaries.
\n\n[ApiController]\n[Route(\"login-example\")]\npublic class LoginExampleController : ControllerBase\n{\n private const string key = \"SecretSecretSecretSecretSecretSecretSecretSecret\";\n\n [HttpPost]\n public IActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key)); // Noncompliant\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var Sectoken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials);\n\n var token = new JwtSecurityTokenHandler().WriteToken(Sectoken);\n return Ok(token);\n }\n}\n\n\n[ApiController]\n[Route(\"login-example\")]\npublic class LoginExampleController : ControllerBase\n{\n [HttpPost]\n public IActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var key = Environment.GetEnvironmentVariable(\"JWT_KEY\") ??\n throw new ApplicationException(\"JWT key is not configured.\");\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var Sectoken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials);\n\n var token = new JwtSecurityTokenHandler().WriteToken(Sectoken);\n return Ok(token);\n }\n}\n\nHere, the compliant solution uses an environment variable to hold the secret. Environment variables are easy to change and are not easily\naccessible outside of the application.
\nSecret vaults provide secure methods for storing and accessing secrets. They protect against the unexpected disclosure of the secrets they\nstore.
\nMicrosoft recommends using Azure Key Vault with .NET Core applications.
\n\nvar builder = WebApplication.CreateBuilder(args);\n\n// Get the name of the key vault\nvar keyVaultName = Environment.GetEnvironmentVariable(\"AZURE_KEYVAULT\") ??\n throw new ApplicationException(\"Azure Key Vault location is not configured.\");\n// Add Azure Key Vault in the configuration\nbuilder.Configuration.AddAzureKeyVault(new Uri($\"https://{keyVaultName}.vault.azure.net/\"), new EnvironmentCredential());\n// Get the JWT secret from Azure Key Vault\nvar jwtKey = builder.Configuration.GetSection(\"JWT-KEY\").Get<string>() ??\n throw new ApplicationException(\"JWT key is not configured.\");\n\nbuilder.Services\n .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)\n .AddJwtBearer(options => {\n options.TokenValidationParameters = new TokenValidationParameters{\n IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtKey!)),\n ValidateIssuerSigningKey = true,\n ValidIssuer = \"example.com\",\n ValidateIssuer = true,\n ValidAudience = \"example.com\",\n ValidateAudience = true,\n ValidateLifetime = true,\n };\n });\n\nSecrets stored in web.config can be read by anyone with access to the file.
\npublic class LoginExampleController : ApiController\n{\n public IHttpActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var key = ConfigurationManager.AppSettings[\"key\"] ??\n throw new ApplicationException(\"JWT key is not configured.\");\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var secToken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials\n );\n\n var token = new JwtSecurityTokenHandler().WriteToken(secToken);\n return Ok(token);\n }\n}\n\nSecrets that are hard-coded into the application can be read by anyone with access to the source code or can be decompiled from the application\nbinaries.
\n\npublic class LoginExampleController : ApiController\n{\n private const string key = \"SecretSecretSecretSecretSecretSecretSecretSecret\";\n\n public IHttpActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var secToken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials\n );\n\n var token = new JwtSecurityTokenHandler().WriteToken(secToken);\n return Ok(token);\n }\n}\n\n\npublic class LoginExampleController : ApiController\n{\n public IHttpActionResult Post([FromBody] LoginModel login)\n {\n // Code to validate the login information is omitted\n\n var key = Environment.GetEnvironmentVariable(\"JWT_KEY\") ??\n throw new ApplicationException(\"JWT key is not configured.\");\n var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));\n var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);\n\n var secToken = new JwtSecurityToken(\n \"example.com\",\n \"example.com\",\n null,\n expires: DateTime.Now.AddMinutes(120),\n signingCredentials: credentials\n );\n\n var token = new JwtSecurityTokenHandler().WriteToken(secToken);\n return Ok(token);\n }\n}\n\nHere, the compliant solution uses an environment variable to hold the secret. Environment variables are easy to change and are not easily\naccessible outside of the application.
\nThe
Component parameters supplied from the query string support the following types:
\nQuery parameters should have one of the supported types. Otherwise, an unhandled exception will be raised at runtime.
\n\nUnhandled exception rendering component: Querystring values cannot be parsed as type '<type>'.\nSystem.NotSupportedException: Querystring values cannot be parsed as type '<type>'\n...\n\n
Change the parameter type to one of the following ones:
\n\n@page \"/print\"\n<p> Parameter value is: @Value </p>\n@code {\n [Parameter]\n [SupplyParameterFromQuery()]\n public TimeSpan Value { get; set; } // Noncompliant\n}\n\n\n@page \"/print\"\n<p> Parameter value is: @Value </p>\n@code {\n [Parameter]\n [SupplyParameterFromQuery()]\n public long Value { get; set; } // Compliant\n}\n\nIn Blazor, the [JSInvokable] attribute is used\nto annotate a method, enabling it to be invoked from JavaScript code. The prerequisite for this functionality is that the method must be declared as\npublic.\n
\n Otherwise, a runtime error will be triggered when an attempt is made to call the method from JavaScript.
To fix the issue, ensure the methods annotated with the [JSInvokable] attribute are public.
\n@code {\n [JSInvokable]\n private static void MyStaticMethod() { } // Noncompliant\n\n [JSInvokable]\n internal void MyMethod() { } // Noncompliant\n}\n\n\n@code {\n [JSInvokable]\n public static void MyStaticMethod() { } // Compliant\n\n [JSInvokable]\n public void MyMethod() { } // Compliant\n}\n\nIn Blazor, when a route parameter\nconstraint is applied, the value is automatically cast to the corresponding component parameter type. If the constraint type does not match the\ncomponent parameter type, it can lead to confusion and potential runtime errors due to unsuccessful casting. Therefore, it is crucial to ensure that\nthe types of route parameters and component parameters match to prevent such issues and maintain code clarity.
\nEnsure the component parameter type matches the route parameter constraint type.
\n| Constraint Type | \n.NET Type | \n
|---|---|
| \n bool \n | \n \n bool \n | \n
| \n datetime \n | \n \n DateTime \n | \n
| \n decimal \n | \n \n decimal \n | \n
| \n double \n | \n \n double \n | \n
| \n float \n | \n \n float \n | \n
| \n guid \n | \n \n Guid \n | \n
| \n int \n | \n \n int \n | \n
| \n long \n | \n \n long \n | \n
| \n string \n | \n \n string \n | \n
\n@page \"/my-route/{Param:datetime}\"\n\n@code {\n [Parameter]\n public string Param { get; set; } // Noncompliant\n}\n\n\n@page \"/my-route/{Param:datetime}\"\n\n@code {\n [Parameter]\n public DateTime Param { get; set; } // Compliant\n}\n\nIn Blazor, using lambda expressions\nas event handlers when the UI elements\nare rendered in a loop can lead to negative user experiences and performance issues. This is particularly noticeable when rendering a large number of\nelements.
\nThe reason behind this is that Blazor rebuilds all lambda expressions within the loop every time the UI elements are rendered.
\nEnsure to not use a delegate in elements rendered in loops, you can try:
\n\n@for (var i = 1; i < 100; i++)\n{\n var buttonNumber = i;\n\n <button @onclick=\"@(e => DoAction(e, buttonNumber))\"> @* Noncompliant *@\n Button #@buttonNumber\n </button>\n}\n\n@code {\n private void DoAction(MouseEventArgs e, int button)\n {\n // Do something here\n }\n}\n\n\n@foreach (var button in Buttons)\n{\n <button @key=\"button.Id\" @onclick=\"button.Action\"> @* Compliant *@\n Button #@button.Id\n </button>\n}\n\n@code {\n private List<Button> Buttons { get; set; } = new();\n\n protected override void OnInitialized()\n {\n for (var i = 0; i < 100; i++)\n {\n var button = new Button();\n\n button.Action = (e) => DoAction(e, button);\n\n Buttons.Add(button);\n }\n }\n\n private void DoAction(MouseEventArgs e, Button button)\n {\n // Do something here\n }\n\n private class Button\n {\n public string? Id { get; } = Guid.NewGuid().ToString();\n public Action<MouseEventArgs> Action { get; set; } = e => { };\n }\n}\n\n\n@* Component.razor *@\n\n@for (var i = 1; i < 100; i++)\n{\n var buttonNumber = i;\n\n <button @onclick=\"@(e => DoAction(e, buttonNumber))\"> @* Noncompliant *@\n Button #@buttonNumber\n </button>\n}\n\n@code {\n private void DoAction(MouseEventArgs e, int button)\n {\n // Do something here\n }\n}\n\n\n@* MyButton.razor *@\n\n<button @onclick=\"OnClickCallback\">\n @ChildContent\n</button>\n\n@code {\n [Parameter]\n public int Id { get; set; }\n\n [Parameter]\n public EventCallback<int> OnClick { get; set; }\n\n [Parameter]\n public RenderFragment ChildContent { get; set; }\n\n private void OnClickCallback()\n {\n OnClick.InvokeAsync(Id);\n }\n}\n\n@* Component.razor *@\n\n@for (var i = 1; i < 100; i++)\n{\n var buttonNumber = i;\n <MyButton Id=\"buttonNumber\" OnClick=\"DoAction\">\n Button #@buttonNumber\n </MyButton>\n}\n\n@code {\n private void DoAction(int button)\n {\n // Do something here\n }\n}\n\nThe results were generated with the help of BenchmarkDotNet and
| Method | \nNbButtonRendered | \nMean | \nStdDev | \nRatio | \n
|---|---|---|---|---|
| \n UseDelegate \n | \n \n 10 \n | \n \n 6.603 us \n | \n \n 0.0483 us \n | \n \n 1.00 \n | \n
| \n UseAction \n | \n \n 10 \n | \n \n 1.994 us \n | \n \n 0.0592 us \n | \n \n 0.29 \n | \n
| \n UseDelegate \n | \n \n 100 \n | \n \n 50.666 us \n | \n \n 0.5449 us \n | \n \n 1.00 \n | \n
| \n UseAction \n | \n \n 100 \n | \n \n 2.016 us \n | \n \n 0.0346 us \n | \n \n 0.04 \n | \n
| \n UseDelegate \n | \n \n 1000 \n | \n \n 512.513 us \n | \n \n 9.7561 us \n | \n \n 1.000 \n | \n
| \n UseAction \n | \n \n 1000 \n | \n \n 2.005 us \n | \n \n 0.0243 us \n | \n \n 0.004 \n | \n
Hardware configuration:
\n\nBenchmarkDotNet v0.13.9+228a464e8be6c580ad9408e98f18813f6407fb5a, Windows 10 (10.0.19045.3448/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n.NET SDK 8.0.100-rc.1.23463.5\n [Host] : .NET 7.0.11 (7.0.1123.42427), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.11 (7.0.1123.42427), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/cs/S6802.json", "content": "{\n \"title\": \"Using lambda expressions in loops should be avoided in Blazor markup section\",\n \"type\": \"CODE_SMELL\",\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1h\"\n },\n \"tags\": [\n \"blazor\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-6802\",\n \"sqKey\": \"S6802\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"EFFICIENT\"\n }\n}\n" }, { "path": "analyzers/rspec/cs/S6803.html", "content": "
This rule is deprecated, and will eventually be removed.
\nComponent parameters can only receive query parameter values in routable components with an @page directive.
\nIn the case of non-routable components, the SupplyParameterFromQuery does not contribute to the functionality, and removing it will\nnot affect the behavior.
Either make the component routable or remove the SupplyParameterFromQuery attribute.
\n<h3>Component</h3>\n\n@code {\n [Parameter]\n [SupplyParameterFromQuery] // Noncompliant\n public bool Param { get; set; }\n}\n\n\n@page \"/component\"\n\n<h3>Component</h3>\n\n@code {\n [Parameter]\n [SupplyParameterFromQuery] // Compliant\n public bool Param { get; set; }\n}\n\nBackslash characters (\\) should be avoided in
Routing in ASP.NET MVC maps
In the former syntax specification of URIs, backslash characters (\\) were not allowed at all (see
For instance, a backslash in the \"path\" part of a /) both by Chrome and Internet\nExplorer (see here).
As an example, \\Calculator\\Evaluate?expression=3\\4 is converted on the fly into /Calculator/Evaluate?expression=3\\4\nbefore the HTTP request is made to the server.
While backslashes are allowed in the \"query\" part of a URL, and it’s common to have them as part of a complex query expression, the route of a\ncontroller is always part of the \"path\".
\nThat is why the use of backslashes in controller templates should be avoided in general.
\nA backslash in the route pattern of a controller would only make sense if the developer intended the backslash in the route to be explicitly\nescaped by the user, using %5C.
For example, the route Something\\[controller] for the HomeController would need to be called as\nSomething%5CHome.
The validity of such a scenario is unlikely and the resulting behavior is surprising.
\n\n[Route(@\"Something\\[controller]\")] // Noncompliant: Replace '\\' with '/'.\npublic class HomeController : Controller\n{\n [HttpGet]\n public ActionResult Index() => View();\n}\n\n\n[Route(@\"Something/[controller]\")] // '\\' replaced with '/'\npublic class HomeController : Controller\n{\n [HttpGet]\n public ActionResult Index() => View();\n}\n\n\napp.MapControllerRoute(\n name: \"default\",\n pattern: \"{controller=Home}\\\\{action=Index}\"); // Noncompliant: Replace '\\' with '/'.\n\n\napp.MapControllerRoute(\n name: \"default\",\n pattern: \"{controller=Home}/{action=Index}\"); // '\\' replaced with '/'\n\nRoute templates for ASP.NET controller\nactions, defined via a RouteAttribute or any derivation of HttpMethodAttribute, should\nnot start with \"/\".
Routing in ASP.NET Core MVC maps
In ASP.NET Core MVC, when an action defines a route template starting with a \"/\", the route is considered absolute and the action is registered at\nthe root of the web application.
\nIn such a scenario, any route defined at the controller level is disregarded, as shown in the following example:
\n\n[Route(\"[controller]\")] // This route is ignored for the routing of Index1 and Index2\npublic class HomeController : Controller\n{\n [HttpGet(\"/Index1\")] // This action is mapped to the root of the web application\n public ActionResult Index1() => View();\n\n [Route(\"/Index2\")] // The same applies here\n public ActionResult Index2() => View();\n}\n\nThe behavior can be found confusing and surprising because any relative action route is relativized to the controller route.
\nTherefore, in the vast majority of scenarios, controllers group all related actions not only in the source code, but also at the routing level.
\nIn ASP.NET Framework MVC with attribute routing enabled via MapMvcAttributeRoutes,\nthe mere presence of an absolute route at the action level will produce an InvalidOperationException at runtime.
It is then a good practice to avoid absolute routing at the action level and move the \"/\" to the root level, changing the template defined in the\nRouteAttribute of the controller appropriately.
The rule only applies when all route templates of all actions of the controller start with \"/\". Sometimes some actions may have both relative and\nabsolute route templates, for example for backward compatibility reasons (i.e. a former route needs to be preserved). In such scenarios, it may make\nsense to keep the absolute route template at the action level.
\n\n[Route(\"[controller]\")] // This route is ignored\npublic class ReviewsController : Controller // Noncompliant\n{\n // Route is /reviews\n [HttpGet(\"/reviews\")]\n public ActionResult Index() { /* ... */ }\n\n // Route is /reviews/{reviewId}\n [Route(\"/reviews/{reviewId}\")]\n public ActionResult Show(int reviewId)() { /* ... */ }\n}\n\n\n[Route(\"/\")] // Turns on attribute routing\npublic class ReviewsController : Controller\n{\n // Route is /reviews\n [HttpGet(\"reviews\")]\n public ActionResult Index() { /* ... */ }\n\n // Route is /reviews/{reviewId}\n [Route(\"reviews/{reviewId}\")]\n public ActionResult Show(int reviewId)() { /* ... */ }\n}\n\nThe HttpRequest class provides access to the raw request data through the QueryString, Headers, and\nForms properties. However, whenever possible it is recommended to use model binding instead of directly accessing the input data.
Both ASP.Net MVC implementations - Core and
Model binding simplifies the code by automatically mapping data from HTTP requests to action method parameters. You don’t need to write any\n code to manually extract values from the request.
\nModel binding provides type safety by automatically converting the incoming data into the appropriate .NET types. If the conversion fails, the\n model state becomes invalid, which you can easily check using ModelState.IsValid.
With model binding, you can easily apply validation rules to your models using data annotations. If the incoming data doesn’t comply with these\n rules, the model state becomes invalid.
\nModel binding helps protect against over-posting attacks by only including properties in the model that you explicitly bind using the\n [Bind] attribute or by using view models that only contain the properties you want to update.
By using model binding, your code becomes cleaner, easier to read, and maintain. It promotes the use of strongly typed views, which can provide\n compile-time checking of your views.
\nRequest.Form, Request.Form.Files, Request.Headers, Request.Query and Request.RouteValues are keyed\ncollections that expose data from the incoming HTTP request:
Request.Form - application/x-www-form-urlencoded form data from the HTTP request bodyRequest.Form.Files - multipart/form-data file data from the HTTP request bodyRequest.Headers - HTTP Header valuesRequest.Query - Request.RouteValues - Values extracted from the Model binding can bind these keyed collections to
\nTo replace the keyed collection access, you can:
\n| Replace | \nwith parameter binding | \nor complex type binding | \nor route binding | \n
|---|---|---|---|
| \n
| \n \n optional | \n \n optional | \n \n |
| \n
| \n \n
| \n \n | \n |
| \n | \n \n
| \n \n
| \n \n |
| \n
| \n \n optional | \n \n optional | \n \n |
| \n | \n \n optional | \n \n | \n optional | \n
The Model Binding in ASP.NET Core article describes the\nmechanisms, conventions, and customization options for model binding in more detail. Route-based binding is described in the
\npublic IActionResult Post()\n{\n var name = Request.Form[\"name\"]; // Noncompliant: Request.Form\n var birthdate = DateTime.Parse(Request.Form[\"Birthdate\"]); // Noncompliant: Request.Form\n\n var locale = Request.Query.TryGetValue(\"locale\", out var locales)\n ? locales.ToString()\n : \"en-US\"; // Noncompliant: Request.Query\n // ..\n}\n\n\npublic record User\n{\n [Required, StringLength(100)]\n public required string Name { get; init; }\n [DataType(DataType.Date)]\n public DateTime? Birthdate { get; init; }\n}\n\npublic IActionResult Post(User user, [FromHeader] string origin, [FromQuery] string locale = \"en-US\")\n{\n if (ModelState.IsValid)\n {\n // ...\n }\n}\n\nModel binding in ASP.NET Core MVC and ASP.NET MVC 4.x works by automatically mapping data from HTTP requests to action method parameters. Here’s a\nstep-by-step breakdown of how it works:
\nModelState.Errors collection. You can check ModelState.IsValid in your action method to see if any\n errors occurred during model binding.ModelState.IsValid is\n false, you can handle the errors in your action method and return an appropriate response.See the links in the Resources section for more information.
\nRequest.Form and Request.QueryString are keyed collections\nthat expose data from the incoming HTTP request:
Request.Form - application/x-www-form-urlencoded form data from the HTTP request bodyRequest.QueryString - Model binding can bind these keyed collections to
\nTo replace the keyed collection access, you can:
\n| Replace | \nwith parameter binding | \nor complex type binding | \n
|---|---|---|
| \n
| \n \n optional | \n \n optional | \n
| \n | \n \n optional | \n \n property name must match query parameter key \n | \n
\npublic ActionResult Post()\n{\n var name = Request.Form[\"name\"]; // Noncompliant: Request.Form\n Debug.WriteLine(Request.Form[0]); // Compliant: Binding by index is not supported.\n var birthdate = DateTime.Parse(Request.Form[\"Birthdate\"]); // Noncompliant: Request.Form\n\n var cultureName = Request.QueryString[\"locale\"] ?? \"en-US\"; // Noncompliant: Request.QueryString\n // ..\n}\n\n\npublic class User\n{\n [Required, StringLength(100)]\n public string Name { get; set; }\n [DataType(DataType.Date)]\n public DateTime? Birthdate { get; set; }\n}\n\npublic ActionResult Post(User user, [Bind(Prefix = \"locale\")] string cultureName = \"en-US\")\n{\n if (ModelState.IsValid)\n {\n // ...\n }\n}\n\npublic IActionResult Post()\n{\n var origin = Request.Headers[HeaderNames.Origin]; // Compliant: Access via non-constant field\n var nameField = \"name\";\n var name = Request.Form[nameField]; // Compliant: Access via local\n var birthdate = DateTime.Parse(Request.Form[\"Birthdate\"]); // Compliant: Access via constant and variable keys is mixed.\n // Model binding would only work partially in the method, so we do not raise here.\n return Ok();\n // ..\n}\n\nModel binding in ASP.NET Core MVC and ASP.NET MVC 4.x works by automatically mapping data from HTTP requests to action method parameters. Here’s a\nstep-by-step breakdown of how it works:
\nModelState.Errors collection. You can check ModelState.IsValid in your action method to see if any\n errors occurred during model binding.ModelState.IsValid is\n false, you can handle the errors in your action method and return an appropriate response.See the links in the Resources section for more information.
\nWhen a route template is defined through an attribute on an action method, conventional routing for that action is disabled. To maintain good\npractice, it’s recommended not to combine conventional and attribute-based routing within a single controller to avoid unpredicted behavior. As such,\nthe controller should exclude itself from conventional routing by applying a [Route] attribute.
In ASP.NET Core MVC, the MapControllerRoute\nmethod. This method is typically configured in one central location for all controllers during the application setup.
Conversely, attribute routing allows routes to be defined at the controller or action method level. It is possible to
\n// Conventional mapping definition\napp.MapControllerRoute(\n name: \"default\",\n pattern: \"{controller=Home}/{action=Index}/{id?}\");\n\npublic class PersonController\n{\n // Conventional routing:\n // Matches e.g. /Person/Index/123\n public IActionResult Index(int? id) => View();\n\n // Attribute routing:\n // Matches e.g. /Age/Ascending (and model binds \"Age\" to sortBy and \"Ascending\" to direction)\n // but does not match /Person/List/Age/Ascending\n [HttpGet(template: \"{sortBy}/{direction}\")]\n public IActionResult List(string sortBy, SortOrder direction) => View();\n}\n\nWhen any of the controller actions are annotated with a HttpMethodAttribute with a\nroute template defined, you should specify a route template on the controller with the RouteAttribute as well.
\npublic class PersonController : Controller\n{\n // Matches /Person/Index/123\n public IActionResult Index(int? id) => View();\n\n // Matches /Age/Ascending\n [HttpGet(template: \"{sortBy}/{direction}\")] // Noncompliant: The \"Index\" and the \"List\" actions are\n // reachable via different routing mechanisms and routes\n public IActionResult List(string sortBy, SortOrder direction) => View();\n}\n\n\n[Route(\"[controller]/{action=Index}\")]\npublic class PersonController : Controller\n{\n // Matches /Person/Index/123\n [Route(\"{id?}\")]\n public IActionResult Index(int? id) => View();\n\n // Matches Person/List/Age/Ascending\n [HttpGet(\"{sortBy}/{direction}\")] // Compliant: The route is relative to the controller\n public IActionResult List(string sortBy, SortOrder direction) => View();\n}\n\nThere are also alternative options to prevent the mixing of conventional and attribute-based routing:
\n\n// Option 1. Replace the attribute-based routing with a conventional route\napp.MapControllerRoute(\n name: \"Lists\",\n pattern: \"{controller}/List/{sortBy}/{direction}\",\n defaults: new { action = \"List\" } ); // Matches Person/List/Age/Ascending\n\n// Option 2. Use a binding, that does not depend on route templates\npublic class PersonController : Controller\n{\n // Matches Person/List?sortBy=Age&direction=Ascending\n [HttpGet] // Compliant: Parameters are bound from the query string\n public IActionResult List(string sortBy, SortOrder direction) => View();\n}\n\n// Option 3. Use an absolute route\npublic class PersonController : Controller\n{\n // Matches Person/List/Age/Ascending\n [HttpGet(\"/[controller]/[action]/{sortBy}/{direction}\")] // Illustrate the expected route by starting with \"/\"\n public IActionResult List(string sortBy, SortOrder direction) => View();\n}\n\nASP.NET controllers should not have mixed responsibilities.\nFollowing the Single Responsibility Principle (SRP), they should be kept\nlean and focused\non a single, separate concern. In short, they should have a single reason to change.
\nThe rule identifies different responsibilities by looking at groups of actions that use different sets of services defined in the controller.
\nBasic services that are typically required by most controllers are not considered:
\nILoggerIMediatorIMapperIConfigurationIBusIMessageBusThe rule currently applies to ASP.NET Core only, and doesn’t cover
It also only takes into account web APIs controllers, i.e. the ones marked with the ApiController attribute. MVC controllers are\nnot in scope.
Multiple issues can appear when the Single Responsibility Principle (SRP) is violated.
\nA controller violating SRP is harder to read and understand since its Cognitive Complexity is generally above average (see\n{rule:csharpsquid:S3776}).
\nFor example, a controller MediaController that is in charge of both the \"movies\" and \"photos\" APIs would need to define all the\nactions dealing with movies, alongside the ones dealing with photos, all defined in the same controller class.
The alternative is to define two controllers: a MovieController and a PhotoController, each in charge of a smaller\nnumber of actions.
Such complexity makes the controller harder to maintain and modify, slowing down new development and
For example, a change in MediaController made for the movies APIs may inadvertently have an impact on the photos APIs as well.\nBecause the change was made in the context of movies, tests on photos may be overlooked, resulting in bugs in production.
That would not be likely to happen when two distinct controllers, MovieController and a PhotoController, are\ndefined.
The controller also becomes harder to test since the test suite would need to define a set of tests for each of the\nresponsibilities of the controller, resulting in a large and complex test suite.
\nFor example, the MediaController introduced above would need to be tested on all movies-related actions, as well as on all\nphotos-related actions.
All those tests would be defined in the same test suite for MediaController, which would be affected by the same issues of\ncognitive complexity as the controller under test by the suite.
A controller that has multiple responsibilities is less likely to be reusable. Lack of reuse can result in code duplication.
\nFor example, when a new controller wants to derive from an existing one, it’s less probable that the new controller requires all the behaviors\nexposed by the reused controller.
\nRather, it’s much more common that the new controller only needs to reuse a fraction of the existing one. When reuse is not possible, the only\nvalid alternative is to duplicate part of the logic in the new controller.
\nA controller that has multiple responsibilities may end up doing more than strictly necessary, resulting in a higher likelihood of\nperformance issues.
\nTo understand why, it’s important to consider the difference between ASP.NET application vs non-ASP.NET applications.
\nIn a non-ASP.NET application, controllers may be defined as Singletons via a
In such a scenario, they would typically be instantiated only once, lazily or eagerly, at application startup.
\nIn ASP.NET applications, however, the default is that controllers are instantiated as many times as the number of requests that are served by\nthe web server. Each instance of the controller would need to resolve services independently.
\nWhile service instantiation is typically handled at application startup, service resolution happens every time an\ninstance of controller needs to be built, for each service declared in the controller.
\nWhether the resolution is done via Dependency Injection, direct static access (in the case of a Singleton), or a
For example, the movies-related APIs of the MediaController mentioned above may require the instantiation of an\nIStreamingService, typically done via
Similarly, some of the photos-related APIs may require the instantiation of an IRedEyeRemovalService, which may not work at all\nwith movies.
Having a single controller would force the developer to deal with both instantiations, even though a given instance of the controller may be\nused only for photos, or only for movies.
\nA controller that deals with multiple concerns often has unnecessarily complex routing: the route template at controller level cannot factorize the\nroute identifying the concern, so the full route template needs to be defined at the action level.
\nFor example, the MediaController would have an empty route (or equivalent, e.g. / or ~/) and the actions\nwould need to define themselves the movie or photo prefix, depending on the type of media they deal with.
On the other hand, MovieController and PhotoController can factorize the movie and photo\nroute respectively, so that the route on the action would only contain action-specific information.
As the size and the responsibilities of the controller increase, the issues that come with such an increase will have a further impact on the\ncode.
\nAlongside attribute\nrouting, which is typical of web APIs, MVC controllers also come with [conventional routing].
\nIn MVC, the file structure of controllers is important, since it drives
For those reasons, splitting an MVC controller into smaller pieces may break core behaviors of the web application such as routing and views,\ntriggering a large refactor of the whole project.
\nSplit the controller into multiple controllers, each dealing with a single responsibility.
\n\n[Route(\"media\")]\npublic class MediaController( // Noncompliant: This controller has multiple responsibilities and could be split into 2 smaller units.\n // Used by all actions\n ILogger<MediaController> logger,\n // Movie-specific dependencies\n IStreamingService streamingService, ISubtitlesService subtitlesService,\n // Photo-specific dependencies\n IRedEyeRemovalService redEyeRemovalService, IPhotoEnhancementService photoEnhancementService) : Controller\n{\n [Route(\"movie/stream\")]\n public IActionResult MovieStream([FromQuery] StreamRequest request) // Belongs to responsibility #1.\n {\n logger.LogInformation(\"Requesting movie stream for {MovieId}\", request.MovieId);\n return File(streamingService.GetStream(request.MovieId), \"video/mp4\");\n }\n\n [Route(\"movie/subtitles\")]\n public IActionResult MovieSubtitles([FromQuery] SubtitlesRequest request) // Belongs to responsibility #1.\n {\n logger.LogInformation(\"Requesting movie subtitles for {MovieId}\", request.MovieId);\n return File(subtitlesService.GetSubtitles(request.MovieId, request.Language), \"text/vtt\");\n }\n\n [Route(\"photo/remove-red-eye\")]\n public IActionResult RemoveRedEye([FromQuery] RedEyeRemovalRequest request) // Belongs to responsibility #2.\n {\n logger.LogInformation(\"Removing red-eye from photo {PhotoId}\", request.PhotoId);\n return File(redEyeRemovalService.RemoveRedEye(request.PhotoId, request.Sensitivity), \"image/jpeg\");\n }\n\n [Route(\"photo/enhance\")]\n public IActionResult EnhancePhoto([FromQuery] PhotoEnhancementRequest request) // Belongs to responsibility #2.\n {\n logger.LogInformation(\"Enhancing photo {PhotoId}\", request.PhotoId);\n return File(photoEnhancementService.EnhancePhoto(request.PhotoId, request.ColorGrading), \"image/jpeg\");\n }\n}\n\n\n[Route(\"media/[controller]\")]\npublic class MovieController(\n ILogger<MovieController> logger,\n IStreamingService streamingService, ISubtitlesService subtitlesService) : Controller\n{\n [Route(\"stream\")]\n public IActionResult MovieStream([FromQuery] StreamRequest request)\n {\n logger.LogInformation(\"Requesting movie stream for {MovieId}\", request.MovieId);\n return File(streamingService.GetStream(request.MovieId), \"video/mp4\");\n }\n\n [Route(\"subtitles\")]\n public IActionResult MovieSubtitles([FromQuery] SubtitlesRequest request)\n {\n logger.LogInformation(\"Requesting movie subtitles for {MovieId}\", request.MovieId);\n return File(subtitlesService.GetSubtitles(request.MovieId, request.Language), \"text/vtt\");\n }\n}\n\n[Route(\"media/[controller]\")]\npublic class PhotoController(\n ILogger<PhotoController> logger,\n IRedEyeRemovalService redEyeRemovalService, IPhotoEnhancementService photoEnhancementService) : Controller\n{\n [Route(\"remove-red-eye\")]\n public IActionResult RemoveRedEye([FromQuery] RedEyeRemovalRequest request)\n {\n logger.LogInformation(\"Removing red-eye from photo {PhotoId}\", request.PhotoId);\n return File(redEyeRemovalService.RemoveRedEye(request.PhotoId, request.Sensitivity), \"image/jpeg\");\n }\n\n [Route(\"enhance\")]\n public IActionResult EnhancePhoto([FromQuery] PhotoEnhancementRequest request)\n {\n logger.LogInformation(\"Enhancing photo {PhotoId}\", request.PhotoId);\n return File(photoEnhancementService.EnhancePhoto(request.PhotoId, request.ColorGrading), \"image/jpeg\");\n }\n}\n\nApiController attributeIn ASP.NET Core, controllers usually inherit either from ControllerBase or Controller. If a controller does not use any\nView-specific functionality, it is recommended to inherit from ControllerBase.
The ControllerBase class contains all the necessary functionality to handle API\nrequests and responses. The Controller class inherits from ControllerBase and adds support for
Inheriting from Controller when not using any View-specific functionality exposes unnecessary methods and can lead to confusion about\nthe intention of the class.
Furthermore, inheriting from Controller may come with a performance cost. Even though the controller might only deal with API\noperations, the support for Views might introduce some overhead from the MVC framework during the
An issue is raised when:
\n[ApiController] attribute.Controller.[NonController] attribute.Change the base type of the controller from Controller to ControllerBase.
\n[ApiController]\npublic class MyController : Controller // Noncompliant: Inherit from ControllerBase instead of Controller.\n// ^^^^^^^^^^\n{\n // ..\n}\n\n\n[ApiController]\npublic class MyController : ControllerBase\n{\n // ..\n}\n\nIn frequently used code paths, such as controller actions, you should avoid using the
If a code path that creates and disposes of HttpClient objects is frequently used, then the following issues can occur:
\nThe IHttpClientFactory was introduced in\nASP.NET Core 2.1 to solve these problems. It handles pooling HTTP connections to optimize performance and reliability.
There are several ways that you can use\nIHttpClientFactory in your application:
\nAlternatively, you may cache the HttpClient in a singleton or a static field. You should be aware that by default, the HttpClient doesn’t respect\nthe DNS’s Time To Live (TTL) settings. If the IP address associated with a domain name changes, HttpClient might still use the old, cached IP address,\nleading to failed requests.
\n\n[ApiController]\n[Route(\"controller\")]\npublic class FooController : Controller\n{\n [HttpGet]\n public async Task<string> Foo()\n {\n using var client = new HttpClient(); // Noncompliant\n return await client.GetStringAsync(_url);\n }\n}\n\n\n// File: Startup.cs\npublic class Startup\n{\n public void ConfigureServices(IServiceCollection services)\n {\n services.AddHttpClient();\n // ...\n }\n}\n\n[ApiController]\n[Route(\"controller\")]\npublic class FooController : Controller\n{\n private readonly IHttpClientFactory _clientFactory;\n\n public FooController(IHttpClientFactory clientFactory)\n {\n _clientFactory = clientFactory;\n }\n\n [HttpGet]\n public async Task<string> Foo()\n {\n using var client = _clientFactory.CreateClient(); // Compliant (Basic usage)\n return await client.GetStringAsync(_url);\n }\n}\n\nOne of the main issues that under-posting can cause is data inconsistency. If the client sends less data than expected, the application might fill\nany value type properties with their default values, leading to inaccurate or inconsistent data in your database. Additionally, there might be\nunexpected behavior if there are certain data expected that are not provided and even security issues; for example, if a user omits a role or\npermission field from a POST request, and the server fills in a default value, it could inadvertently grant more access than intended.
\nA model class (in this case the\nProduct class) can be an input of an HTTP handler method:
\npublic class ProductsController : Controller\n{\n [HttpPost]\n public IActionResult Create([FromBody]Product product)\n {\n // Process product data...\n }\n}\n\nThis rule does not raise an issue when properties are decorated with the following attributes:
\nAdditionally, this rule does not raise for properties in model classes that are not in the same project as the Controller class that references\nthem. This is due to a limitation of Roslyn (see here).
\nYou should mark any model value-type property as
\npublic class Product\n{\n public int Id { get; set; } // Noncompliant\n public string Name { get; set; }\n public int NumberOfItems { get; set; } // Noncompliant\n public decimal Price { get; set; } // Noncompliant\n}\n\nIf the client sends a request without setting the NumberOfItems or Price properties, they will default to 0.\nIn the request handler method, there’s no way to determine whether they were intentionally set to 0 or omitted by mistake.
\npublic class Product\n{\n public required int Id { get; set; }\n public string Name { get; set; }\n public int? NumberOfItems { get; set; } // Compliant - property is optional\n [JsonRequired] public decimal Price { get; set; } // Compliant - property must have a value\n}\n\nIn this example, the request handler method can
\nNumberOfItems was filled out through the HasValue propertyPrice is not missing\npublic class ProductsController : Controller\n{\n [HttpPost]\n public IActionResult Create(Product product)\n {\n if (!ModelState.IsValid) // if product.Price is missing then the model state will not be valid\n {\n return View(product);\n }\n\n if (product.NumberOfItems.HasValue)\n {\n // ...\n }\n // Process input...\n }\n}\n\nWhen building a REST API,
You should annotate the controller actions with the available HttpMethod attributes. You can still use them in conjunction with the Route\nattribute, in case there are multiple templates for one action and you need to
This rule does not raise if the controller or the action is annotated with [ or AcceptsVerbs\nattribute.
\n[Route(\"Customer\")] // This route conflicts with GetCustomers action route\npublic async Task<IResult> ChangeCustomer([FromBody] CustomerData data) // Noncompliant\n{\n // ...\n return Results.Ok();\n}\n\n[Route(\"Customer\")] // This route conflicts with ChangeCustomer action route\npublic async Task<string> GetCustomers() // Noncompliant\n{\n return _customerRepository.GetAll();\n}\n\n\n[Route(\"Customer\")]\n[HttpPost]\npublic async Task<IResult> ChangeCustomer([FromBody] CustomerData data) // Compliant\n{\n // ...\n return Results.Ok();\n}\n\n[HttpGet(\"Customer\")]\npublic async Task<string> GetCustomers() // Compliant\n{\n return _customerRepository.GetAll();\n}\n\nIn an async method, any blocking operations should be avoided.
Using a synchronous method instead of its asynchronous\ncounterpart in an async method blocks the execution and is considered bad practice for several reasons:
Each thread consumes system resources, such as memory. When a thread is blocked, it’s not doing any useful work, but it’s still consuming these\n resources. This can lead to inefficient use of system resources.
\nBlocking threads can limit the scalability of your application. In a high-load scenario where many operations are happening concurrently, each\n blocked thread represents a missed opportunity to do useful work. This can prevent your application from effectively handling increased load.
\nBlocking threads can degrade the performance of your application. If all threads in the thread pool become blocked, new tasks can’t start\n executing until an existing task completes and frees up a thread. This can lead to delays and poor responsiveness.
\nInstead of blocking, it’s recommended to use the async operator with async methods. This\nallows the system to release the current thread back to the thread pool until the awaited task is complete, improving scalability and\nresponsiveness.
\npublic async Task Examples(Stream stream, DbSet<Person> dbSet)\n{\n stream.Read(array, 0, 1024); // Noncompliant\n File.ReadAllLines(\"path\"); // Noncompliant\n dbSet.ToList(); // Noncompliant in Entity Framework Core queries\n dbSet.FirstOrDefault(x => x.Age >= 18); // Noncompliant in Entity Framework Core queries\n}\n\n\npublic async Task Examples(Stream stream, DbSet<Person> dbSet)\n{\n await stream.ReadAsync(array, 0, 1024);\n await File.ReadAllLinesAsync(\"path\");\n await dbSet.ToListAsync();\n await dbSet.FirstOrDefaultAsync(x => x.Age >= 18);\n}\n\nIn the context of ASP.NET Core MVC web applications, both model binding and model validation are processes that take place prior to the execution\nof a controller action. It is imperative for the application to examine the ModelState.IsValid and respond accordingly.
This rule enforces the developer to validate the model within a controller action, ensuring the application’s robustness and reliability.
\nQuerying the ModelState.IsValid property is necessary because it checks if the submitted data in the HTTP request is valid or not.\nThis property evaluates all the validation attributes applied on your model properties and determines whether the data provided satisfies those\nvalidation rules.
Skipping model validation can lead to:
\nTherefore, it’s highly recommended to always validate models in your application to ensure data integrity, application stability, and a good user\nexperience.
\nWhile client-side validation enhances user experience by providing immediate feedback, it’s not sufficient due to potential manipulation of\nclient-side code, browser compatibility issues, and dependence on JavaScript. Users can bypass or disable it, leading to invalid or malicious data\nbeing submitted. Therefore, server-side validation is essential to ensure data integrity and security, making it a best practice to use both\nclient-side and server-side validation in your application.
\nModelState.IsValid if they have the [ApiController] attribute. In that case,\n an automatic HTTP 400 response containing error details is returned when model state is invalid.TryValidateModel can also be used for model validation.If ModelState.IsValid returns true, it means that the data is valid and the process can continue. If it returns false, it means that\nthe validation failed, indicating that the data is not in the expected format or is missing required information.
In such cases, the controller action should handle this by returning an appropriate response, such as re-displaying the form with error messages.\nThis helps maintain the integrity of the data and provides feedback to the user, enhancing the overall user experience and security of your\napplication.
\n\npublic async Task<IActionResult> Create(Movie movie) // Noncompliant: model validity check is missing\n{\n _context.Movies.Add(movie);\n await _context.SaveChangesAsync();\n\n return RedirectToAction(nameof(Index));\n}\n\n\npublic async Task<IActionResult> Create(Movie movie)\n{\n if (!ModelState.IsValid)\n {\n return View(movie);\n }\n\n _context.Movies.Add(movie);\n await _context.SaveChangesAsync();\n\n return RedirectToAction(nameof(Index));\n}\n\nIn an ASP.NET Core Web API,\ncontroller actions can optionally return a result value. If a controller action returns a value in the [ProducesResponseType]\noverloads that describe the type is recommended.
If an ASP.NET Core Web API uses Swagger, the API documentation will be generated based on the input/output types\nof the controller actions, as well as the attributes annotating the actions. If an action returns
This rule raises an issue on a controller action when:
\n[ProducesResponseType] attribute containing the return type, either at controller or action level.[SwaggerResponse] attribute containing the return type, either at controller or action level.[ApiController] attribute.There are multiple ways to fix this issue:
\n[ProducesResponseType]\n containing the return type.[IActionResult] or [IResult].[IActionResult] or [IResult].\n[HttpGet(\"foo\")]\n// Noncompliant: Annotate this method with ProducesResponseType containing the return type for succesful responses.\npublic IActionResult MagicNumber() => Ok(42);\n\n
\n[HttpGet(\"foo\")]\n// Noncompliant: Use the ProducesResponseType overload containing the return type for succesful responses.\n[ProducesResponseType(StatusCodes.Status200OK)]\npublic IActionResult MagicNumber() => Ok(42);\n\n
\n[HttpGet(\"foo\")]\n[ProducesResponseType<int>(StatusCodes.Status200OK)]\npublic IActionResult MagicNumber() => Ok(42);\n\n
\n[HttpGet(\"foo\")]\n[ProducesResponseType(typeof(int), StatusCodes.Status200OK)]\npublic IActionResult MagicNumber() => Ok(42);\n\n
The Content Security Policy (CSP) is a computer security standard that serves as an additional layer of protection against various types of\nattacks, including Cross-Site Scripting (XSS) and clickjacking. It provides a set of standard procedures for loading resources by user agents, which\ncan help to mitigate the risk of content injection vulnerabilities.
\nHowever, it is important to note that CSP is not a primary line of defense, but rather a safety net that catches attempts to exploit\nvulnerabilities that exist in the system despite other protective measures. An insecure CSP does not automatically imply that the website is\nvulnerable, but it does mean that this additional layer of protection is weakened.
\nA CSP can be considered insecure if it allows potentially harmful practices, such as inline scripts or loading resources from arbitrary domains.\nThese practices can increase the risk of content injection attacks.
\nAn insecure Content Security Policy (CSP) can increase the potential severity of other vulnerabilities in the system. For instance, if an attacker\nmanages to exploit a Cross-Site Scripting (XSS) vulnerability, an insecure CSP might not provide the intended additional protection.
\nThe impact of a successful XSS attack can be severe. XSS allows an attacker to inject malicious scripts into web pages viewed by other users. These\nscripts can then be used to steal sensitive information like session cookies, personal data, or credit card details, leading to identity theft or\nfinancial fraud.
\nMoreover, XSS can be used to perform actions on behalf of the user without their consent, such as changing their email address or password, or\nmaking transactions. This can lead to unauthorized access and potential loss of control over user accounts.
\nIn addition, an insecure CSP that allows loading resources from arbitrary domains could potentially expose sensitive user data to untrusted\nsources. This could lead to data breaches, which can have serious legal and reputational consequences.
\n\nusing System.Web;\n\npublic async Task InvokeAsync(HttpContext context)\n{\n context.Response.Headers.ContentSecurityPolicy = \"script-src 'self' 'unsafe-inline';\"; // Noncompliant\n}\n\n\nusing System.Web;\n\npublic async Task InvokeAsync(HttpContext context)\n{\n context.Response.Headers.ContentSecurityPolicy = \"script-src 'self' 'sha256-RFWPLDbv2BY+rCkDzsE+0fr8ylGr2R2faWMhq4lfEQc=';\";\n}\n\nTo fix an insecure Content Security Policy (CSP), you should adhere to the principle of least privilege. This principle states that a user should\nbe given the minimum levels of access necessary to complete their tasks. In the context of CSP, this means restricting the sources from which content\ncan be loaded to the minimum necessary.
\nHere are some steps to secure your CSP:
\nWhen working with collections that are known to be non-empty, using
Using FirstOrDefault or SingleOrDefault on collections that are known to be non-empty is an issue due to:
FirstOrDefault or SingleOrDefault, it implies that the collection might be\n empty, which can be misleading if you know it is not. It can be confusing for other developers who read your code, making it harder for them to\n understand the actual constraints and behavior of the collection. This leads to confusion and harder-to-maintain code.FirstOrDefault and\n SingleOrDefault can lead to subtle bugs. These methods return a default value (null for reference types and\n default for value types) when the collection is empty, potentially causing issues like NullReferenceException later in the\n code. In contrast, First or Single will throw an InvalidOperationException immediately if the collection is\n empty, making it easier to detect and address issues early in the development process.null, you introduces a condition that cannot be fully tested,\n impacting the code coverage.\nvar items = new List<int> { 1, 2, 3 };\n\nint firstItem = items.FirstOrDefault(); // Noncompliant, this implies the collection might be empty, when we know it is not\n\n\nvar items = new List<int> { 1, 2, 3 };\n\nint firstItem = items.First(); // Compliant\n\nSingleFirstSingleOrDefaultFirstOrDefaultWhen using ReaderWriterLock and
This rule raises if:
\nIf you use the ReaderWriterLockSlim class, you will get a ReaderWriterLock, you’ll get a runtime exception for trying to release a lock that is not owned by the calling thread.
\npublic class Example\n{\n private static ReaderWriterLock rwLock = new();\n\n public void Writer()\n {\n rwLock.AcquireWriterLock(2000);\n try\n {\n // ...\n }\n finally\n {\n rwLock.ReleaseReaderLock(); // Noncompliant, will throw runtime exception\n }\n }\n\n public void Reader()\n {\n rwLock.AcquireReaderLock(2000);\n try\n {\n // ...\n }\n finally\n {\n rwLock.ReleaseWriterLock(); // Noncompliant, will throw runtime exception\n }\n }\n}\n\n\npublic class Example\n{\n private static ReaderWriterLock rwLock = new();\n\n public static void Writer()\n {\n rwLock.AcquireWriterLock(2000);\n try\n {\n // ...\n }\n finally\n {\n rwLock.ReleaseWriterLock();\n }\n }\n\n public static void Reader()\n {\n rwLock.AcquireReaderLock(2000);\n try\n {\n // ...\n }\n finally\n {\n rwLock.ReleaseReaderLock();\n }\n }\n}\n\nThis rule raises if you acquire a lock with one of the following methods, and do not release it within the same method.
\nThis rule will raise an issue when the code uses the
Not releasing a lock in the same method where you acquire it, and releasing in another one, makes the code less clear and harder to maintain. You\nare also introducing the risk of not releasing a lock at all which can lead to deadlocks or exceptions.
\n\npublic class Example\n{\n private static ReaderWriterLock rwLock = new();\n\n public void AcquireWriterLock() =>\n rwLock.AcquireWriterLock(2000); // Noncompliant, as the lock release is on the callers responsibility\n\n public void DoSomething()\n {\n // ...\n }\n\n public void ReleaseWriterLock() =>\n rwLock.ReleaseWriterLock();\n}\n\n\npublic class Example\n{\n private static ReaderWriterLock rwLock = new();\n\n public void DoSomething()\n {\n rwLock.AcquireWriterLock(2000); // Compliant, locks are released in the same method\n try\n {\n // ...\n }\n finally\n {\n rwLock.ReleaseWriterLock();\n }\n }\n}\n\nUsing upper case literal suffixes removes the potential ambiguity between \"1\" (digit 1) and \"l\" (letter el) for declaring literals.
\n\nconst long b = 0l; // Noncompliant\n\n
\nconst long b = 0L;\n\n\n" }, { "path": "analyzers/rspec/cs/S818.json", "content": "{\n \"title\": \"Literal suffixes should be upper case\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-818\",\n \"sqKey\": \"S818\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/cs/S8367.html", "content": "
This rule raises an issue when code uses 'field' as an identifier in contexts where it conflicts with the new field contextual keyword\nintroduced in C# 14.
C# 14 introduces the field contextual keyword for field-backed properties. This keyword allows access to the synthesized backing\nfields directly within property accessors, simplifying property implementations that need custom logic.
By using 'field' as an identifier, several problems can occur:
\nfield within property accessors cause compiler\n error CS9273. References to existing members named field within property accessors cause compiler error CS9258. See field may be unexpectedly overshadowed by the synthesized backing\n field when referenced within property accessors, leading to logic errors and unexpected runtime behavior.Using 'field' as an identifier can prevent successful compilation when upgrading to C# 14. In property accessors, local variables or parameters\nnamed 'field' will cause compilation errors, while class members named 'field' may be unexpectedly overshadowed by synthesized backing fields, leading\nto logic errors and unexpected runtime behavior.
\nRename the identifier, escape it by prefixing with @, or qualify member access with this. or base. to avoid\nconflicts with the contextual keyword. This rule applies only inside property get, set, and init accessors;\nindexer and event accessors are not affected.
\npublic class ClassFieldExample\n{\n private string field;\n\n public string Message\n {\n get => field; // Noncompliant\n set => field = value; // Noncompliant\n }\n}\n\n\npublic class LocalFunctionExample\n{\n public int Value\n {\n get\n {\n return LocalFunction(42);\n\n int LocalFunction(int field) // Noncompliant\n => field;\n }\n }\n}\n\n\npublic class ClassFieldExample\n{\n private string field;\n\n public string Message\n {\n get => this.field; // or @field\n set => this.field = value; // or @field = value;\n }\n}\n\n\npublic class LocalFunctionExample\n{\n public int Value\n {\n get\n {\n return LocalFunction(42);\n\n int LocalFunction(int value) // Compliant - renamed\n => value;\n }\n }\n}\n\nfield\n keywordfield in a property accessor refers to synthesized backing fieldfield disallowed in a property accessor (documentation incorrectly references CS9272; the actual error code is CS9273)Identifiers named extension should be renamed or use the @ escape prefix to avoid breaking changes in C# 14 or later.
Starting with C# 14, extension extension as an identifier. For example, a class named 'extension' will be interpreted as an extension container declaration,\nleading to parsing failures.
This rule flags any unescaped extension identifiers used in the following cases:
Note that method names, parameter names, and local variable names are not affected by this breaking change. For example, void extension() {\n} remains valid in C# 14.
Code that currently compiles will fail to compile when the project is upgraded to C# 14.
\nRename the identifier, or add the @ prefix to it.
\nclass extension { }\nclass MyClass\n{\n extension field;\n extension Property { get; }\n}\n\nEscape the identifier with the @ verbatim prefix:
\nclass @extension { }\nclass MyClass\n{\n @extension field;\n @extension Property { get; }\n}\n\n\nclass extension { }\nclass MyClass\n{\n extension ReturnType() { return default; }\n}\n\nRename the identifier:
\n\nclass MyExtension { }\nclass MyClass\n{\n MyExtension ReturnType() { return default; }\n}\n\nextension treated as a contextual keyword@ prefix)Using partial as a return type identifier will cause a compilation error when upgrading to C# 14.
In C# 14, partial in a return type position is always treated as a modifier, even when a type named partial is in scope.\nThis causes compilation errors in code that previously compiled successfully.
The issue specifically affects method declarations where a custom type named partial is used as the return type. Other uses of the\npartial type (such as in variable declarations or constructor calls) are not affected by this change.
This breaking change will cause compilation failures when upgrading existing codebases to C# 14. The compilation error prevents the application\nfrom building, requiring immediate attention to fix the syntax.
\nWhile this is not a runtime issue, it can block development and deployment processes until resolved. The fix is straightforward but must be applied\nto all affected method declarations.
\nAdd the @ prefix before partial when used as a return type. This tells the compiler to treat partial as an\nidentifier rather than a modifier. Alternatively, rename the type to avoid the conflict.
\nclass C\n{\n partial F() => new partial(); // Noncompliant\n}\n\nclass partial { }\n\n\nclass C\n{\n @partial F() => new partial();\n}\n\nclass partial { }\n\n\nclass C\n{\n partial F() => new partial(); // Noncompliant\n}\n\nclass partial { }\n\n\nclass C\n{\n PartialItem F() => new PartialItem();\n}\n\nclass PartialItem { }\n\npartial cannot be a return type of methodsUsing scoped as a type name in lambda parameter lists will cause a compilation error when upgrading to C# 14 or later.
In C# 14, the language introduced the ability to write lambdas with parameter modifiers without specifying parameter types. As part of this\nenhancement, a breaking change was implemented where scoped is always treated as a modifier in lambda parameter lists.
As a result, parenthesized lambda parameters that use scoped as an identifier or type name will fail to compile after upgrading to C#\n14. In that context, the compiler interprets scoped as a modifier unless it is escaped with @.
This breaking change affects existing code that was valid in earlier C# versions, particularly when upgrading projects to C# 14. The issue is\nspecific to lambda expressions and doesn’t affect other contexts where the scoped type name might be used.
This issue prevents code compilation when upgrading to C# 14. Projects that previously compiled successfully will fail to build, blocking\ndevelopment and deployment processes until the code is updated.
\nRename the type, or escape the type name scoped with the @ prefix. This tells the compiler to treat it as an identifier\nrather than a contextual keyword.
\nAction<int> lambda1 = (scoped) => { }; // Noncompliant\nvar lambda2 = (scoped scoped) => { }; // Noncompliant\nvar lambda3 = (scoped scoped parameter) => { }; // Noncompliant\n\nref struct @scoped { }\n\n\nAction<int> lambda1 = (@scoped) => { };\nvar lambda2 = (@scoped scoped) => { };\nvar lambda3 = (scoped @scoped parameter) => { };\n\nref struct @scoped { }\n\n\nvar lambda = (scoped scoped parameter) => { }; // Noncompliant\n\nref struct @scoped { }\n\n\nvar lambda = (scoped ScopedItem parameter) => { };\n\nref struct ScopedItem { }\n\nThe use of increment and decrement operators in method calls or in combination with other arithmetic operators is not recommended, because:
\n\nu8a = ++u8b + u8c--;\nfoo = bar++ / 4;\n\n
The following sequence is clearer and therefore safer:
\n\n++u8b;\nu8a = u8b + u8c;\nu8c--;\nfoo = bar / 4;\nbar++;\n\n\n" }, { "path": "analyzers/rspec/cs/S881.json", "content": "{\n \"title\": \"Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-881\",\n \"sqKey\": \"S881\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/cs/S907.html", "content": "
goto is an unstructured control flow statement. It makes code less readable and maintainable. Structured control flow statements such\nas if, for, while, continue or break should be used instead.
Parameters are part of the
Implementing a method from an interface, a base class, or a partial method and changing one of its parameters' names will confuse and impact the\nmethod’s readability.
\n\ninterface IBankAccount\n{\n void AddMoney(int money);\n}\n\nclass BankAccount : IBankAccount\n{\n void AddMoney(int amount) // Noncompliant: parameter's name differs from base\n {\n // ...\n }\n}\n\nTo avoid any ambiguity in the code, a parameter’s name should match the initial declaration, whether its initial declaration is from an interface,\na base class, or a partial method.
\n\ninterface IBankAccount\n{\n void AddMoney(int money);\n}\n\nclass BankAccount : IBankAccount\n{\n void AddMoney(int money) // Compliant: parameter's name match base name\n {\n // ...\n }\n}\n\nThe rule is ignored if both the parameter defined in the initial decalaration is a generic type and the implementing member’s declaration is a\nnon-generic type.
\nThis allows the implementing member to be more specific and provide more information.
\nShared naming conventions allow teams to collaborate efficiently.
\nThis rule raises an issue when a class name does not match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nBackColorGetIDGetHtmlFor example, with the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$, the class:
\nClass foo ' Noncompliant\nEnd Class\n\n
should be renamed to
\n\nClass Foo\nEnd Class\n\n
Scrolling horizontally to see a full line of code lowers the code readability.
\n\n" }, { "path": "analyzers/rspec/vbnet/S103.json", "content": "{\n \"title\": \"Lines should not be too long\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-103\",\n \"sqKey\": \"S103\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S104.html", "content": "When a source file grows too much, it can accumulate numerous responsibilities and become challenging to understand and maintain.
\nAbove a specific threshold, refactor the file into smaller files whose code focuses on well-defined tasks. Those smaller files will be easier to\nunderstand and test.
\n\n" }, { "path": "analyzers/rspec/vbnet/S104.json", "content": "{\n \"title\": \"Files should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1h\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-104\",\n \"sqKey\": \"S104\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1048.html", "content": "The Finalize methods are used to perform
When creating a Finalize method, it should never throw an exception, as there is a high risk of having the application terminated leaving unmanaged\nresources without a graceful cleanup.
\nThe rule raises an issue on throw statements used in a Finalize method.
\nClass Sample\n Protected Overrides Sub Finalize()\n Throw New NotImplementedException() ' Noncompliant: Finalize method throws an exception\n End Sub\nEnd Class\n\n
\nClass Sample\n Protected Overrides Sub Finalize()\n ' Noncompliant: Finalize method does not throw an exception\n End Sub\nEnd Class\n\n
In general object finalization can be a complex and error-prone operation and should not be implemented except within the
When cleaning up unmanaged resources, it is\nrecommended to implement the dispose pattern or, to cover uncalled Dispose method by the consumer, implement SafeHandle.
SafeHandle\n ClassIDisposable.Dispose\n MethodThe tab width can differ from one development environment to another. Using tabs may require other developers to configure their environment (text\neditor, preferences, etc.) to read source code.
\nThat is why using spaces is preferable.
\n\n" }, { "path": "analyzers/rspec/vbnet/S105.json", "content": "{\n \"title\": \"Tabulation characters should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-105\",\n \"sqKey\": \"S105\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1066.html", "content": "Nested code - blocks of code inside blocks of code - is eventually necessary, but increases complexity. This is why keeping the code as flat as\npossible, by avoiding unnecessary nesting, is considered a good practice.
\nMerging if statements when possible will decrease the nesting of the code and improve its readability.
Code like
\n\nIf condition1 Then\n If condition2 Then ' Noncompliant\n ' ...\n End If\nEnd If\n\n
Will be more readable as
\n\nIf condition1 AndAlso condition2 Then\n ' ...\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1066.json", "content": "{\n \"title\": \"Mergeable \\\"if\\\" statements should be combined\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1066\",\n \"sqKey\": \"S1066\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1067.html", "content": "
Complex boolean expressions are hard to read and so to maintain.
\nWith the default threshold value of 3
\n\nIf ((condition1 AndAlso condition2) OrElse (condition3 AndAlso condition4)) AndAlso condition5) Then 'Noncompliant\n ...\nEnd If\n\n
\nIf ((MyFirstCondition() OrElse MySecondCondition()) AndAlso MyLastCondition()) Then\n ...\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1067.json", "content": "{\n \"title\": \"Expressions should not be too complex\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"3min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1067\",\n \"sqKey\": \"S1067\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S107.html", "content": "
Procedures with a long parameter list are difficult to use because maintainers must figure out the role of each parameter and keep track of their\nposition.
\n\nSub SetCoordinates(x1 As Integer, y1 As Integer, z1 As Integer, x2 As Integer, y2 As Integer, z2 As Integer) ' Noncompliant\n ' ...\nEnd Sub\n\n
The solution can be to:
\n\n' Each function does a part of what the original setCoordinates function was doing, so confusion risks are lower\nSub SetOrigin(x As Integer, y As Integer, z As Integer)\n ' ...\nEnd Sub\n\nSub SetSize(width As Integer, height As Integer, depth As Integer)\n ' ...\nEnd Sub\n\n
\nClass Point ' In geometry, Point is a logical structure to group data\n\n Public x As Integer\n Public y As Integer\n Public z As Integer\n\nEnd Class\n\nSub SetCoordinates(p1 As Point, p2 As Point)\n ' ...\nEnd Sub\n\n
This rule raises an issue when a procedure has more parameters than the provided threshold.
\nThe rule does not count the parameters intended for a base class constructor.
\nWith a maximum number of 4 parameters:
\n\nClass BaseClass\n\n Sub New(Param1 As Integer)\n ' ...\n End Sub\n\nEnd Class\n\nClass DerivedClass\n Inherits BaseClass\n\n Public Sub New(Param1 As Integer, Param2 As Integer, Param3 As Integer, Param4 As Integer, Param5 As Long)\n ' Compliant by exception: Param1 is used in the base class constructor, so it does not count in the sum of the parameter list.\n MyBase.New(Param1)\n ' ...\n End Sub\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S107.json", "content": "{\n \"title\": \"Procedures should not have too many parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-107\",\n \"sqKey\": \"S107\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1075.html", "content": "
Hard-coding a URI makes it difficult to test a program for a variety of reasons:
\nIn addition, hard-coded URIs can contain sensitive information, like IP addresses, and they should not be stored in the code.
\nFor all those reasons, a URI should never be hard coded. Instead, it should be replaced by a customizable parameter.
\nFurther, even if the elements of a URI are obtained dynamically, portability can still be limited if the path delimiters are hard-coded.
\nThis rule raises an issue when URIs or path delimiters are hard-coded.
\n\n" }, { "path": "analyzers/rspec/vbnet/S1075.json", "content": "{\n \"title\": \"URIs should not be hardcoded\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1075\",\n \"sqKey\": \"S1075\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S108.html", "content": "An empty code block is confusing. It will require some effort from maintainers to determine if it is intentional or indicates the implementation is\nincomplete.
\n\nFor Index As Integer = 1 To 42 ' Noncompliant: is the block empty on purpose, or is code missing?\nNext\n\n
Removing or filling the empty code blocks takes away ambiguity and generally results in a more straightforward and less surprising code.
\nThe rule ignores code blocks that contain comments.
\n\n" }, { "path": "analyzers/rspec/vbnet/S108.json", "content": "{\n \"title\": \"Nested blocks of code should not be left empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-108\",\n \"sqKey\": \"S108\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1110.html", "content": "The use of parentheses, even those not required to enforce a desired order of operations, can clarify the intent behind a piece of code. However,\nredundant pairs of parentheses could be misleading and should be removed.
\n\nIf a AndAlso ((x + y > 0)) Then ' Noncompliant\n ' ...\nEnd If\n\nReturn ((x + 1)) ' Noncompliant\n\n
\nIf a AndAlso x + y > 0 Then\n ' ...\nEnd If\n\nReturn x + 1\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1110.json", "content": "{\n \"title\": \"Redundant pairs of parentheses should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1110\",\n \"sqKey\": \"S1110\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S112.html", "content": "
This rule raises an issue when a generic exception (such as Exception, SystemException,\nApplicationException, IndexOutOfRangeException, NullReferenceException, OutOfMemoryException or\nExecutionEngineException) is thrown.
Throwing general exceptions such as Exception, SystemException and ApplicationException will have a negative\nimpact on any code trying to catch these exceptions.
From a consumer perspective, it is generally a best practice to only catch exceptions you intend to handle. Other exceptions should ideally not be\ncaught and let to propagate up the stack trace so that they can be dealt with appropriately. When a generic exception is thrown, it forces consumers\nto catch exceptions they do not intend to handle, which they then have to re-throw.
\nBesides, when working with a generic type of exception, the only way to distinguish between multiple exceptions is to check their message, which is\nerror-prone and difficult to maintain. Legitimate exceptions may be unintentionally silenced and errors may be hidden.
\nFor instance, if an exception such as StackOverflowException is caught and not re-thrown, it may prevent the program from terminating\ngracefully.
When throwing an exception, it is therefore recommended to throw the most specific exception possible so that it can be handled intentionally by\nconsumers.
\nAdditionally, some reserved exceptions should not be thrown manually. Exceptions such as IndexOutOfRangeException,\nNullReferenceException, OutOfMemoryException or ExecutionEngineException will be thrown automatically by the\nruntime when the corresponding error occurs. Many of them indicate serious errors, which the application may not be able to recover from. It is\ntherefore recommended to avoid throwing them as well as using them as base classes.
To fix this issue, make sure to throw specific exceptions that are relevant to the context in which they arise. It is recommended to either:
\nException when one matches. For instance ArgumentException could be raised when an unexpected\n argument is provided to a function.Exception or one of its subclasses.\nPublic Sub DoSomething(obj As Object)\n If obj Is Nothing Then\n ' Noncompliant\n Throw New NullReferenceException(\"obj\") ' Noncompliant: This reserved exception should not be thrown manually\n End If\n ' ...\nEnd Sub\n\n
\nPublic Sub DoSomething(obj As Object)\n If obj Is Nothing Then\n Throw New ArgumentNullException(\"obj\") ' Compliant: this is a specific and non-reserved exception type\n End If\n ' ...\nEnd Sub\n\n
The Obsolete attribute can be applied with or without a message argument. Marking something Obsolete without including\nadvice on why it’s obsolete or what to use instead will lead maintainers to waste time trying to figure those things out.
\nPublic Class Car\n\n <Obsolete> ' Noncompliant\n Public Sub CrankEngine(Turns As Integer)\n ' ...\n End Sub\n\nEnd Class\n\n
\nPublic Class Car\n\n <Obsolete(\"Replaced by the automatic starter\")>\n Public Sub CrankEngine(Turns As Integer)\n ' ...\n End Sub\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1123.json", "content": "{\n \"title\": \"\\\"Obsolete\\\" attributes should include explanations\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"obsolete\",\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1123\",\n \"sqKey\": \"S1123\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1125.html", "content": "
A boolean literal can be represented in two different ways: True or False. They can be combined with logical operators\n(Not, And, Or, =) to produce logical expressions that represent truth values. However, comparing a boolean literal to a variable or\nexpression that evaluates to a boolean value is unnecessary and can make the code harder to read and understand. The more complex a boolean expression\nis, the harder it will be for developers to understand its meaning and expected behavior, and it will favour the introduction of new bugs.
Remove redundant boolean literals from expressions to improve readability and make the code more maintainable.
\n\nIf BooleanMethod() = True Then ' Noncompliant\n ' ...\nEnd If\nIf BooleanMethod() = False Then ' Noncompliant\n ' ...\nEnd If\nIf BooleanMethod() OrElse False Then ' Noncompliant\n ' ...\nEnd If\nDoSomething(Not False) ' Noncompliant\nDoSomething(BooleanMethod() = True) ' Noncompliant\n\nDim booleanVariable = If(BooleanMethod(), True, False) ' Noncompliant\nbooleanVariable = If(BooleanMethod(), True, exp) ' Noncompliant\nbooleanVariable = If(BooleanMethod(), False, exp) ' Noncompliant\nbooleanVariable = If(BooleanMethod(), exp, True) ' Noncompliant\nbooleanVariable = If(BooleanMethod(), exp, False) ' Noncompliant\n\n
\nIf BooleanMethod() Then\n ' ...\nEnd If\nIf Not BooleanMethod() Then\n ' ...\nEnd If\nIf BooleanMethod() Then\n ' ...\nEnd If\nDoSomething(True)\nDoSomething(BooleanMethod())\n\nDim booleanVariable = BooleanMethod()\nbooleanVariable = BooleanMethod() OrElse exp\nbooleanVariable = Not BooleanMethod() AndAlso exp\nbooleanVariable = Not BooleanMethod() OrElse exp\nbooleanVariable = BooleanMethod() AndAlso exp\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1125.json", "content": "{\n \"title\": \"Boolean literals should not be redundant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1125\",\n \"sqKey\": \"S1125\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1133.html", "content": "
This rule is meant to be used as a way to track code which is marked as being deprecated. Deprecated code should eventually be removed.
\n\n<Obsolete> ' Noncompliant\nSub Procedure()\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1133.json", "content": "{\n \"title\": \"Deprecated code should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"INFO\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"obsolete\"\n ],\n \"defaultSeverity\": \"Info\",\n \"ruleSpecification\": \"RSPEC-1133\",\n \"sqKey\": \"S1133\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1134.html", "content": "
FIXME tags are commonly used to mark places where a bug is suspected, but which the developer wants to deal with later.
Sometimes the developer will not have the time or will simply forget to get back to that tag.
\nThis rule is meant to track those tags and to ensure that they do not go unnoticed.
\n\nFunction Divide(numerator As Integer, denominator As Integer) As Integer\n Return numerator / denominator ' FIXME denominator value might be 0\nEnd Function\n\n
Developers often use TODO tags to mark areas in the code where additional work or improvements are needed but are not implemented\nimmediately. However, these TODO tags sometimes get overlooked or forgotten, leading to incomplete or unfinished code. This rule aims to\nidentify and address unattended TODO tags to ensure a clean and maintainable codebase. This description explores why this is a problem\nand how it can be fixed to improve the overall code quality.
Unattended TODO tags in code can have significant implications for the development process and the overall codebase.
Incomplete Functionality: When developers leave TODO tags without implementing the corresponding code, it results in incomplete\nfunctionality within the software. This can lead to unexpected behavior or missing features, adversely affecting the end-user experience.
Missed Bug Fixes: If developers do not promptly address TODO tags, they might overlook critical bug fixes and security updates.\nDelayed bug fixes can result in more severe issues and increase the effort required to resolve them later.
Impact on Collaboration: In team-based development environments, unattended TODO tags can hinder collaboration. Other team members\nmight not be aware of the intended changes, leading to conflicts or redundant efforts in the codebase.
Codebase Bloat: The accumulation of unattended TODO tags over time can clutter the codebase and make it difficult to distinguish\nbetween work in progress and completed code. This bloat can make it challenging to maintain an organized and efficient codebase.
Addressing this code smell is essential to ensure a maintainable, readable, reliable codebase and promote effective collaboration among\ndevelopers.
\n\nSub DoSomething()\n ' TODO\nEnd Sub\n\n
Sharing some naming conventions is a key point to make it possible for a team to efficiently collaborate.
\nThis rule allows to check that all interface names match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^I([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nInterface Foo ' Noncompliant\nEnd Interface\n\n
\nInterface IFoo ' Compliant\nEnd Interface\n\n\n" }, { "path": "analyzers/rspec/vbnet/S114.json", "content": "{\n \"title\": \"Interface names should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-114\",\n \"sqKey\": \"S114\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1147.html", "content": "
End statements exit the control flow of the program in an unstructured way. This statement stops code execution immediately without\nexecuting Dispose or Finalize methods, or executing Finally blocks. Therefore, it should be avoided.
\nModule Module1\n Sub Print(ByVal str As String)\n Try\n ...\n End ' Noncompliant\n Finally\n ' do something important here\n ...\n End Try\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1147.json", "content": "{\n \"title\": \"\\\"End\\\" statements should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"30min\"\n },\n \"tags\": [\n \"cwe\",\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-1147\",\n \"sqKey\": \"S1147\",\n \"scope\": \"Main\",\n \"securityStandards\": {\n \"CWE\": [\n 382\n ]\n },\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1151.html", "content": "
The Select...Case statement should be used only to clearly define some new branches in the control flow. As soon as a case clause\ncontains too many statements this highly decreases the readability of the overall control flow statement. In such case, the content of the case clause\nshould be extracted into a dedicated procedure.
With the default threshold of 3:
\n\nSelect Case number\n Case 1 To 5 ' Noncompliant: 4 statements in the case\n MethodCall1(\"\")\n MethodCall2(\"\")\n MethodCall3(\"\")\n MethodCall4(\"\")\n Case Else\n ' ...\nEnd Select\n\n
\nSelect Case number\n Case 1 To 5\n DoSomething()\n Case Else\n ' ...\nEnd Select\n...\nSub DoSomething()\n MethodCall1(\"\")\n MethodCall2(\"\")\n MethodCall3(\"\")\n MethodCall4(\"\")\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1151.json", "content": "{\n \"title\": \"\\\"Select...Case\\\" clauses should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1151\",\n \"sqKey\": \"S1151\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1155.html", "content": "
Using .Count() to test for emptiness works, but using .Any() makes the intent clearer, and the code more readable.\nHowever, there are some cases where special attention should be paid:
EntityFramework or other ORM query, calling .Count() will cause executing a potentially\n massive SQL query and could put a large overhead on the application database. Calling .Any() will also connect to the database, but\n will generate much more efficient SQL..Select() statements that create objects, a large amount of memory could be\n unnecessarily allocated. Calling .Any() will be much more efficient because it will execute fewer iterations of the enumerable.\nPrivate Function HasContent(Strings As IEnumerable(Of String)) As Boolean\n Return Strings.Count() > 0 ' Noncompliant\nEnd Function\n\nPrivate Function HasContent2(Strings As IEnumerable(Of String)) As Boolean\n Return Strings.Count() >= 1 ' Noncompliant\nEnd Function\n\nPrivate Function IsEmpty(Strings As IEnumerable(Of String)) As Boolean\n Return Strings.Count() = 0 ' Noncompliant\nEnd Function\n\n
\nPrivate Function HasContent(Strings As IEnumerable(Of String)) As Boolean\n Return Strings.Any\nEnd Function\n\nPrivate Function HasContent2(Strings As IEnumerable(Of String)) As Boolean\n Return Strings.Any\nEnd Function\n\nPrivate Function IsEmpty(Strings As IEnumerable(Of String)) As Boolean\n Return Not Strings.Any\nEnd Function\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1155.json", "content": "{\n \"title\": \"\\\"Any()\\\" should be used to test for emptiness\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1155\",\n \"sqKey\": \"S1155\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1163.html", "content": "
If an exception is already being thrown within the try block or caught in a catch block, throwing another exception in\nthe finally block will override the original exception. This means that the original exception’s message and stack trace will be lost,\npotentially making it challenging to diagnose and troubleshoot the root cause of the problem.
\nTry\n ' Some work which end up throwing an exception\n Throw New ArgumentException()\nFinally\n ' Cleanup\n Throw New InvalidOperationException() ' Noncompliant: will mask the ArgumentException\nEnd Try\n\n
\nTry\n ' Some work which end up throwing an exception\n Throw New ArgumentException()\nFinally\n ' Cleanup without throwing\nEnd Try\n\n
Local variables should be named consistently to communicate intent and improve maintainability. Rename your local variable to follow your project’s\nnaming convention to address this issue.
\nA naming convention in software development is a set of guidelines for naming code elements like variables, functions, and classes.\n
\n Local variables hold the meaning of the written code. Their names should be meaningful and follow a consistent and easily recognizable pattern.\n
\n Adhering to a consistent naming convention helps to make the code more readable and understandable, which makes it easier to maintain and debug. It\n also ensures consistency in the code, especially when multiple developers are working on the same project.
This rule checks that local variable names match a provided regular expression.
\nInconsistent naming of local variables can lead to several issues in your code:
\nIn summary, not adhering to a naming convention for local variables can lead to confusion, errors, and inefficiencies, making the code harder to\nread, understand, and maintain.
\nFirst, familiarize yourself with the particular naming convention of the project in question. Then, update the name to match the convention, as\nwell as all usages of the name. For many IDEs, you can use built-in renaming and refactoring features to update all usages at once.
\nWith the default regular expression ^[a-z][a-z0-9]*([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$, bringing the following constraints:
\nModule Module1\n Sub Main()\n Dim Foo = 0 ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim foo = 0 ' Compliant\n End Sub\nEnd Module\n\n
A typical code smell known as unused function parameters refers to parameters declared in a function but not used anywhere within the function’s\nbody. While this might seem harmless at first glance, it can lead to confusion and potential errors in your code. Disregarding the values passed to\nsuch parameters, the function’s behavior will be the same, but the programmer’s intention won’t be clearly expressed anymore. Therefore, removing\nfunction parameters that are not being utilized is considered best practice.
\nThis rule raises an issue when a private procedure of a Class, Module or Structure takes a\nparameter without using it.
This rule doesn’t raise any issue in the following contexts:
\nNotImplementedException.virtual, override procedures.Having unused function parameters in your code can lead to confusion and misunderstanding of a developer’s intention. They reduce code readability\nand introduce the potential for errors. To avoid these problems, developers should remove unused parameters from function declarations.
\n\nPrivate Sub DoSomething(ByVal a As Integer, ByVal b as Integer) ' \"b\" is unused\n Compute(a)\nEnd Sub\n\nPrivate Function DoSomething2(ByVal a As Integer, ByVal b As Integer) As Integer ' \"a\" is unused\n Compute(b)\n Return b\nEnd Function\n\n
\nPrivate Sub DoSomething(ByVal a As Integer)\n Compute(a)\nEnd Sub\n\nPrivate Function DoSomething2(ByVal b As Integer) As Integer\n Compute(b)\n Return b\nEnd Function\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1172.json", "content": "{\n \"title\": \"Unused procedure parameters should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1172\",\n \"sqKey\": \"S1172\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1186.html", "content": "
An empty method is generally considered bad practice and can lead to confusion, readability, and maintenance issues. Empty methods bring no\nfunctionality and are misleading to others as they might think the method implementation fulfills a specific and identified requirement.
\nThere are several reasons for a method not to have a body:
\nThe following empty methods are considered compliant:
\nOverridable methods, as the implementation might not be required in the base classMustOverride method as the implementation is mandatory for child class\nSub ShouldNotBeEmpty() ' Noncompliant - method is empty\nEnd Sub\n\nSub NotImplementedYet() ' Noncompliant - method is empty\nEnd Sub\n\nSub WillNeverBeImplemented() ' Noncompliant - method is empty\nEnd Sub\n\nSub EmptyOnPurpose() ' Noncompliant - method is empty\nEnd Sub\n\n
\nSub ShouldNotBeEmpty()\n DoSomething()\nEnd Sub\n\nSub NotImplementedYet()\n Throw New NotImplementedException\nEnd Sub\n\nSub WillNeverBeImplemented()\n Throw New NotSupportedException\nEnd Sub\n\nSub EmptyOnPurpose()\n ' Do nothing because of X\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1186.json", "content": "{\n \"title\": \"Methods should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1186\",\n \"sqKey\": \"S1186\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S119.html", "content": "
Inconsistent naming conventions can lead to confusion and errors when working in a team. This rule ensures that all generic type parameter names\nfollow a consistent naming convention by checking them against a provided regular expression.
\nThe default configuration follows Microsoft’s recommended convention:
\nTo fix this issue, ensure that all generic type parameter names in your code follow the naming convention specified in the regular expression.
\nWith the default parameter value ^T(([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?)?$:
\nPublic Class Foo(Of tkey) ' Noncompliant\nEnd Class\n\n
\nPublic Class Foo(Of TKey) ' Compliant\nEnd Class\n\n
Duplicated string literals make the process of refactoring complex and error-prone, as any change would need to be propagated on all\noccurrences.
\nThe following are ignored:
\nUse constants to replace the duplicated string literals. Constants can be referenced from many places, but only need to be updated in a single\nplace.
\n\nPublic Class Foo\n\n Private Name As String = \"foobar\" ' Noncompliant\n\n Public ReadOnly Property DefaultName As String = \"foobar\" ' Noncompliant\n\n Public Sub New(Optional Value As String = \"foobar\") ' Noncompliant\n\n Dim Something = If(Value, \"foobar\") ' Noncompliant\n\n End Sub\n\nEnd Class\n\n
\nPublic Class Foo\n\n Private Const Foobar As String = \"foobar\"\n\n Private Name As String = Foobar\n\n Public ReadOnly Property DefaultName As String = Foobar\n\n Public Sub New(Optional Value As String = Foobar)\n\n Dim Something = If(Value, Foobar)\n\n End Sub\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1192.json", "content": "{\n \"title\": \"String literals should not be duplicated\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"DISTINCT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Linear with offset\",\n \"linearDesc\": \"per duplicate instance\",\n \"linearOffset\": \"2min\",\n \"linearFactor\": \"2min\"\n },\n \"tags\": [\n \"design\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1192\",\n \"sqKey\": \"S1192\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1197.html", "content": "
Array designators should always be located on the type for better code readability. Otherwise, developers must look both at the type and the\nvariable name to know whether or not a variable is an array.
\n\nModule Module1\n Sub Main()\n Dim foo() As String ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim foo As String() ' Compliant\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1197.json", "content": "{\n \"title\": \"Array designators \\\"()\\\" should be on the type, not the variable\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1197\",\n \"sqKey\": \"S1197\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S122.html", "content": "
Putting multiple statements on a single line lowers the code readability and makes debugging the code more complex.
\n\nDim a = 0 : Dim b = 0 ' Noncompliant\n\n
Write one statement per line to improve readability.
\n\nDim a = 0\nDim b = 0\n\n\n" }, { "path": "analyzers/rspec/vbnet/S122.json", "content": "{\n \"title\": \"Statements should be on separate lines\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-122\",\n \"sqKey\": \"S122\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1226.html", "content": "
While it is technically correct to assign to parameters from within method bodies, doing so before the parameter value is read is likely a bug.\nInstead, initial values of parameters should be, if not treated as readonly then at least read before reassignment.
\nModule Module1\n Sub Foo(ByVal a As Integer)\n a = 42 ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Foo(ByVal a As Integer)\n Dim tmp = a\n tmp = 42\n End Sub\nEnd Module\n\n
ByRef parameters are ignored.
\nModule Module1\n Sub Foo(ByRef a As Integer)\n a = 42 ' Ignored; it is a ByRef parameter\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1226.json", "content": "{\n \"title\": \"Method parameters and caught exceptions should not be reassigned\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1226\",\n \"sqKey\": \"S1226\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S126.html", "content": "
This rule applies whenever an If statement is followed by one or more ElseIf statements; the final ElseIf\nshould be followed by an Else statement.
The requirement for a final Else statement is defensive programming.
The Else statement should either take appropriate action or contain a suitable comment as to why no action is taken. This is\nconsistent with the requirement to have a final Case Else clause in a Select Case statement.
\nIf x = 0 Then\n DoSomething()\nElseIf x = 1 Then\n DoSomethingElse()\nEnd If\n\n
\nIf x = 0 Then\n DoSomething()\nElseIf x = 1 Then\n DoSomethingElse()\nElse\n Throw New ArgumentException(\"...\")\nEnd If\n\n
None
\n\n" }, { "path": "analyzers/rspec/vbnet/S126.json", "content": "{\n \"title\": \"\\\"If ... ElseIf\\\" constructs should end with \\\"Else\\\" clauses\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-126\",\n \"sqKey\": \"S126\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1301.html", "content": "switch statements are useful when there are many different cases depending on the value of the same expression.
For just one or two cases, however, the code will be more readable with if statements.
\nSelect Case variable\n Case 0\n doSomething()\n Case Else\n doSomethingElse()\nEnd Select\n\n
\nIf variable = 0 Then\n doSomething()\nElse\n doSomethingElse()\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1301.json", "content": "{\n \"title\": \"\\\"Select\\\" statements should have at least 3 \\\"Case\\\" clauses\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1301\",\n \"sqKey\": \"S1301\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S131.html", "content": "
The requirement for a final Case Else clause is defensive programming.
This clause should either take appropriate action or contain a suitable comment as to why no action is taken.
\n\nSelect Case param ' Noncompliant - Case Else clause is missing\n Case 0\n DoSomething()\n Case 1\n DoSomethingElse()\nEnd Select\n\n
\nSelect Case param\n Case 0\n DoSomething()\n Case 1\n DoSomethingElse()\n Case Else ' Compliant\n DoSomethingElse()\nEnd Select\n\n
Hardcoding IP addresses is security-sensitive. It has led in the past to the following vulnerabilities:
\nToday’s services have an ever-changing architecture due to their scaling and redundancy needs. It is a mistake to think that a service will always\nhave the same IP address. When it does change, the hardcoded IP will have to be modified too. This will have an impact on the product development,\ndelivery, and deployment:
\nLast but not least it has an effect on application security. Attackers might be able to decompile the code and thereby discover a potentially\nsensitive address. They can perform a Denial of Service attack on the service, try to get access to the system, or try to spoof the IP address to\nbypass security checks. Such attacks can always be possible, but in the case of a hardcoded IP address solving the issue will take more time, which\nwill increase an attack’s impact.
\nThe disclosed IP address is sensitive, e.g.:
\nThere is a risk if you answered yes to any of these questions.
\nDon’t hard-code the IP address in the source code, instead make it configurable with environment variables, configuration files, or a similar\napproach. Alternatively, if confidentially is not required a domain name can be used since it allows to change the destination quickly without having\nto rebuild the software.
\n\nDim ip = \"192.168.12.42\" ' Sensitive\nDim address = IPAddress.Parse(ip)\n\n
\nDim ip = ConfigurationManager.AppSettings(\"myapplication.ip\") ' Compliant\nDim address = IPAddress.Parse(ip)\n\n
No issue is reported for the following cases because they are not considered sensitive:
\n2.5.<number>.<number> as they often match\n Object Identifiers (OID)Nested control flow statements If, Select, For, For Each, While, Do,\nand Try are often key ingredients in creating what’s known as \"Spaghetti code\". This code smell can make your program difficult to\nunderstand and maintain.
When numerous control structures are placed inside one another, the code becomes a tangled, complex web. This significantly reduces the code’s\nreadability and maintainability, and it also complicates the testing process.
\nThe following example demonstrates the behavior of the rule with the default threshold of 3 levels of nesting:
\n\nIf condition1 ' Compliant - depth = 1\n ' ...\n If condition2 ' Compliant - depth = 2\n ' ...\n For i = 0 to 10 ' Compliant - depth = 3, not exceeding the limit\n ' ...\n If condition4 ' Noncompliant - depth = 4\n If condition5 ' Depth = 5, exceeding the limit, but issues are only reported on depth = 4\n ' ...\n End If\n Return\n End If\n Next\n End If\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S134.json", "content": "{\n \"title\": \"Control flow statements \\\"If\\\", \\\"For\\\", \\\"For Each\\\", \\\"Do\\\", \\\"While\\\", \\\"Select\\\" and \\\"Try\\\" should not be nested too deeply\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-134\",\n \"sqKey\": \"S134\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S138.html", "content": "
A procedure that grows too large tends to aggregate too many responsibilities.
\nSuch procedures inevitably become harder to understand and therefore harder to maintain.
\nAbove a specific threshold, it is strongly advised to refactor into smaller procedures which focus on well-defined tasks.
\nThose smaller procedures will not only be easier to understand but also probably easier to test.
\n\n" }, { "path": "analyzers/rspec/vbnet/S138.json", "content": "{\n \"title\": \"Procedures should not have too many lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-138\",\n \"sqKey\": \"S138\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S139.html", "content": "This rule verifies that single-line comments are not located at the ends of lines of code. The main idea behind this rule is that in order to be\nreally readable, trailing comments would have to be properly written and formatted (correct alignment, no interference with the visual structure of\nthe code, not too long to be visible) but most often, automatic code formatters would not handle this correctly: the code would end up less readable.\nComments are far better placed on the previous empty line of code, where they will always be visible and properly formatted.
\nWith the default comment pattern ^'\\s*\\S+\\s*$, which ignores single word comments:
\nModule Module1\n Sub Main()\n Console.WriteLine(\"Hello, world!\") ' Noncompliant - My first program!\n Console.WriteLine(\"Hello, world!\") ' CompliantOneWord\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n ' Compliant - My first program!\n Console.WriteLine(\"Hello, world!\")\n Console.WriteLine(\"Hello, world!\") ' CompliantOneWord\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S139.json", "content": "{\n \"title\": \"Comments should not be located at the end of lines of code\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-139\",\n \"sqKey\": \"S139\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1451.html", "content": "
Each source file should start with a header stating file ownership and the license which must be used to distribute the application.
\nThis rule must be fed with the header text that is expected at the beginning of every file.
\nThe headerFormat must end with an empty line if you want to have an empty line between the file header and the first line for your\nsource file (using, namespace…).
For example, if you want the source file to look like this
\n\n' Copyright (c) SonarSource. All Rights Reserved. Licensed under the LGPL License. See License.txt in the project root for license information.\n\nnamespace Foo\n{\n}\n\nthen the headerFormat parameter should end with an empty line like this
\n' Copyright (c) SonarSource. All Rights Reserved. Licensed under the LGPL License. See License.txt in the project root for license information.\n\n
\n/*\n * SonarQube, open source software quality management tool.\n * Copyright (C) 2008-2013 SonarSource\n * mailto:contact AT sonarsource DOT com\n *\n * SonarQube is free software; you can redistribute it and/or\n * modify it under the terms of the GNU Lesser General Public\n * License as published by the Free Software Foundation; either\n * version 3 of the License, or (at your option) any later version.\n *\n * SonarQube is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with this program; if not, write to the Free Software Foundation,\n * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1451.json", "content": "{\n \"title\": \"Track lack of copyright and license headers\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"LAWFUL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-1451\",\n \"sqKey\": \"S1451\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1479.html", "content": "
When Select Case statements\nhave large sets of multi-line Case clauses, the code becomes hard to read and maintain.
For example, the Cognitive Complexity is going to be particularly high.
\nIn such scenarios, it’s better to refactor the Select Case to only have single-line case clauses.
When all the Case clauses of a Select Case statement are single-line, the readability of the code is not affected.
This rule ignores:
\nSelect Case statements over Enum argumentsReturn and Throw statements in Case clausesExtract the logic of multi-line Case clauses into separate methods.
The examples below use the \"Maximum number of case\" property set to 4.
\nPublic Function MapChar(ch As Char, value As Integer) As Integer ' Noncompliant\n Select Case ch\n Case \"a\"c\n Return 1\n Case \"b\"c\n Return 2\n Case \"c\"c\n Return 3\n ' ...\n Case \"-\"c\n If value > 10 Then\n Return 42\n ElseIf value < 5 AndAlso value > 1 Then\n Return 21\n End If\n Return 99\n Case Else\n Return 1000\n End Select\nEnd Function\n\n
\nPublic Function MapChar(ch As Char, value As Integer) As Integer\n Select Case ch\n Case \"a\"c\n Return 1\n Case \"b\"c\n Return 2\n Case \"c\"c\n Return 3\n ' ...\n Case \"-\"c\n Return HandleDash(value)\n Case Else\n Return 1000\n End Select\nEnd Function\n\nPrivate Function HandleDash(value As Integer) As Integer\n If value > 10 Then\n Return 42\n ElseIf value < 5 AndAlso value > 1 Then\n Return 21\n End If\n Return 99\nEnd Function\n\n
An unused local variable is a variable that has been declared but is not used anywhere in the block of code where it is defined. It is dead code,\ncontributing to unnecessary complexity and leading to confusion when reading the code. Therefore, it should be removed from your code to maintain\nclarity and efficiency.
\nHaving unused local variables in your code can lead to several issues:
\nIn summary, unused local variables can make your code less readable, more confusing, and harder to maintain, and they can potentially lead to bugs\nor inefficient memory use. Therefore, it is best to remove them.
\nUnused locally created resources in a Using statement are not reported.
\nUsing t = New TestTimer()\nEnd Using\n\n
The fix for this issue is straightforward. Once you ensure the unused variable is not part of an incomplete implementation leading to bugs, you\njust need to remove it.
\n\nPublic Function NumberOfMinutes(ByVal hours As Integer) As Integer\n Dim seconds As Integer = 0 ' Noncompliant - seconds is unused\n Return hours * 60\nEnd Function\n\n
\nPublic Function NumberOfMinutes(ByVal hours As Integer) As Integer\n Return hours * 60\nEnd Function\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1481.json", "content": "{\n \"title\": \"Unused local variables should be removed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"unused\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1481\",\n \"sqKey\": \"S1481\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1541.html", "content": "
The cyclomatic complexity of a function, procedure or property should not exceed a defined threshold. Complex code can perform poorly and will in\nany case be difficult to understand and therefore to maintain.
\n\n" }, { "path": "analyzers/rspec/vbnet/S1541.json", "content": "{\n \"title\": \"Functions, procedures and properties should not be too complex\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1541\",\n \"sqKey\": \"S1541\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1542.html", "content": "Shared naming conventions allow teams to collaborate efficiently. This rule checks that all subroutine and function names match a provided regular\nexpression.
\nThe default configuration is the one recommended by Microsoft:
\nEventArgs second parameter are not covered by this rule.With the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$
\nModule Module1\n Sub bad_subroutine() ' Noncompliant\n End Sub\n\n Public Function Bad_Function() As Integer ' Noncompliant\n Return 42\n End Function\nEnd Module\n\n
\nModule Module1\n Sub GoodSubroutine() ' Compliant\n End Sub\n\n Public Function GoodFunction() As Integer ' Compliant\n Return 42\n End Function\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1542.json", "content": "{\n \"title\": \"Functions and procedures should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1542\",\n \"sqKey\": \"S1542\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1643.html", "content": "
StringBuilder is more efficient than string concatenation, especially when the operator is repeated over and over as in loops.
\nModule Module1\n Sub Main()\n Dim foo = \"\"\n foo &= \"Result: \" ' Compliant - outside of loop\n\n For i = 1 To 9\n foo &= i ' Noncompliant\n Next\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim foo = New System.Text.StringBuilder\n foo.Append(\"Result: \") ' Compliant\n\n For i = 1 To 9\n foo.Append(i) ' Compliant\n Next\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1643.json", "content": "{\n \"title\": \"Strings should not be concatenated using \\\"+\\\" or \\\"\\u0026\\\" in a loop\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1643\",\n \"sqKey\": \"S1643\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1645.html", "content": "
Consistently using the & operator for string concatenation make the developer intentions clear.
&, unlike +, will convert its operands to strings and perform an actual concatenation.
+ on the other hand can be an addition, or a concatenation, depending on the operand types.
\nModule Module1\n Sub Main()\n Console.WriteLine(\"1\" + 2) ' Noncompliant - will display \"3\"\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Console.WriteLine(1 & 2) ' Compliant - will display \"12\"\n Console.WriteLine(1 + 2) ' Compliant - but will display \"3\"\n Console.WriteLine(\"1\" & 2) ' Compliant - will display \"12\"\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1645.json", "content": "{\n \"title\": \"The \\\"\\u0026\\\" operator should be used to concatenate strings\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1645\",\n \"sqKey\": \"S1645\",\n \"scope\": \"Main\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1654.html", "content": "
Sharing some naming conventions is a key point to make it possible for a team to efficiently collaborate.
\nThis rule allows to check that all parameter names match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^[a-z][a-z0-9]*([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$
\nModule Module1\n Sub GetSomething(ByVal ID As Integer) ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub GetSomething(ByVal id As Integer) ' Compliant\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1654.json", "content": "{\n \"title\": \"Method parameters should follow a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1654\",\n \"sqKey\": \"S1654\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1656.html", "content": "
There is no reason to re-assign a variable to itself. Either this statement is redundant and should be removed, or the re-assignment is a mistake\nand some other value or variable was intended for the assignment instead.
\n\nPublic Sub SetName(name As String)\n name = name ' Noncompliant\nEnd Sub\n\n
\nPublic Sub SetName(name As String)\n Me.name = name ' Compliant\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1656.json", "content": "{\n \"title\": \"Variables should not be self-assigned\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"3min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-1656\",\n \"sqKey\": \"S1656\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1659.html", "content": "
Declaring multiple variable on one line is difficult to read.
\n\nModule Module1\n Public Const AAA As Integer = 5, BBB = 42, CCC As String = \"foo\" ' Noncompliant\nEnd Module\n\n
\nModule Module1\n Public Const AAA As Integer = 5\n Public Const BBB = 42\n Public Const CCC as String = \"foo\"\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1659.json", "content": "{\n \"title\": \"Multiple variables should not be declared on the same line\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1659\",\n \"sqKey\": \"S1659\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1751.html", "content": "
A loop\nstatement with at most one iteration is equivalent to an If statement; the following block is executed only once.
If the initial intention was to conditionally execute the block only once, an If statement should be used instead. If that was not the\ninitial intention, the block of the loop should be fixed so the block is executed multiple times.
A loop statement with at most one iteration can happen when a statement unconditionally transfers control, such as a jump statement or a throw\nstatement, is misplaced inside the loop block.
\nThis rule raises when the following statements are misplaced:
\n\n\nPublic Function Method(items As IEnumerable(Of Object)) As Object\n For i As Integer = 0 To 9\n Console.WriteLine(i)\n Exit For ' Noncompliant: loop only executes once\n Next\n\n For Each item As Object In items\n Return item ' Noncompliant: loop only executes once\n Next\n Return Nothing\nEnd Function\n\n
\nPublic Function Method(items As IEnumerable(Of Object)) As Object\n For i As Integer = 0 To 9\n Console.WriteLine(i)\n Next\n\n Dim item = items.FirstOrDefault()\n If item IsNot Nothing Then\n Return item\n End If\n Return Nothing\nEnd Function\n\n
Exit\n Statement (Visual Basic)Continue Statement\n (Visual Basic)Return Statement (Visual\n Basic)Throw Statement (Visual\n Basic)Using the same value on either side of a binary operator is almost always a mistake. In the case of logical operators, it is either a copy/paste\nerror and therefore a bug, or it is simply wasted code, and should be simplified. In the case of most binary mathematical operators, having the same\nvalue on both sides of an operator yields predictable results, and should be simplified.
\nThis rule ignores *, +, &, <<, and >>.
\nIf (a = a) Then\n doZ()\nEnd If\n\nIf a = b OrElse a = b Then\n doW()\nEnd If\n\nDim j = 5 / 5\nj = 5 \\ 5\nj = 5 Mod 5\nDim k = 5 - 5\n\nDim i = 42\ni /= i\ni -= i\n\n
This rule ignores *, +, and =.
=.Nested Select Case structures are difficult to understand because you can easily confuse the cases of an inner Select\nCase as belonging to an outer statement. Therefore nested Select Case statements should be avoided.
Specifically, you should structure your code to avoid the need for nested Select Case statements, but if you cannot, then consider\nmoving the inner Select Case to another function.
\nPublic Sub Foo(A As Integer, B As Integer)\n Select Case A\n Case 0\n ' ...\n Case 1\n Select Case B ' Noncompliant; nested Select Case\n Case 2\n ' ...\n Case 3\n ' ...\n Case 4\n ' ...\n Case Else\n ' ...\n End Select\n Case 2\n ' ...\n Case Else\n ' ...\n End Select\nEnd Sub\n\n
\nPublic Sub Foo(A As Integer, B As Integer)\n Select Case A\n Case 0\n ' ...\n Case 1\n HandleB(B)\n Case 2\n ' ...\n Case Else\n ' ...\n End Select\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1821.json", "content": "{\n \"title\": \"\\\"Select Case\\\" statements should not be nested\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-1821\",\n \"sqKey\": \"S1821\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1862.html", "content": "
A chain of If/ElseIf\nstatements is evaluated from top to bottom. At most, only one branch will be executed: the first statement with a condition that evaluates to\nTrue. Therefore, duplicating a condition leads to unreachable code inside the duplicated condition block. Usually, this is due to a\ncopy/paste error.
The result of such duplication can lead to unreachable code or even to unexpected behavior.
\n\nIf param = 1 Then\n OpenWindow()\nElseIf param = 2 Then\n CloseWindow()\nElseIf param = 1 Then ' Noncompliant: condition has already been checked\n MoveWindowToTheBackground() ' unreachable code\nEnd If\n\n
\nIf param = 1 Then\n OpenWindow()\nElseIf param = 2 Then\n CloseWindow()\nElseIf param = 3 Then\n MoveWindowToTheBackground()\nEnd If\n\n
When the same code is duplicated in two or more separate branches of a conditional, it can make the code harder to understand, maintain, and can\npotentially introduce bugs if one instance of the code is changed but others are not.
\nHaving two Cases in the same Select statement or branches in the same If structure with the same\nimplementation is at best duplicate code, and at worst a coding error.
\nIf a >= 0 AndAlso a < 10 Then\n DoFirst()\n DoTheThing()\nElseIf a >= 10 AndAlso a < 20 Then\n DoTheOtherThing()\nElseIf a >= 20 AndAlso a < 50 ' Noncompliant; duplicates first condition\n DoFirst()\n DoTheThing()\nElse\n DoTheRest();\nEnd If\n\n
\nSelect i\n Case 1\n DoFirst()\n DoSomething()\n Case 2\n DoSomethingDifferent()\n Case 3 ' Noncompliant; duplicates case 1's implementation\n DoFirst()\n DoSomething()\n Case Else:\n DoTheRest()\nEnd Select\n\n
If the same logic is needed for both instances, then:
\nIf structure they should be combined\nIf (a >= 0 AndAlso a < 10) OrElse (a >= 20 AndAlso a < 50) Then\n DoFirst()\n DoTheThing()\nElseIf a >= 10 AndAlso a < 20 Then\n DoTheOtherThing()\nElse\n DoTheRest();\nEnd If\n\n
Select, the values should be put in the Case expression list.\nSelect i\n Case 1, 3\n DoFirst()\n DoSomething()\n Case 2\n DoSomethingDifferent()\n Case Else:\n DoTheRest()\nEnd Select\n\n
Blocks in an If chain or Case clause that contain a single line of code are ignored.
\nIf a >= 0 AndAlso a < 10 Then\n DoTheThing()\nElseIf a >= 10 AndAlso a < 20 Then\n DoTheOtherThing()\nElseIf a >= 20 AndAlso a < 50 ' no issue, usually this is done on purpose to increase the readability\n DoTheThing()\nEnd If\n\n
But this exception does not apply to If chains without Else-s, or to Select-s without Case Else\nclauses when all branches have the same single line of code. In the case of If chains with Else-s, or of\nSelect-es with Case Else clauses, rule {rule:vbnet:S3923} raises a bug.
\nIf a == 1 Then\n DoTheThing() ' Noncompliant, this might have been done on purpose but probably not\nElseIf a == 2 Then\n DoTheThing()\nEnd If\n\n
It is needlessly complex to invert the result of a boolean comparison. The opposite comparison should be made instead.
\n\nIf Not (a = 2) Then // Noncompliant\nDim b as Boolean = Not (i < 10) // Noncompliant\n\n
\nIf a <> 2 Then\nDim b as Boolean = i >= 10\n\n\n" }, { "path": "analyzers/rspec/vbnet/S1940.json", "content": "{\n \"title\": \"Boolean checks should not be inverted\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-1940\",\n \"sqKey\": \"S1940\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S1944.html", "content": "
A cast is an
In Visual Basic, there are two explicit conversion operators:
\n\nPublic Sub Method(Value As Object)\n Dim i As Integer\n i = DirectCast(Value, Integer) ' Direct casting from object holding an integer type to Integer\n i = CType(Value, Integer) ' Conversion from the underlying type to Integer\nEnd Sub\n\n
In most cases, the compiler will be able to catch invalid casts between incompatible value types or reference types.
\nHowever, the compiler will not be able to detect invalid casts to
Invalid casts will lead to unexpected behaviors or runtime errors such as
No issue is reported if the interface has no implementing class in the assembly.
\nTo prevent an InvalidCastException from raising during an explicit conversion, it is recommended to use the TryCast operator. When the\nconversion is not possible, the TryCast operator returns Nothing and will never raise an exception.
\nPublic Interface IMyInterface\nEnd Interface\n\nPublic Class Implementer\n Implements IMyInterface\nEnd Class\n\nPublic Class AnotherClass\nEnd Class\n\nModule Program\n Sub Main()\n Dim Another As New AnotherClass\n Dim x As IMyInterface = DirectCast(Another, IMyInterface) ' Noncompliant: InvalidCastException is being thrown\n End Sub\nEnd Module\n\n
\nPublic Interface IMyInterface\nEnd Interface\n\nPublic Class Implementer\n Implements IMyInterface\nEnd Class\n\nPublic Class AnotherClass\nEnd Class\n\nModule Program\n Sub Main()\n Dim Another As New AnotherClass\n Dim x = TryCast(Another, IMyInterface) ' Compliant: but will always be Nothing\n End Sub\nEnd Module\n\n
DirectCast\n operatorCType functionTryCast\n operatorThis vulnerability increases the likelihood that attackers are able to compute the cleartext of password hashes.
\nDuring the process of password hashing, an additional component, known as a \"salt,\" is often integrated to bolster the overall security. This salt,\nacting as a defensive measure, primarily wards off certain types of attacks that leverage pre-computed tables to crack passwords.
\nHowever, potential risks emerge when the salt is deemed insecure. This can occur when the salt is consistently the same across all users or when it\nis too short or predictable. In scenarios where users share the same password and salt, their password hashes will inevitably mirror each other.\nSimilarly, a short salt heightens the probability of multiple users unintentionally having identical salts, which can potentially lead to identical\npassword hashes. These identical hashes streamline the process for potential attackers to recover clear-text passwords. Thus, the emphasis on\nimplementing secure, unique, and sufficiently lengthy salts in password-hashing functions is vital.
\nDespite best efforts, even well-guarded systems might have vulnerabilities that could allow an attacker to gain access to the hashed passwords.\nThis could be due to software vulnerabilities, insider threats, or even successful phishing attempts that give attackers the access they need.
\nOnce the attacker has these hashes, they will likely attempt to crack them using a couple of methods. One is brute force, which entails trying\nevery possible combination until the correct password is found. While this can be time-consuming, having the same salt for all users or a short salt\ncan make the task significantly easier and faster.
\nIf multiple users have the same password and the same salt, their password hashes would be identical. This means that if an attacker successfully\ncracks one hash, they have effectively cracked all identical ones, granting them access to multiple accounts at once.
\nA short salt, while less critical than a shared one, still increases the odds of different users having the same salt. This might create clusters\nof password hashes with identical salt that can then be attacked as explained before.
\nWith short salts, the probability of a collision between two users' passwords and salts couple might be low depending on the salt size. The shorter\nthe salt, the higher the collision probability. In any case, using longer, cryptographically secure salt should be preferred.
\nTo securely store password hashes, it is a recommended to rely on key derivation functions that are computationally intensive. Examples of such\nfunctions are:
\nWhen they are used for password storage, using a secure, random salt is required.
\nHowever, those functions can also be used for other purposes such as master key derivation or password-based pre-shared key generation. In those\ncases, the implemented cryptographic protocol might require using a fixed salt to derive keys in a deterministic way. In such cases, using a fixed\nsalt is safe and accepted.
\nThe following code contains examples of hard-coded salts.
\n\nImports System.Security.Cryptography\n\nPublic Sub Hash(Password As String)\n Dim Salt As Byte() = Encoding.UTF8.GetBytes(\"salty\")\n Dim Hashed As New Rfc2898DeriveBytes(Password, Salt) ' Noncompliant\nEnd Sub\n\n
\nImports System.Security.Cryptography\n\nPublic Sub Hash(Password As String)\n Dim Hashed As New Rfc2898DeriveBytes(Password, 16, 10000, HashAlgorithmName.SHA256)\nEnd Sub\n\n
This code ensures that each user’s password has a unique salt value associated with it. It generates a salt randomly and with a length that\nprovides the required security level. It uses a salt length of at least 16 bytes (128 bits), as recommended by industry standards.
\nIn the case of the code sample, the class automatically takes care of generating a secure salt if none is specified.
\nHard-coding credentials in source code or binaries makes it easy for attackers to extract sensitive information, especially in distributed or\nopen-source applications. This practice exposes your application to significant security risks.
\nThis rule flags instances of hard-coded credentials used in database and LDAP connections. It looks for hard-coded credentials in connection\nstrings, and for variable names that match any of the patterns from the provided list.
\nIn the past, it has led to the following vulnerabilities:
\nCredentials should be stored in a configuration file that is not committed to the code repository, in a database, or managed by your cloud\nprovider’s secrets management service. If a password is exposed in the source code, it must be changed immediately.
\n\nDim username As String = \"admin\"\nDim password As String = \"Password123\" ' Noncompliant\nDim usernamePassword As String = \"user=admin&password=Password123\" ' Noncompliant\nDim url As String = \"scheme://user:Admin123@domain.com\" ' Noncompliant\n\n
\nDim username As String = \"admin\"\nDim password As String = GetEncryptedPassword()\nDim usernamePassword As String = String.Format(\"user={0}&password={1}\", GetEncryptedUsername(), GetEncryptedPassword())\nDim url As String = $\"scheme://{username}:{password}@domain.com\"\n\nDim url2 As String= \"http://guest:guest@domain.com\" ' Compliant\nConst Password_Property As String = \"custom.password\" ' Compliant\n\nFormatted SQL queries can be difficult to maintain, debug and can increase the risk of SQL injection when concatenating untrusted values into the\nquery. However, this rule doesn’t detect SQL injections, the goal is only to highlight complex/formatted queries.
\nThere is a risk if you answered yes to any of those questions.
\n\nPublic Sub SqlCommands(ByVal connection As SqlConnection, ByVal query As String, ByVal param As String)\n Dim sensitiveQuery As String = String.Concat(query, param)\n command = New SqlCommand(sensitiveQuery) ' Sensitive\n\n command.CommandText = sensitiveQuery ' Sensitive\n\n Dim adapter As SqlDataAdapter\n adapter = New SqlDataAdapter(sensitiveQuery, connection) ' Sensitive\nEnd Sub\n\nPublic Sub Foo(ByVal context As DbContext, ByVal query As String, ByVal param As String)\n Dim sensitiveQuery As String = String.Concat(query, param)\n context.Database.ExecuteSqlCommand(sensitiveQuery) ' Sensitive\n\n context.Query(Of User)().FromSql(sensitiveQuery) ' Sensitive\nEnd Sub\n\n
\nPublic Sub Foo(ByVal context As DbContext, ByVal value As String)\n context.Database.ExecuteSqlCommand(\"SELECT * FROM mytable WHERE mycol=@p0\", value) ' Compliant, the query is parameterized\nEnd Sub\n\n
There is no good excuse for an empty class. If it’s being used simply as a common extension point, it should be replaced with an\ninterface. If it was stubbed in as a placeholder for future development it should be fleshed-out. In any other case, it should be\neliminated.
\nPublic Class Empty ' Noncompliant\n\nEnd Class\n\n
\nPublic Interface IEmpty\n\nEnd Interface\n\n
Command, Message, Event, or Query are ignored as messaging\n libraries often use them.System.Exception are ignored; even an empty Exception class can provide helpful information by its type name\n alone.System.Attribute and classes annotated with attributes are ignored.PageModel class used in ASP.NET Core Razor Pages — are ignored.\nImports Microsoft.AspNetCore.Mvc.RazorPages\n\nPublic Class EmptyPageModel ' Compliant - an empty PageModel can be fully functional, the VB code can be in the vbhtml file\n Inherits PageModel\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2094.json", "content": "{\n \"title\": \"Classes should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2094\",\n \"sqKey\": \"S2094\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2166.html", "content": "
Clear, communicative naming is important in code. It helps maintainers and API users understand the intentions for and uses of a unit of code.\nUsing \"exception\" in the name of a class that does not extend Exception or one of its subclasses is a clear violation of the expectation\nthat a class' name will indicate what it is and/or does.
\nPublic Class FruitException ' Noncompliant - this has nothing to do with Exception\n Private expected As Fruit\n Private unusualCharacteristics As String\n Private appropriateForCommercialExploitation As Boolean\n ' ...\nEnd Class\n\nPublic Class CarException ' Noncompliant - does not derive from any Exception-based class\n Public Sub New(message As String, inner As Exception)\n ' ...\n End Sub\nEnd Class\n\n
\nPublic Class FruitSport ' Compliant - class name does not end with 'Exception'\n Private expected As Fruit\n Private unusualCharacteristics As String\n Private appropriateForCommercialExploitation As Boolean\n ' ...\nEnd Class\n\nPublic Class CarException Inherits Exception ' Compliant - correctly extends System.Exception\n Public Sub New(message As String, inner As Exception)\n MyBase.New(message, inner)\n ' ...\n End Sub\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2166.json", "content": "{\n \"title\": \"Classes named like \\\"Exception\\\" should extend \\\"Exception\\\" or a subclass\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\",\n \"error-handling\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2166\",\n \"sqKey\": \"S2166\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2178.html", "content": "
Short-circuit evaluation is an evaluation strategy for
VB.NET provides logical operators that implement short-circuiting evaluations AndAlso and OrElse, as well as the\nnon-short-circuiting versions And and Or. Unlike short-circuiting operators, the non-short-circuiting operators evaluate\nboth operands and afterward perform the logical operation.
For example False AndAlso FunctionCall always results in False even when the FunctionCall invocation would\nraise an exception. In contrast, False And FunctionCall also evaluates FunctionCall, and results in an exception if\nFunctionCall raises an exception.
Similarly, True OrElse FunctionCall always results in True, no matter what the return value of FunctionCall\nwould be.
The use of non-short-circuit logic in a boolean context is likely a mistake, one that could cause serious program errors as conditions are\nevaluated under the wrong circumstances.
\n\nIf GetTrue() Or GetFalse() Then ' Noncompliant: both sides evaluated\nEnd If\n\n
\nIf GetTrue() OrElse GetFalse() Then ' Compliant: short-circuit logic used\nEnd If\n\n
To prevent potential deadlocks in an application, it is crucial to release any locks that are\nacquired within a method along all possible execution paths.
\nFailing to release locks properly can lead to potential deadlocks, where the lock might not be released, causing issues in the application.
\nThis rule specifically focuses on tracking the following types from the System.Threading namespace:
MonitorMutexReaderWriterLockReaderWriterLockSlimSpinLock An issue is reported when a lock is acquired within a method but not released on all paths.
\nIf the lock is never released within the method, no issue is raised, assuming that the callers will handle the release.
\nTo make sure that a lock is always released correctly, you can follow one of these two methods:
\nSyncLock\n statement with your lock object.Try-Finally\n statement and put the release of your lock object within a Finally block.\nClass Example\n Private obj As Object = New Object()\n\n Public Sub DoSomethingWithMonitor()\n Monitor.Enter(obj) ' Noncompliant: not all paths release the lock\n\n If IsInitialized() Then\n ' ...\n Monitor.Exit(obj)\n End If\n End Sub\nEnd Class\n\n
\nClass Example\n Private lockObj As ReaderWriterLockSlim = New ReaderWriterLockSlim()\n\n Public Sub DoSomethingWithReaderWriteLockSlim()\n lockObj.EnterReadLock() ' Noncompliant: not all paths release the lock\n If IsInitialized() Then\n ' ...\n lockObj.ExitReadLock()\n End If\n End Sub\nEnd Class\n\n
\nClass Example\n Private obj As Object = New Object()\n\n Public Sub DoSomethingWithMonitor()\n SyncLock obj ' Compliant: the lock will be released at the end of the SyncLock block\n If IsInitialized() Then\n ' ...\n End If\n End SyncLock\n End Sub\nEnd Class\n\n
\nClass Example\n Private lockObj As ReaderWriterLockSlim = New ReaderWriterLockSlim()\n\n Public Sub DoSomethingWithReaderWriteLockSlim()\n lockObj.EnterReadLock() ' Compliant: the lock will be released in the finally block\n\n Try\n If IsInitialized() Then\n ' ...\n End If\n Finally\n lockObj.ExitReadLock()\n End Try\n End Sub\nEnd Class\n\n
SyncLock\n statementFinally blockCalling ToString() on an object should always return a\nstring. Thus, overriding the ToString method should never return Nothing because it breaks the method’s implicit contract,\nand as a result the consumer’s expectations.
\nPublic Overrides Function ToString() As String\n Return Nothing ' Noncompliant\nEnd Function\n\n
\nPublic Overrides Function ToString() As String\n Return \"\"\nEnd Function\n\n
Calling a procedure with argument variables whose names match the procedure parameter names but in a different order can cause confusion. It could\nindicate a mistake in the arguments' order, leading to unexpected results.
\n\nPublic Function Divide(divisor As Integer, dividend As Integer) As Double\n Return divisor / dividend\nEnd Function\n\nPublic Sub DoTheThing()\n Dim divisor = 15\n Dim dividend = 5\n\n Dim result = Divide(dividend, divisor) ' Noncompliant: arguments' order doesn't match their respective parameter names\n '...\nEnd Sub\n\n
However, matching the procedure parameters' order contributes to clearer and more readable code:
\n\nPublic Function Divide(divisor As Integer, dividend As Integer) As Double\n Return divisor / dividend\nEnd Function\n\nPublic Sub DoTheThing()\n Dim divisor = 15\n Dim dividend = 5\n\n Dim result = Divide(divisor, dividend) ' Compliant\n '...\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2234.json", "content": "{\n \"title\": \"Arguments should be passed in the same order as the procedure parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2234\",\n \"sqKey\": \"S2234\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2257.html", "content": "
The use of a non-standard algorithm is dangerous because a determined attacker may be able to break the algorithm and compromise whatever data has\nbeen protected. Standard algorithms like AES, RSA, SHA, … should be used instead.
This rule tracks custom implementation of these types from System.Security.Cryptography namespace:
AsymmetricAlgorithmAsymmetricKeyExchangeDeformatterAsymmetricKeyExchangeFormatterAsymmetricSignatureDeformatterAsymmetricSignatureFormatterDeriveBytesHashAlgorithmICryptoTransformSymmetricAlgorithm\nPublic Class CustomHash ' Noncompliant\n Inherits HashAlgorithm\n\n Private fResult() As Byte\n\n Public Overrides Sub Initialize()\n fResult = Nothing\n End Sub\n\n Protected Overrides Function HashFinal() As Byte()\n Return fResult\n End Function\n\n Protected Overrides Sub HashCore(array() As Byte, ibStart As Integer, cbSize As Integer)\n fResult = If(fResult, array.Take(8).ToArray)\n End Sub\n\nEnd Class\n\n
\nDim mySHA256 As SHA256 = SHA256.Create()\n\n
Accessing a Nothing value will always throw a
Such termination might expose sensitive information that a malicious third party could exploit to, for instance, bypass security measures.
\nIn the following cases, the rule does not raise:
\nCalls to extension methods can still operate on Nothing values.
\nImports System.Diagnostics.CodeAnalysis\nImports System.Runtime.CompilerServices\nImports System.Text.RegularExpressions\n\nModule Program\n <Extension>\n Function RemoveVowels(Value As String) As String\n If Value Is Nothing Then\n Return Nothing\n End If\n Return Regex.Replace(Value, \"[aeoui]*\", \"\", RegexOptions.IgnoreCase)\n End Function\n\n Sub Main()\n Dim StrValue As String = Nothing\n Console.WriteLine(StrValue.RemoveVowels()) ' Compliant: 'RemoveVowels' is an extension method\n End Sub\nEnd Module\n\n
Unreachable code is not executed, thus Nothing values will never be accessed.
\nPublic Sub Method()\n Dim o As Object = Nothing\n If False Then\n o.ToString() ' Compliant: code is unreachable\n End If\nEnd Sub\n\n
Nullable analysis attributes enable\nthe developer to annotate methods with information about the null-state of its arguments. Thus, potential Nothing values validated by one\nof the following attributes will not raise:
It is important to note those attributes are only available starting .NET Core 3. As a workaround, it is possible to define those attributes\nmanually in a custom class:
\n\nPublic NotInheritable Class NotNullAttribute ' The alternative name 'ValidatedNotNullAttribute' is also supported\n Inherits Attribute\nEnd Class\n\nPublic Module Guard\n Public Sub CheckNotNull(Of T)(<NotNull> Value As T, Name As String)\n If Value Is Nothing Then Throw New ArgumentNullException(Name)\n End Sub\nEnd Module\n\nPublic Module Utils\n Public Function Normalize(Value As String) As String\n CheckNotNull(Value, nameof(Value)) ' Will throw if 'Value' is Nothing\n Return Value.ToUpper() ' Compliant: value is known to be not Nothing here\n End Function\nEnd Module\n\n
A value validated with Debug.Assert to not be\nNothing is safe to access.
\nImports System.Diagnostics\n\nPublic Sub Method(MyObject As Object)\n Debug.Assert(MyObject IsNot Nothing)\n MyObject.ToString() ' Compliant: 'MyObject' is known to be not Nothing here.\nEnd Sub\n\n
Like with null-analysis-attribute, potential Nothing values validated by one of the following IDE-specific attributes will not\nraise
\nImports System\nImports JetBrains.Annotations\n\nPublic Class Utils\n <TerminatesProgram>\n Public Sub TerminateProgram()\n Environment.FailFast(\"A catastrophic failure has occurred.\")\n End Sub\n\n Public Sub Method()\n Dim MyObject As Object = Nothing\n TerminateProgram()\n MyObject.ToString() ' Compliant: unreachable\n End Sub\nEnd Class\n
To fix the issue, the access of the Nothing value needs to be prevented by either:
NothingThe variable MyObject is equal to Nothing, meaning it has no value:
\nPublic Sub Method()\n Dim MyObject As Object = Nothing\n Console.WriteLine(MyObject.ToString) ' Noncompliant: 'MyObject' is always Nothing\nEnd Sub\n\n
The parameter Input might be Nothing as suggested by the if condition:
\nPublic Sub Method(Input As Object)\n If Input Is Nothing Then\n ' ...\n End If\n Console.WriteLine(Input.ToString) ' Noncompliant: 'Input' might be Nothing\nEnd Sub\n\n
Ensuring the variable MyObject has a value resolves the issue:
\nPublic Sub Method()\n Dim MyObject As New Object\n Console.WriteLine(MyObject.ToString) ' Compliant: 'MyObject' is not Nothing\nEnd Sub\n\n
Preventing the non-compliant code to be executed by returning early:
\n\nPublic Sub Method(Input As Object)\n If Input Is Nothing Then\n Return\n End If\n Console.WriteLine(Input.ToString) ' Compliant: if 'Input' is Nothing, this part is unreachable\nEnd Sub\n\n
Because parameter names could be changed during refactoring, they should not be spelled out literally in strings. Instead, use\nNameOf(), and the string that’s output will always be correct.
This rule raises an issue when any string in the Throw statement is an exact match for the name of one of the method parameters.
\nPublic Sub DoSomething(param As Integer, secondParam As String)\n If (param < 0)\n Throw New Exception(\"param\") ' Noncompliant\n End If\n If secondParam is Nothing\n Throw New Exception(\"secondParam should be valid\") ' Noncompliant\n End If\nEnd Sub\n\n
\nPublic Sub DoSomething(param As Integer, secondParam As String)\n If (param < 0)\n Throw New Exception(NameOf(param))\n End If\n If secondParam is Nothing\n Throw New Exception($\"{NameOf(secondParam)} should be valid\")\n End If\nEnd Sub\n\nThrow statement string, the rule will raise an issue only if the\n parameter name is at least 5 characters long. This is to avoid false positives.Shared coding conventions allow teams to collaborate efficiently. This rule checks that all namespace names match a provided regular\nexpression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression: ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?(\\.([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2}))*$
\nNamespace foo ' Noncompliant\nEnd Namespace\n\n
\nNamespace Foo ' Compliant\nEnd Namespace\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2304.json", "content": "{\n \"title\": \"Namespace names should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2304\",\n \"sqKey\": \"S2304\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2339.html", "content": "
Constant members are copied at compile time to the call sites, instead of being fetched at runtime.
\nAs an example, say you have a library with a constant Version member set to 1.0, and a client application linked to it.\nThis library is then updated and Version is set to 2.0. Unfortunately, even after the old DLL is replaced by the new one,\nVersion will still be 1.0 for the client application. In order to see 2.0, the client application would need to\nbe rebuilt against the new version of the library.
This means that you should use constants to hold values that by definition will never change, such as Zero. In practice, those cases\nare uncommon, and therefore it is generally better to avoid constant members.
This rule only reports issues on public constant fields, which can be reached from outside the defining assembly.
\n\nPublic Class Foo\n Public Const Version = 1.0 ' Noncompliant\nEnd Class\n\n
\nPublic Class Foo\n Public Shared ReadOnly Property Version = 1.0 ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2339.json", "content": "{\n \"title\": \"Public constant members should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2339\",\n \"sqKey\": \"S2339\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2340.html", "content": "
A Do ... Loop without a While or Until condition must be terminated by an unstructured Exit Do\nstatement. It is safer and more readable to use structured loops instead.
\nModule Module1\n Sub Main()\n Dim i = 1\n\n Do ' Non-Compliant\n If i = 10 Then\n Exit Do\n End If\n\n Console.WriteLine(i)\n\n i = i + 1\n Loop\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n For i = 1 To 9 ' Compliant\n Console.WriteLine(i)\n Next\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2340.json", "content": "{\n \"title\": \"\\\"Do\\\" loops should not be used without a \\\"While\\\" or \\\"Until\\\" condition\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2340\",\n \"sqKey\": \"S2340\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2342.html", "content": "
Shared naming conventions allow teams to collaborate efficiently. This rule checks that all enum names match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression for non-flags enums: ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$
\nPublic Enum foo ' Noncompliant\n FooValue = 0\nEnd Enum\n\n
With the default regular expression for flags enums: ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?s$
\n<Flags()>\nPublic Enum Option ' Noncompliant\n None = 0,\n Option1 = 1,\n Option2 = 2\nEnd Enum\n\n
\nPublic Enum Foo\n FooValue = 0\nEnd Enum\n\n
\n<Flags()>\nPublic Enum Options\n None = 0,\n Option1 = 1,\n Option2 = 2\nEnd Enum\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2342.json", "content": "{\n \"title\": \"Enumeration types should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2342\",\n \"sqKey\": \"S2342\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2343.html", "content": "
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all enumeration value names match a provided regular\nexpression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nEnum Foo\n fooValue ' Noncompliant\nEnd Enum\n\n
\nEnum Foo\n FooValue ' Compliant\nEnd Enum\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2343.json", "content": "{\n \"title\": \"Enumeration values should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2343\",\n \"sqKey\": \"S2343\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2344.html", "content": "
The information that an enumeration type is actually an enumeration or a set of flags should not be duplicated in its name.
\n\nEnum FooFlags ' Noncompliant\n Foo = 1\n Bar = 2\n Baz = 4\nEnd Enum\n\n
\nEnum Foo ' Compliant\n Foo = 1\n Bar = 2\n Baz = 4\nEnd Enum\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2344.json", "content": "{\n \"title\": \"Enumeration type names should not have \\\"Flags\\\" or \\\"Enum\\\" suffixes\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2344\",\n \"sqKey\": \"S2344\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2345.html", "content": "
When you annotate an Enum with the Enum members, but you should define the enumeration constants in powers of two (1, 2, 4, 8, and so on).\nAutomatic value initialization will set the first member to zero and increment the value by one for each subsequent member. As a result, you won’t be\nable to use the enum members with bitwise operators.
The default initialization of 0, 1, 2, 3, 4, … matches 0, 1, 2, 4, 8 … in the first three values, so no issue is\nreported if the first three members of the enumeration are not initialized.
Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on.
\n\n<Flags()>\nEnum FruitType ' Non-Compliant\n None\n Banana\n Orange\n Strawberry\nEnd Enum\n\nModule Module1\n Sub Main()\n Dim bananaAndStrawberry = FruitType.Banana Or FruitType.Strawberry\n Console.WriteLine(bananaAndStrawberry.ToString()) ' Will display only \"Strawberry\"\n End Sub\nEnd Module\n\n
\n<Flags()>\nEnum FruitType ' Compliant\n None = 0\n Banana = 1\n Orange = 2\n Strawberry = 4\nEnd Enum\n\nModule Module1\n Sub Main()\n Dim bananaAndStrawberry = FruitType.Banana Or FruitType.Strawberry\n Console.WriteLine(bananaAndStrawberry.ToString()) ' Will display \"Banana, Strawberry\"\n End Sub\nEnd Module\n\n
An enumeration can be decorated with the FlagsAttribute to\nindicate that it can be used as a bit field: a set of flags, that can be independently set and\nreset.
\nFor example, the following definition of the day of the week:
\n\n<Flags()>\nEnum Days\n Monday = 1 ' 0b00000001\n Tuesday = 2 ' 0b00000010\n Wednesday = 4 ' 0b00000100\n Thursday = 8 ' 0b00001000\n Friday = 16 ' 0b00010000\n Saturday = 32 ' 0b00100000\n Sunday = 64 ' 0b01000000\nEnd Enum\n\n
allows to define special set of days, such as WeekDays and Weekend using the Or operator:
\n<Flags()>\nEnum Days\n ' ...\n None = 0 ' 0b00000000\n Weekdays = Monday Or Tuesday Or Wednesday Or Thursday Or Friday ' 0b00011111\n Weekend = Saturday Or Sunday ' 0b01100000\n All = Weekdays Or Weekend ' 0b01111111\nEnd Enum\n\n
These can be used to write more expressive conditions, taking advantage of
\nDim someDays = Days.Wednesday | Days.Weekend ' 0b01100100\nsomeDays.HasFlag(Days.Wednesday) ' someDays contains Wednesday\n\nDim mondayAndWednesday = Days.Monday Or Days.Wednesday\nsomeDays.HasFlag(mondayAndWednesday) ' someDays contains Monday and Wednesday\nsomeDays.HasFlag(Days.Monday) OrElse someDays.HasFlag(Days.Wednesday) ' someDays contains Monday or Wednesday\nsomeDays And Days.Weekend <> Days.None ' someDays overlaps with the weekend\nsomeDays And Days.Weekdays = Days.Weekdays ' someDays is only made of weekdays\n\n
Consistent use of None in flag enumerations indicates that all flag values are cleared. The value 0 should not be used to indicate any\nother state since there is no way to check that the bit 0 is set.
\n<Flags()>\nEnum Days\n Monday = 0 ' 0 is used to indicate Monday\n Tuesday = 1\n Wednesday = 2\n Thursday = 4\n Friday = 8\n Saturday = 16\n Sunday = 32\n Weekdays = Monday Or Tuesday Or Wednesday Or Thursday Or Friday\n Weekend = Saturday Or Sunday\n All = Weekdays Or Weekend\nEnd Enum\n\nDim someDays = Days.Wednesday Or Days.Thursday\nsomeDays & Days.Tuesday = Days.Tuesday ' False, because someDays doesn't contains Tuesday\nsomeDays & Days.Monday = Days.Monday ' True, even though someDays doesn't contains Monday!\nsomeDays.HasFlag(Days.Monday) ' Same issue as above\n\n
\n<Flags()>\nEnum FruitType\n Void = 0 ' Non-Compliant\n Banana = 1\n Orange = 2\n Strawberry = 4\nEnd Enum\n\n
\n<Flags()>\nEnum FruitType\n None = 0 ' Compliant\n Banana = 1\n Orange = 2\n Strawberry = 4\nEnd Enum\n\n
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all even handler names match a provided regular\nexpression.
\nThe default configuration is:
\nEvent handlers with a handles clause and two-parameter methods with EventArgs second parameter are covered by this\nrule.
With the default regular expression ^(([a-z][a-z0-9]*)?([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?_)?([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nModule Module1\n Sub subject__SomeEvent() Handles X.SomeEvent ' Noncompliant - two underscores\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub subject_SomeEvent() Handles X.SomeEvent ' Compliant\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2347.json", "content": "{\n \"title\": \"Event handlers should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2347\",\n \"sqKey\": \"S2347\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2348.html", "content": "
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all even names match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nClass Foo\n Event fooEvent() ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Event FooEvent() ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2348.json", "content": "{\n \"title\": \"Events should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2348\",\n \"sqKey\": \"S2348\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2349.html", "content": "
\"After\" and \"Before\" prefixes or suffixes should not be used to indicate pre and post events. The concepts of before and after should be given to\nevents using the present and past tense.
\n\nClass Foo\n Event BeforeClose() ' Noncompliant\n Event AfterClose() ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Event Closing() ' Compliant\n Event Closed() ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2349.json", "content": "{\n \"title\": \"Event names should not have \\\"Before\\\" or \\\"After\\\" as a prefix or suffix\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2349\",\n \"sqKey\": \"S2349\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2352.html", "content": "
Indexed properties are meant to represent access to a logical collection. When multiple parameters are required, this design guideline may be\nviolated, and refactoring the property into a method is preferable.
\n\nModule Module1\n ReadOnly Property Sum(ByVal a As Integer, ByVal b As Integer) ' Noncompliant\n Get\n Return a + b\n End Get\n End Property\nEnd Module\n\n
\nModule Module1\n Function Sum(ByVal a As Integer, ByVal b As Integer) ' Compliant\n Return a + b\n End Function\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2352.json", "content": "{\n \"title\": \"Indexed properties with more than one parameter should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2352\",\n \"sqKey\": \"S2352\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2354.html", "content": "
To improve the code readability, the explicit line continuation character, _, should not be used. Instead, it is better to break lines\nafter an operator.
\nModule Module1\n Sub Main()\n ' Noncompliant\n Console.WriteLine(\"Hello\" _\n & \"world\")\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n\n Console.WriteLine(\"Hello\" &\n \"world\")\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2354.json", "content": "{\n \"title\": \"Line continuations should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2354\",\n \"sqKey\": \"S2354\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2355.html", "content": "
Array literals are more compact than array creation expressions.
\n\nModule Module1\n Sub Main()\n Dim foo = New String() {\"a\", \"b\", \"c\"} ' Noncompliant\n End Sub\nEnd Module\n\n\nModule Module1\n Sub Main()\n Dim foo = {\"a\", \"b\", \"c\"} ' Compliant\n End Sub\nEnd Module\n\n\n"
},
{
"path": "analyzers/rspec/vbnet/S2355.json",
"content": "{\n \"title\": \"Array literals should be used instead of array creation expressions\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2355\",\n \"sqKey\": \"S2355\",\n \"scope\": \"Main\",\n \"quickfix\": \"covered\"\n}\n"
},
{
"path": "analyzers/rspec/vbnet/S2357.html",
"content": "Fields should not be part of an API, and therefore should always be private. Indeed, they cannot be added to an interface for instance, and\nvalidation cannot be added later on without breaking backward compatibility. Instead, developers should encapsulate their fields into properties.\nExplicit property getters and setters can be introduced for validation purposes or to smooth the transition to a newer system.
\n\nClass Foo\n Public Foo = 42 ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Public Property Foo = 42 ' Compliant\nEnd Class\n\n
Shared and Const fields are ignored.
The ... IsNot ... syntax is more compact and more readable than the Not ... Is ... syntax.
\nModule Module1\n Sub Main()\n Dim a = Not \"a\" Is Nothing ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim a = \"a\" IsNot Nothing ' Compliant\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2358.json", "content": "{\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2358\",\n \"sqKey\": \"S2358\",\n \"scope\": \"Main\",\n \"quickfix\": \"covered\",\n \"title\": \"\\\"IsNot\\\" should be used instead of \\\"Not ... Is ...\\\"\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2359.html", "content": "
Prefer the use of Try ... Catch blocks instead of On Error statements.
Visual Basic .NET and Visual Basic 2005 offer structured exception handling that provides a powerful, more readable alternative to the On\nError Goto error handling from previous versions of Microsoft Visual Basic. Structured exception handling is more powerful because it allows\nyou to nest error handlers inside other error handlers within the same procedure. Furthermore, structured exception handling uses a block syntax\nsimilar to the If...Else...End If statement. This makes Visual Basic .NET and Visual Basic 2005 code more readable and easier to\nmaintain.
\nSub DivideByZero()\n On Error GoTo nextstep\n Dim result As Integer\n Dim num As Integer\n num = 100\n result = num / 0\nnextstep:\n System.Console.WriteLine(\"Error\")\nEnd Sub\n\n
\nSub DivideByZero()\n Try\n Dim result As Integer\n Dim num As Integer\n num = 100\n result = num / 0\n Catch\n System.Console.WriteLine(\"Error\")\n End Try\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2359.json", "content": "{\n \"title\": \"\\\"On Error\\\" statements should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2359\",\n \"sqKey\": \"S2359\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2360.html", "content": "
The overloading mechanism should be used in place of optional parameters for several reasons:
\n\nSub Notify(ByVal Company As String, Optional ByVal Office As String = \"QJZ\") ' Noncompliant\n\nEnd Sub\n\n
\nSub Notify(ByVal Company As String)\n Notify(Company, \"QJZ\")\nEnd Sub\n\nSub Notify(ByVal Company As String, ByVal Office As String)\n\nEnd Sub\n\n
The rule ignores non externally visible methods.
\n\n" }, { "path": "analyzers/rspec/vbnet/S2360.json", "content": "{\n \"title\": \"Optional parameters should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2360\",\n \"sqKey\": \"S2360\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2362.html", "content": "Shared coding conventions allow teams to collaborate efficiently. This rule checks that all Private Const field names comply with the\nprovided regular expression.
The default configuration is:
\n_foo, s_fooWith the default regular expression ^(s_|_)?[a-z][a-z0-9]*([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nModule Module1\n Private Const Foo = 0 ' Noncompliant\nEnd Module\n\n
\nModule Module1\n Private Const foo = 0 ' Compliant\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2362.json", "content": "{\n \"title\": \"Private constants should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2362\",\n \"sqKey\": \"S2362\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2363.html", "content": "
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all Private Shared ReadOnly field names comply\nwith the provided regular expression.
The default configuration is:
\n_foo, s_fooWith the default regular expression ^(s_|_)?[a-z][a-z0-9]*([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nClass Foo\n Private Shared ReadOnly Foo As Integer ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Private Shared ReadOnly foo As Integer ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2363.json", "content": "{\n \"title\": \"\\\"Private Shared ReadOnly\\\" fields should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2363\",\n \"sqKey\": \"S2363\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2364.html", "content": "
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all Private field names match the provided\nregular expression.
Note that this rule does not apply to Private Shared ReadOnly fields, which are checked by another rule.
The default configuration is:
\n_foo, s_fooWith the default regular expression ^(s_|_)?[a-z][a-z0-9]*([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nClass Foo\n Private Foo As Integer ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Private foo As Integer ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2364.json", "content": "{\n \"title\": \"\\\"Private\\\" fields should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2364\",\n \"sqKey\": \"S2364\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2365.html", "content": "
Most developers expect property access to be as efficient as field access. However, if a property returns a copy of an array or collection, it will\nbe much slower than a simple field access, contrary to the caller’s likely expectations. Therefore, such properties should be refactored into methods\nso that callers are not surprised by the unexpectedly poor performance.
\nThis rule tracks calls to the following methods inside properties:
\n\n\nPrivate fFoo As New List(Of String) From {\"a\", \"b\", \"c\"}\nPrivate fBar As String() = {\"a\", \"b\", \"c\"}\n\nPublic ReadOnly Property Foo() As IEnumerable(Of String) ' Noncompliant: collection fFoo is copied\n Get\n Return fFoo.ToList()\n End Get\nEnd Property\n\nPublic ReadOnly Property Bar() As IEnumerable(Of String) ' Noncompliant: array fBar is copied\n Get\n Return DirectCast(fBar.Clone(), String())\n End Get\nEnd Property\n\n\nPrivate fFoo As New List(Of String) From {\"a\", \"b\", \"c\"}\nPrivate fBar As String() = {\"a\", \"b\", \"c\"}\n\nPublic Function GetFoo() As IEnumerable(Of String)\n Return fFoo.ToList()\nEnd Function\n\nPublic Function GetBar() As IEnumerable(Of String)\n Return DirectCast(fBar.Clone(), String())\nEnd Function\n\nShared coding conventions allow teams to collaborate efficiently. This rule checks that property names match a provided regular expression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nModule Module1\n Public Property foo As Integer ' Noncompliant\nEnd Module\n\n
\nModule Module1\n Public Property Foo As Integer ' Compliant\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2366.json", "content": "{\n \"title\": \"Properties should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2366\",\n \"sqKey\": \"S2366\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2367.html", "content": "
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all non-private Const field names comply with\nthe provided regular expression.
The default configuration is the one recommended by Microsoft:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nModule Module1\n Public Const foo = 0 ' Noncompliant\nEnd Module\n\n
\nModule Module1\n Public Const Foo = 0 ' Compliant\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2367.json", "content": "{\n \"title\": \"Non-private constants should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2367\",\n \"sqKey\": \"S2367\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2368.html", "content": "
Using multidimensional and
When these methods are exposed to external users, it requires advanced language knowledge for effective usage.
\nDetermining the appropriate data to pass to these parameters may not be intuitive.
\n\nPublic Class Program\n Public Sub WriteMatrix(matrix As Integer()()) ' Noncompliant: data type is not intuitive\n ' ...\n End Sub\nEnd Class\n\n
In this example, it cannot be inferred easily what the matrix should look like. Is it a 2x2 Matrix or even a triangular Matrix?
\nUsing a collection, data structure, or class that provides a more suitable representation of the required data is recommended instead of a\nmultidimensional array or jagged array to enhance code readability.
\n\nPublic Class Matrix2x2\n ' ...\nEnd Class\n\nPublic Class Program\n Public Sub WriteMatrix(matrix As Matrix2x2) ' Compliant: data type is intuitive\n ' ...\n End Sub\nEnd Class\n\n
As a result, avoiding exposing such methods to external users is recommended.
\nHowever, using multidimensional and jagged array method parameters internally, such as in private or internal methods or\nwithin internal classes, is compliant since they are not publicly exposed.
\nPublic Class FirstClass\n Private Sub UpdateMatrix(matrix As Integer()()) ' Compliant: method is private\n ' ...\n End Sub\nEnd Class\n\nFriend Class SecondClass\n Public Sub UpdateMatrix(matrix As Integer()()) ' Compliant: class is internal\n ' ...\n End Sub\nEnd Class\n\n
Shared coding conventions allow teams to collaborate efficiently. This rule checks that all non-private fields names match a provided regular\nexpression.
\nNote that this rule does not apply to non-private Shared ReadOnly fields, for which there is another rule.
The default configuration is:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nClass Foo\n Public foo As Integer ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Public Foo As Integer ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2369.json", "content": "{\n \"title\": \"Non-private fields should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2369\",\n \"sqKey\": \"S2369\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2370.html", "content": "
Shared naming conventions allow teams to collaborate efficiently. This rule checks that all non-private Shared ReadOnly fields names\nmatch a provided regular expression.
The default configuration is:
\nWith the default regular expression ^([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?$:
\nClass Foo\n Public Shared ReadOnly foo As Integer ' Noncompliant\nEnd Class\n\n
\nClass Foo\n Public Shared ReadOnly Foo As Integer ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2370.json", "content": "{\n \"title\": \"Non-private \\\"Shared ReadOnly\\\" fields should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2370\",\n \"sqKey\": \"S2370\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2372.html", "content": "
Property getters should be simple operations that are always safe to call. If exceptions need to be thrown, it is best to convert the property to a\nmethod.
\nIt is valid to throw exceptions from indexed property getters and from property setters, which are not detected by this rule.
\n\nModule Module1\n Public Property Foo() As Integer\n Get\n Throw New Exception ' Non-Compliant\n End Get\n Set(ByVal value As Integer)\n ' ... some code ...\n End Set\n End Property\nEnd Module\n\n
\nModule Module1\n Sub SetFoo(ByVal value As Integer) ' Compliant\n ' ... some code ...\n End Sub\nEnd Module\n\n
No issue is raised when the thrown exception derives from or is of type NotImplementedException, NotSupportedException or\nInvalidOperationException.
This rule is deprecated; use {rule:vbnet:S119} instead.
\nShared naming conventions allow teams to collaborate efficiently. This rule checks that all generic type parameter names match a provided regular\nexpression.
\nThe default configuration is the one recommended by Microsoft:
\nWith the default parameter value ^T(([A-Z]{1,3}[a-z0-9]+)*([A-Z]{2})?)?$:
\nPublic Class Foo(Of t) ' Noncompliant\nEnd Class\n\n
\nPublic Class Foo(Of T) ' Compliant\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2373.json", "content": "{\n \"title\": \"Generic type parameter names should comply with a naming convention\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"IDENTIFIABLE\"\n },\n \"status\": \"deprecated\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2373\",\n \"sqKey\": \"S2373\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2374.html", "content": "
Unsigned integers have different arithmetic operators than signed ones - operators that few developers understand. Therefore, signed types should\nbe preferred where possible.
\n\nModule Module1\n Sub Main()\n Dim foo1 As UShort ' Noncompliant\n Dim foo2 As UInteger ' Noncompliant\n Dim foo3 As ULong ' Noncompliant\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim foo1 As Short\n Dim foo2 As Integer\n Dim foo3 As Long\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2374.json", "content": "{\n \"title\": \"Signed types should be preferred to unsigned ones\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"HIGH\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Critical\",\n \"ruleSpecification\": \"RSPEC-2374\",\n \"sqKey\": \"S2374\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2375.html", "content": "
Using the With statement for a series of calls to the same object makes the code more readable.
With the default value of 6:
\n\nModule Module1\n Dim product = New With {.Name = \"paperclips\", .RetailPrice = 1.2, .WholesalePrice = 0.6, .A = 0, .B = 0, .C = 0}\n\n Sub Main()\n product.Name = \"\" ' Noncompliant\n product.RetailPrice = 0\n product.WholesalePrice = 0\n product.A = 0\n product.B = 0\n product.C = 0\n End Sub\nEnd Module\n\n\nModule Module1\n Dim product = New With {.Name = \"paperclips\", .RetailPrice = 1.2, .WholesalePrice = 0.6, .A = 0, .B = 0, .C = 0}\n\n Sub Main()\n With product\n .Name = \"\"\n .RetailPrice = 0\n .WholesalePrice = 0\n .A = 0\n .B = 0\n .C = 0\n End With\n End Sub\nEnd Module\n\n\n"
},
{
"path": "analyzers/rspec/vbnet/S2375.json",
"content": "{\n \"title\": \"\\\"With\\\" statements should be used for a series of calls to the same object\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2375\",\n \"sqKey\": \"S2375\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/vbnet/S2376.html",
"content": "Properties with only setters are confusing and counterintuitive. Instead, a property getter should be added if possible, or the property should be\nreplaced with a setter method.
\n\nModule Module1\n WriteOnly Property Foo() As Integer ' Non-Compliant\n Set(ByVal value As Integer)\n ' ... some code ...\n End Set\n End Property\nEnd Module\n\n
\nModule Module1\n Sub SetFoo(ByVal value As Integer) ' Compliant\n ' ... some code ...\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2376.json", "content": "{\n \"title\": \"Write-only properties should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"20min\"\n },\n \"tags\": [\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2376\",\n \"sqKey\": \"S2376\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2387.html", "content": "
This rule is deprecated, and will eventually be removed.
\nHaving a variable with the same name in two unrelated classes is fine, but do the same thing within a class hierarchy and you’ll get confusion at\nbest, chaos at worst.
\n\nPublic Class Fruit\n\n Protected Ripe As Season\n Protected Flesh As Color\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n Private Ripe As Boolean ' Noncompliant\n Private Shared FLESH As Color ' Noncompliant\n\n ' ...\n\nEnd Class\n\n
\nPublic Class Fruit\n\n Protected Ripe As Season\n Protected Flesh As Color\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n Private Riped As Boolean\n Private Shared FLESH_COLOR As Color ' Noncompliant\n\n ' ...\n\nEnd Class\n\n
This rule ignores same-name fields that are Shared in both the parent and child classes. It also ignores Private parent\nclass fields and fields explicitly declared as Shadows, but in all other such cases, the child class field should be renamed.
\nPublic Class Fruit\n\n Private Ripe As Season\n Protected Flesh As Color\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n Private Ripe As Season ' Compliant as parent field 'Ripe' is not visible from Raspberry anyway\n Protected Shadows Flesh As Color ' Compliant as the intention is explicitly declared\n\n ' ...\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2387.json", "content": "{\n \"title\": \"Child class fields should not shadow parent class fields\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"BLOCKER\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"deprecated\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Blocker\",\n \"ruleSpecification\": \"RSPEC-2387\",\n \"sqKey\": \"S2387\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2429.html", "content": "
The ... = {} syntax is more compact, more readable and less error-prone.
\nModule Module1\n Sub Main()\n Dim foo(1) As String ' Noncompliant\n foo(0) = \"foo\"\n foo(1) = \"bar\"\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim foo = {\"foo\", \"bar\"} ' Compliant\n End Sub\nEnd Module\n\n\n"
},
{
"path": "analyzers/rspec/vbnet/S2429.json",
"content": "{\n \"title\": \"Arrays should be initialized using the \\\"... \\u003d {}\\\" syntax\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2429\",\n \"sqKey\": \"S2429\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/vbnet/S2437.html",
"content": "Certain
Specifically, using And -1 with any value always results in the original value.
That is because the binary representation of -1 on a Integer or Long, is based on &B111…111.
Performing And between a value and &B111…111 means applying the And operator to each bit of the value\nand the bit 1, resulting in a value equal to the provided one, bit by bit.
\nanyValue And -1 ' Noncompliant\nanyValue ' Compliant\n\n
Similarly, anyValue Or 0 always results in anyValue, because the binary representation of 0 is always\n&B000…000 and the Or operator returns its first input when the second is 0.
\nanyValue Or 0 ' Noncompliant\nanyValue ' Compliant\n\n
The same applies to anyValue Xor 0: the Xor operator returns 1 when its two input bits are different\n(1 and 0 or 0 and 1) and returns 0 when its two input bits are the same (both\n0 or both 1). When Xor is applied with 0, the result would be 1 if the other input is\n1, because the two input bits are different, and 0 if the other input bit is 0, because the two input are the\nsame. That results in returning anyValue.
\nanyValue Xor 0 ' Noncompliant\nanyValue ' Compliant\n\n
The instance passed to the SyncLock statement\nshould be a dedicated private field.
If the instance representing an exclusively acquired lock is publicly accessible, another thread in another part of the program could accidentally\nattempt to acquire the same lock. This increases the likelihood of deadlocks.
\nFor example, a string should never be used for locking. When a string is
Instead, a dedicated private Lock object\ninstance (or object instance, for frameworks before .Net 9) should be used for locking. This minimizes access to the lock instance and\ntherefore prevents accidential lock sharing.
The following objects are considered potentially prone to accidental lock sharing:
\n\nPublic Sub MyLockingMethod()\n SyncLock Me 'Noncompliant\n ' ...\n End SyncLock\nEnd Sub\n\n
\nPrivate lockObj As New Object()\nPublic Sub MyLockingMethod()\n SyncLock lockObj\n ' ...\n End SyncLock\nEnd Sub\n\n
Conditional expressions which are always true or false can lead to
In the case below, the call of Dispose() never happens.
\nDim a = False\n\nIf a Then\n Dispose() ' Never reached\nEnd If\n\n
This rule will not raise an issue in either of these cases:
\nconst bool\nConst debug = False\n'...\nIf debug Then\n ' Print something\nEnd If\n\n
true or false.In these cases, it is obvious the code is as intended.
\nThe conditions should be reviewed to decide whether:
\n\nPublic Sub Sample(ByVal b As Boolean)\n Dim a = False\n If a Then ' Noncompliant: The true branch is never reached\n DoSomething() ' Never reached\n End If\n\n If Not a OrElse b Then ' Noncompliant: \"not a\" is always \"True\" and the false branch is never reached\n DoSomething()\n Else\n DoSomethingElse() ' Never reached\n End If\n\n Dim c = \"xxx\"\n Dim res = If(c, \"value\") ' Noncompliant: d is always not Nothing, \"value\" is never used\nEnd Sub\n\n
\nPublic Sub Sample(ByVal b As Boolean)\n Dim a = False\n If Foo(a) Then ' Condition was updated\n DoSomething()\n End If\n\n If b Then ' Parts of the condition were removed.\n DoSomething()\n Else\n DoSomethingElse()\n End If\n\n Dim c = \"xxx\"\n Dim res = c ' \"value\" was removed\nEnd Sub\n\n
Gratuitous boolean expressions are conditions that do not change the evaluation of a program. This issue can indicate logical errors and affect the\ncorrectness of an application, as well as its maintainability.
\nControl flow constructs like if-statements allow the programmer to direct the flow of a program depending on a boolean expression.\nHowever, if the condition is always true or always false, only one of the branches will ever be executed. In that case, the control flow construct and\nthe condition no longer serve a purpose; they become gratuitous.
The presence of gratuitous conditions can indicate a logical error. For example, the programmer intended to have the program branch into\ndifferent paths but made a mistake when formulating the branching condition. In this case, this issue might result in a bug and thus affect the\nreliability of the application. For instance, it might lead to the computation of incorrect results.
\nAdditionally, gratuitous conditions and control flow constructs introduce unnecessary complexity. The source code becomes harder to understand, and\nthus, the application becomes more difficult to maintain.
\nThis rule looks for operands of a boolean expression never changing the result of the expression. It also applies to the Nothing.
\nDim d As String = Nothing\nDim v1 = If(d, \"value\")\n\n
This rule will not raise an issue in either of these cases:
\nConst bool\nConst debug = False\n'...\nIf debug Then\n ' Print something\nEnd If\n\n
True or False.In these cases, it is obvious the code is as intended.
\nGratuitous boolean expressions are suspicious and should be carefully removed from the code.
\nFirst, the boolean expression in question should be closely inspected for logical errors. If a mistake was made, it can be corrected so the\ncondition is no longer gratuitous.
\nIf it becomes apparent that the condition is actually unnecessary, it can be removed. The associated control flow construct (e.g., the\nif-statement containing the condition) will be adapted or even removed, leaving only the necessary branches.
\nPublic Sub Sample(ByVal b As Boolean, ByVal c As Boolean)\n Dim a = True\n If a Then ' Noncompliant: \"a\" is always \"true\"\n DoSomething()\n End If\n\n If b AndAlso a Then ' Noncompliant: \"a\" is always \"true\"\n DoSomething()\n End If\n\n If c OrElse Not a Then ' Noncompliant: \"Not a\" is always \"false\"\n DoSomething()\n End If\n\n Dim d As String = Nothing\n Dim v1 = If(d, \"value\") ' Noncompliant: \"d\" is always Nothing and v1 is always \"value\".\n Dim v2 = If(s, d) ' Noncompliant: \"d\" is always Nothing and v2 is always equal to s.\nEnd Sub\n\n
\nPublic Sub Sample(ByVal b As Boolean, ByVal c As Boolean, ByVal s As String)\n Dim a = IsAllowed()\n If a Then ' Compliant\n DoSomething()\n End If\n\n If b AndAlso a Then ' Compliant\n DoSomething()\n End If\n\n If c OrElse Not a Then ' Compliant\n DoSomething()\n End If\n\n Dim d As String = GetStringData()\n Dim v1 = If(d, \"value\") ' Compliant\n Dim v2 = If(s, d) ' Compliant\nEnd Sub\n\n
In Windows, \"Everyone\" group is similar and includes all members of the Authenticated Users group as well as the built-in Guest account, and\nseveral other built-in security accounts.
\nGranting permissions to this category can lead to unintended access to files or directories that could allow attackers to obtain sensitive\ninformation, disrupt services or elevate privileges.
\nWhen file or directory permissions grant access to all users on a system (often represented as \"others\" or \"everyone\" in permission models),\nattackers who gain access to any user account can read sensitive files containing credentials, configuration data, API keys, database passwords,\npersonal information, or proprietary business data. This exposure can lead to data breaches, identity theft, compliance violations, and competitive\ndisadvantage.
\nGranting write permissions to broad user categories allows any user on the system to modify or delete critical files and directories. Attackers or\ncompromised low-privileged accounts can corrupt application data, modify configuration files to alter system behavior or disrupt services, or delete\nimportant resources, leading to service outages, system instability, data loss, and denial of service.
\nWhen executable files or scripts have overly permissive permissions, especially when combined with special permission bits that allow programs to\nexecute with the permissions of the file owner or group rather than the executing user, attackers can replace legitimate executables with malicious\ncode. When these modified files are executed by privileged users or processes, the attacker’s code runs with elevated privileges, potentially enabling\nthem to escalate from a low-privileged account to root or administrator access, install backdoors, or pivot to other systems in the network.
\nReplace the AccessControlType.Allow with AccessControlType.Deny when creating file system access rules for the \"Everyone\"\ngroup. This explicitly denies permissions rather than granting them, ensuring that broad user groups cannot access the file.
\nDim unsafeAccessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.FullControl, AccessControlType.Allow)\n\nDim fileSecurity = File.GetAccessControl(\"path\")\nfileSecurity.AddAccessRule(unsafeAccessRule) ' Noncompliant\nFile.SetAccessControl(\"fileName\", fileSecurity)\n\n
\nDim safeAccessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.FullControl, AccessControlType.Deny)\n\nDim fileSecurity = File.GetAccessControl(\"path\")\nfileSecurity.AddAccessRule(safeAccessRule)\nFile.SetAccessControl(\"path\", fileSecurity)\n\n
Use AccessControlType.Deny instead of AccessControlType.Allow when setting access rules for the \"Everyone\" group. This\nprevents the broad group from having write or full control access to files.
\nDim accessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.Write, AccessControlType.Allow)\nDim fileInfo = new FileInfo(\"path\")\nDim fileSecurity = fileInfo.GetAccessControl()\n\nfileSecurity.SetAccessRule(accessRule) ' Noncompliant\nfileInfo.SetAccessControl(fileSecurity)\n\n
\nDim accessRule = new FileSystemAccessRule(\"Everyone\", FileSystemRights.FullControl, AccessControlType.Deny)\nDim fileInfo = new FileInfo(\"path\")\nDim fileSecurity = fileInfo.GetAccessControl()\n\nfileSecurity.SetAccessRule(accessRule)\nfileInfo.SetAccessControl(fileSecurity)\n\n
Avoid setting permissions that grant read, write, or execute access to \"others\" (all users). Instead, restrict permissions to the file owner or\nspecific groups. Use FileAccessPermissions.UserExecute or other restrictive permission flags that limit access to the owner only.
\nDim fsEntry = UnixFileSystemInfo.GetFileSystemEntry(\"path\")\nfsEntry.FileAccessPermissions = FileAccessPermissions.OtherReadWriteExecute ' Noncompliant\n\n
\nDim fsEntry = UnixFileSystemInfo.GetFileSystemEntry(\"path\")\nfsEntry.FileAccessPermissions = FileAccessPermissions.UserExecute\n\n
Most checks against an IndexOf value compare it with -1 because\n0 is a valid index.
\n\nstrings.IndexOf(someString) = -1 ' Test for \"index not found\"\nstrings.IndexOf(someString) < 0 ' Test for \"index not found\"\nstrings.IndexOf(someString) >= 0 ' Test for \"index found\"\n\n
Any checks which look for values > 0 ignore the first element, which is likely a bug. If the intent is merely to check the\ninclusion of a value in a String, List, or array, consider using the
\nstrings.Contains(someString) ' Boolean result\n\n
This rule raises an issue when the output value of any of the following methods is tested against > 0:
String, list or\n arrayStringString, list or\n arrayString\nsomeArray.IndexOf(someItem) > 0 ' Noncompliant: index 0 missing\nsomeString.IndexOfAny(charsArray) > 0 ' Noncompliant: index 0 missing\nsomeList.LastIndexOf(someItem) > 0 ' Noncompliant: index 0 missing\nsomeString.LastIndexOf(charsArray) > 0 ' Noncompliant: index 0 missing\n\n
\nDim Color As String = \"blue\"\nDim Name As String = \"ishmael\"\n\nDim Strings As New List(Of String)\nStrings.Add(Color)\nStrings.Add(Name)\nDim StringArray As String() = Strings.ToArray()\n\nIf Strings.IndexOf(Color) > 0 Then ' Noncompliant\n ' ...\nEnd If\n\nIf Name.IndexOf(\"ish\") > 0 Then ' Noncompliant\n ' ...\nEnd If\n\nIf Name.IndexOf(\"ae\") > 0 Then ' Noncompliant\n ' ...\nEnd If\n\nIf Array.IndexOf(StringArray, Color) > 0 Then ' Noncompliant\n ' ...\nEnd If\n\n
\nDim Color As String = \"blue\"\nDim Name As String = \"ishmael\"\n\nDim Strings As New List(Of String)\nStrings.Add(Color)\nStrings.Add(Name)\nDim StringArray As String() = Strings.ToArray()\n\nIf Strings.IndexOf(Color) > -1 Then\n ' ...\nEnd If\n\nIf Name.IndexOf(\"ish\") >= 0 Then\n ' ...\nEnd If\n\nIf Name.Contains(\"ae\") Then\n ' ...\nEnd If\n\nIf Array.IndexOf(StringArray, Color) >= 0 Then\n ' ...\nEnd If\n\n
A Catch clause that only rethrows the caught exception has the same effect as omitting the Catch altogether and letting\nit bubble up automatically.
\nDim s As String = \"\"\nTry\n s = File.ReadAllText(fileName)\nCatch e As Exception\n Throw\nEnd Try\n\n
Such clauses should either be removed or populated with the appropriate logic.
\n\nDim s As String = File.ReadAllText(fileName)\n\n
or
\n\nDim s As String = \"\"\nTry\n s = File.ReadAllText(fileName)\nCatch e As Exception\n logger.LogError(e)\n Throw\nEnd Try\n\n
This rule will not generate issues for Catch blocks if they are followed by a Catch block for a more general exception\ntype that does more than just rethrowing the exception.
\nDim s As String = \"\"\nTry\n s = File.ReadAllText(fileName)\nCatch e As IOException 'Compliant by exception: removing it would change the logic\n Throw\nCatch e As Exception 'Compliant: does more than just rethrow\n logger.LogError(e)\n Throw\nEnd Try\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2737.json", "content": "{\n \"title\": \"\\\"catch\\\" clauses should do more than rethrow\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"error-handling\",\n \"unused\",\n \"finding\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2737\",\n \"sqKey\": \"S2737\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2757.html", "content": "
Using operator pairs (=+ or =-) that look like reversed single operators (+= or -=) is\nconfusing. They compile and run but do not produce the same result as their mirrored counterpart.
\nDim target As Integer = -5\nDim num As Integer = 3\n\ntarget =- num ' Noncompliant: target = -3. Is that the intended behavior?\ntarget =+ num ' Noncompliant: target = 3\n\n
This rule raises an issue when =+ or =- are used without any space between the operators and when there is at least one\nwhitespace after.
Replace the operators with a single one if that is the intention
\n\nDim num As Integer = 3\n\ntarget -= num ' target = -8\n\n
Or fix the spacing to avoid confusion
\n\nDim num As Integer = 3\n\ntarget = -num // target = -3\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2757.json", "content": "{\n \"title\": \"Non-existent operators like \\\"\\u003d+\\\" should not be used\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2757\",\n \"sqKey\": \"S2757\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2761.html", "content": "
The repetition of the Not operator is usually a typo. The second operator invalidates the first one:
\nDim b As Boolean = False\nDim c As Boolean = Not Not b 'Noncompliant: equivalent to \"b\"\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2761.json", "content": "{\n \"title\": \"\\u0027Not\\u0027 boolean operator should not be repeated\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-2761\",\n \"sqKey\": \"S2761\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S2925.html", "content": "
Using Thread.Sleep in a test might introduce unpredictable and inconsistent results depending on the environment. Furthermore, it will\nblock the thread, which means the system resources are not being fully used.
\n<TestMethod>\nPublic Sub SomeTest()\n Threading.Thread.Sleep(500) ' Noncompliant\n ' assertions...\nEnd Sub\n\n
An alternative is a task-based asynchronous approach, using
More specifically the Task.Delay method should be\nused, because of the following advantages:
\nThread.Sleep\n<TestMethod>\nPublic Async Function SomeTest() As Task\n Await Task.Delay(500)\n ' assertions...\nEnd Function\n\n
Another scenario is when some data might need to be mocked using Moq, and a delay needs to be\nintroduced:
\n\n<TestMethod>\nPublic Sub UserService_Test()\n Dim UserService As New Mock(Of UserService)\n Dim Expected As New User\n UserService.Setup(Function(X) X.GetUserById(42)).Returns(\n Function()\n Threading.Thread.Sleep(500) ' Noncompliant\n Return Task.FromResult(Expected)\n End Function)\n ' assertions...\nEnd Sub\n\n
An alternative to Thread.Sleep while mocking with Moq is to use ReturnsAsync and pass the amount of time to\ndelay there:
\n<TestMethod>\nPublic Sub UserService_Test()\n Dim UserService As New Mock(Of UserService)\n Dim Expected As New User\n UserService.Setup(Function(X) X.GetUserById(42)).ReturnsAsync(Expected, TimeSpan.FromMilliseconds(500))\n ' assertions...\nEnd Sub\n\n
Visual Basic .NET, unlike many other programming languages, has no \"fall-through\" for its Select cases. Each case already has an\nimplicit Exit Select as its last instruction. It therefore is redundant to explicitly add one.
\nModule Module1\n Sub Main()\n Dim x = 0\n Select Case x\n Case 0\n Console.WriteLine(\"0\")\n Exit Select ' Noncompliant\n Case Else\n Console.WriteLine(\"Not 0\")\n Exit Select ' Noncompliant\n End Select\n End Sub\nEnd Module\n\n
\nModule Module1\n Sub Main()\n Dim x = 0\n Select Case x\n Case 0 ' Compliant\n Console.WriteLine(\"0\")\n Case Else ' Compliant\n Console.WriteLine(\"Not 0\")\n End Select\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S2951.json", "content": "{\n \"title\": \"\\\"Exit Select\\\" statements should not be used redundantly\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"unused\",\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-2951\",\n \"sqKey\": \"S2951\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3011.html", "content": "
Altering or bypassing the accessibility of classes, methods, or fields through reflection violates the encapsulation principle. This can break the\ninternal contracts of the accessed target and lead to maintainability issues and runtime errors.
\nThis rule raises an issue when reflection is used to change the visibility of a class, method or field, and when it is used to directly update a\nfield value.
\n\nImports System.Reflection\n\nDim dynClass = Type.GetType(\"MyInternalClass\")\n' Sensitive. Using BindingFlags.NonPublic will return non-public members\nDim bindingAttr As BindingFlags = BindingFlags.NonPublic Or BindingFlags.Static\nDim dynMethod As MethodInfo = dynClass.GetMethod(\"mymethod\", bindingAttr)\nDim result = dynMethod.Invoke(dynClass, Nothing)\n\n
StringBuilder instances that never build a string clutter the code and worse are a drag on performance. Either they\nshould be removed, or the missing ToString() call should be added.
\nPublic Sub DoSomething(ByVal strings As List(Of String))\n Dim sb As StringBuilder = New StringBuilder() ' Noncompliant\n sb.Append(\"Got: \")\n\n For Each str As String In strings\n sb.Append(str).Append(\", \")\n Next\nEnd Sub\n\n
\nPublic Sub DoSomething(ByVal strings As List(Of String))\n For Each str As String In strings\n Next\nEnd Sub\n\n
or
\n\nPublic Sub DoSomething(ByVal strings As List(Of String))\n Dim sb As StringBuilder = New StringBuilder()\n sb.Append(\"Got: \")\n\n For Each str As String In strings\n sb.Append(str).Append(\", \")\n Next\n\n My.Application.Log.WriteEntry(sb.ToString())\nEnd Sub\n\n
No issue is reported when StringBuilder is:
sb.CopyTo(), sb.GetChunks(), sb.Length, or sb(index).ToString() invocation there.Dim sb As StringBuilder = GetStringBuilder()).This vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nIn the mode Cipher Block Chaining (CBC), each block is used as cryptographic input for the next block. For this reason, the first block requires an\ninitialization vector (IV), also called a \"starting variable\" (SV).
\nIf the same IV is used for multiple encryption sessions or messages, each new encryption of the same plaintext input would always produce the same\nciphertext output. This may allow an attacker to detect patterns in the ciphertext.
\nAfter retrieving encrypted data and performing cryptographic attacks on it on a given timeframe, attackers can recover the plaintext that\nencryption was supposed to protect.
\nDepending on the recovered data, the impact may vary.
\nBelow are some real-world scenarios that illustrate the potential impact of an attacker exploiting the vulnerability.
\nBy modifying the plaintext of the encrypted message, an attacker may be able to trigger additional vulnerabilities in the code. An attacker can\nfurther exploit a system to obtain more information.\n
\n Encrypted values are often considered trustworthy because it would not be possible for a third party to modify them under normal circumstances.
When encrypted data contains personal or sensitive information, its retrieval by an attacker can lead to privacy violations, identity theft,\nfinancial loss, reputational damage, or unauthorized access to confidential systems.
\nIn this scenario, a company, its employees, users, and partners could be seriously affected.
\nThe impact is twofold, as data breaches and exposure of encrypted data can undermine trust in the organization, as customers, clients and\nstakeholders may lose confidence in the organization’s ability to protect their sensitive data.
\nIn many industries and locations, there are legal and compliance requirements to protect sensitive data. If encrypted data is compromised and the\nplaintext can be recovered, companies face legal consequences, penalties, or violations of privacy laws.
\n\nImports System.IO\nImports System.Security.Cryptography\n\nPublic Sub Encrypt(key As Byte(), dataToEncrypt As Byte(), target As MemoryStream)\n Dim aes = New AesCryptoServiceProvider()\n\n Dim iv = New Byte() {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}\n Dim encryptor = aes.CreateEncryptor(key, iv) ' Noncompliant\n\n Dim cryptoStream = New CryptoStream(target, encryptor, CryptoStreamMode.Write)\n Dim swEncrypt = New StreamWriter(cryptoStream)\n\n swEncrypt.Write(dataToEncrypt)\nEnd Sub\n\nIn this example, the code implicitly uses a number generator that is considered strong, thanks to aes.IV.
\nImports System.IO\nImports System.Security.Cryptography\n\nPublic Sub Encrypt(key As Byte(), dataToEncrypt As Byte(), target As MemoryStream)\n Dim aes = New AesCryptoServiceProvider()\n\n Dim encryptor = aes.CreateEncryptor(key, aes.IV)\n\n Dim cryptoStream = New CryptoStream(target, encryptor, CryptoStreamMode.Write)\n Dim swEncrypt = New StreamWriter(cryptoStream)\n\n swEncrypt.Write(dataToEncrypt)\nEnd Sub\n\n
To ensure high security, initialization vectors must meet two important criteria:
\nThe IV does not need be secret, so the IV or information sufficient to determine the IV may be transmitted along with the ciphertext.
\nIn the previous non-compliant example, the problem is not that the IV is hard-coded.\n
\n It is that the same IV is used for multiple encryption attempts.
Nested ternaries are hard to read and can make the order of operations complex to understand.
\n\nPublic Function GetReadableStatus(job As Job) As String\n Return If(job.IsRunning, \"Running\", If(job.HasErrors, \"Failed\", \"Succeeded\")) ' Noncompliant\nEnd Function\n\n
Instead, use another line to express the nested operation in a separate statement.
\n\nPublic Function GetReadableStatus(job As Job) As String\n If job.IsRunning Then Return \"Running\"\n Return If(job.HasErrors, \"Failed\", \"Succeeded\")\nEnd Function\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3358.json", "content": "{\n \"title\": \"If operators should not be nested\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3358\",\n \"sqKey\": \"S3358\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3363.html", "content": "
You should only set a property of a temporal type (like DateTime or DateTimeOffset) as the primary key of a table if the\nvalues are guaranteed to be unique.
Using temporal types as the primary key of a table is risky. When these types are used as primary keys, it usually means that each new key is\ncreated with the use of .Now or .UtcNow properties from DateTime and DateTimeOffset classes. In\nthose cases, duplicate keys exceptions may occur in many ways:
DateTime type);The rule raises an issue if:
\nId, <type name>Id or decorated by the [Key] or\n [PrimaryKey] attribute.Either use a GUID or the auto generated ID as a primary key.
\n\nPublic Class Account\n Public Property Id As DateTime\n\n Public Property Name As String\n Public Property Surname As String\nEnd Class\n\n
\nPublic Class Account\n Public Property Id As Guid\n\n Public Property Name As String\n Public Property Surname As String\nEnd Class\n\n
or
\n\nPublic Class Person\n <Key>\n Public Property PersonIdentifier As DateTime\n\n Public Property Name As String\n Public Property Surname As String\nEnd Class\n\n
\nPublic Class Person\n <Key>\n Public Property PersonIdentifier As Guid\n\n Public Property Name As String\n Public Property Surname As String\nEnd Class\n\n
Exit Function, Exit Property, and Exit Sub are all poor, less-readable substitutes for a simple\nReturn, and if used with code that should return a value (Exit Function and in some cases Exit Property) they\ncould result in a NullReferenceException.
This rule raises an issue for all their usages.
\n\nPublic Class Sample\n\n Public Sub MySub(Condition As Boolean)\n If Condition Then Exit Sub ' Noncompliant\n ' ...\n End Sub\n\n Public Function MyFunction(Condition As Boolean) As Integer\n If Condition Then\n MyFunction = 42\n Exit Function ' Noncompliant\n End If\n ' ...\n End Function\n\nEnd Class\n\n
\nPublic Class Sample\n\n Public Sub MySub(Condition As Boolean)\n If Condition Then Return ' Noncompliant\n ' ...\n End Sub\n\n Public Function MyFunction(Condition As Boolean) As Integer\n If Condition Then Return 42\n ' ...\n End Function\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3385.json", "content": "{\n \"title\": \"\\\"Exit\\\" statements should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"brain-overload\",\n \"bad-practice\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3385\",\n \"sqKey\": \"S3385\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3431.html", "content": "
It should be clear to a casual reader what code a test is testing and what results are expected. Unfortunately, that’s not usually the case with\nthe ExpectedException attribute since an exception could be thrown from almost any line in the method.
This rule detects MSTest and NUnit ExpectedException attribute.
This rule ignores:
\nCatch or Finally clause\n<TestMethod>\n<ExpectedException(GetType(InvalidOperationException))>\nPublic Sub UsingTest()\n Console.ForegroundColor = ConsoleColor.Black\n Try\n Using alert As New ConsoleAlert()\n Assert.AreEqual(ConsoleColor.Red, Console.ForegroundColor)\n Throw New InvalidOperationException()\n End Using\n Finally\n Assert.AreEqual(ConsoleColor.Black, Console.ForegroundColor) ' The exception itself is not relevant for the test.\n End Try\nEnd Sub\n\nPublic NotInheritable Class ConsoleAlert\n Implements IDisposable\n\n Private ReadOnly previous As ConsoleColor\n\n Public Sub New()\n previous = Console.ForegroundColor\n Console.ForegroundColor = ConsoleColor.Red\n End Sub\n\n Public Sub Dispose() Implements IDisposable.Dispose\n Console.ForegroundColor = previous\n End Sub\nEnd Class\n\n
Remove the ExpectedException attribute in favor of using the
\n<TestMethod>\n<ExpectedException(GetType(ArgumentNullException))> ' Noncompliant\nPublic Sub Method_NullParam()\n Dim sut As New MyService()\n sut.Method(Nothing)\nEnd Sub\n\n
\n<TestMethod>\nPublic Sub Method_NullParam()\n Dim sut As New MyService()\n Assert.ThrowsException(Of ArgumentNullException)(Sub() sut.Method(Nothing))\nEnd Sub\n\n
Remove the ExpectedException attribute in favor of using the
\n<Test>\n<ExpectedException(GetType(ArgumentNullException))> ' Noncompliant\nPublic Sub Method_NullParam()\n Dim sut As New MyService()\n sut.Method(Nothing)\nEnd Sub\n\n
\n<Test>\nPublic Sub Method_NullParam()\n Dim sut As New MyService()\n Assert.Throws(Of ArgumentNullException)(Sub() sut.Method(Nothing))\nEnd Sub\n\n
Numbers can be shifted with the << and >> int or a type that has an int. However, when the left operand is an object, the compiler’s type checking is turned off, therfore you\ncan pass anything to the right of a shift operator and have it compile. If the argument can’t be implicitly converted to int at runtime,\na RuntimeBinderException will be\nraised.
\nDim o As Object = 5\nDim x As Integer = 5\n\nx = o >> 5 ' Noncompliant\nx = x << o ' Noncompliant\n\n
This rule does not raise when the left or the right expression is
\nx = Nothing >> 5\nx = 5 << Nothing\n\n
When a class has only a private constructor, it can’t be instantiated except within the class itself. Such classes can be considered\ndead code and should be fixed
static members are also ignored because they are covered by Rule {rule:vbnet:S1118}.\nPublic Class [MyClass] ' Noncompliant: the class contains only private constructors\n Private Sub New()\n ' ...\n End Sub\nEnd Class\n\n
\nPublic Class [MyClass] ' Compliant: the class contains at least one non-private constructor\n Public Sub New()\n ' ...\n End Sub\nEnd Class\n\n
Recursion is a technique used to define a problem in terms of the problem itself, usually in\nterms of a simpler version of the problem itself.
\nFor example, the implementation of the generator for the n-th value of the Fibonacci\nsequence comes naturally from its mathematical definition, when recursion is used:
\n\nFunction NthFibonacciNumber(ByVal n As Integer) As Integer\n If n <= 1 Then\n Return 1\n Else\n Return NthFibonacciNumber(n - 1) + NthFibonacciNumber(n - 2)\n End If\nEnd Function\n\n
As opposed to:
\n\nFunction NthFibonacciNumber(ByVal n As Integer) As Integer\n Dim previous As Integer = 0\n Dim last As Integer = 1\n\n For i = 0 To n - 1\n Dim temp = previous\n previous = last\n last = last + temp\n Next\n\n Return last\nEnd Function\n\n
The use of recursion is acceptable in methods, like the one above, where you can break out of it.
\n\nFunction NthFibonacciNumber(ByVal n As Integer) As Integer\n If n <= 1 Then\n Return 1 ' Base case: stop the recursion\n End If\n ' ...\nEnd Function\n\n
It is also acceptable and makes sense in some type definitions:
\n\nClass Box\n Inherits IComparable(Of Box)\n\n Public Function CompareTo(ByVal other As Box?) As Integer\n ' Compare the two Box instances...\n End Function\nEnd Class\n\n
With types, some invalid recursive definitions are caught by the compiler:
\n\nClass C2(Of T) ' Error BC31447 C2(Of T) cannot reference itself in Inherits clause\n Inherits C2(Of T)\nEnd Class\n\nClass C2(Of T)\n Inherits C2(Of C2(Of T)) ' Error BC31447 C2(Of T) cannot reference itself in Inherits clause\nEnd Class\n\n
In more complex scenarios, however, the code will compile but execution will result in a
\nClass C1(Of T)\nEnd Class\n\nClass C2(Of T) ' Noncompliant\n Inherits C1(Of C2(Of C2(Of T)))\nEnd Class\n\nDim c2 = New C2(Of Integer) ' This would result into a TypeLoadException\n\n
When optional parameter values are not passed to base method calls, the value passed in by the caller is ignored. This can cause the function to\nbehave differently than expected, leading to errors and making the code difficult to debug.
\n\nPublic Class BaseClass\n Public Overridable Sub MyMethod(ByVal Optional i As Integer = 1)\n Console.WriteLine(i)\n End Sub\nEnd Class\n\nPublic Class DerivedClass\n Inherits BaseClass\n\n Public Overrides Sub MyMethod(ByVal Optional i As Integer = 1)\n ' ...\n MyBase.MyMethod() ' Noncompliant: caller's value is ignored\n End Sub\n\n Private Shared Function Main(ByVal args As String()) As Integer\n Dim dc As DerivedClass = New DerivedClass()\n dc.MyMethod(12) ' prints 1\n End Function\nEnd Class\n\n
\nPublic Class BaseClass\n Public Overridable Sub MyMethod(ByVal Optional i As Integer = 1)\n Console.WriteLine(i)\n End Sub\nEnd Class\n\nPublic Class DerivedClass\n Inherits BaseClass\n\n Public Overrides Sub MyMethod(ByVal Optional i As Integer = 1)\n ' ...\n MyBase.MyMethod(i)\n End Sub\n\n Private Shared Function Main(ByVal args As String()) As Integer\n Dim dc As DerivedClass = New DerivedClass()\n dc.MyMethod(12) ' prints 12\n End Function\nEnd Class\n\n
Microsoft Learn -
When declaring a Windows Communication Foundation (WCF) OperationContract\nmethod as one-way,\nthat service method won’t return any result, not even an underlying empty confirmation message. These are fire-and-forget methods that are useful in\nevent-like communication. Therefore, specifying a return type has no effect and can confuse readers.
The rule doesn’t report if OperationContractAttribute.AsyncPattern\nis set to true.
\n<ServiceContract>\nInterface IMyService\n <OperationContract(IsOneWay:=True)>\n Function SomethingHappened(ByVal parameter As Integer) As Integer ' Noncompliant\nEnd Interface\n\n
\n<ServiceContract>\nInterface IMyService\n <OperationContract(IsOneWay:=True)>\n Sub SomethingHappened(ByVal parameter As Integer)\nEnd Interface\n\n
Microsoft Learn -
Marking a method with the Pure\nattribute indicates that the method doesn’t make any visible state changes. Therefore, a Pure method should return a result. Otherwise,\nit indicates a no-operation call.
Using Pure on a void method is either by mistake or the method is not doing a meaningful task.
\nClass Person\n Private age As Integer\n\n <Pure> ' Noncompliant: The method makes a state change\n Private Sub ConfigureAge(ByVal age As Integer)\n Me.age = age\n End Sub\n\n <Pure>\n Private Sub WriteAge() ' Noncompliant\n Console.WriteLine(Me.age)\n End Sub\n\nEnd Class\n\n
\nClass Person\n Private age As Integer\n\n Private Sub ConfigureAge(ByVal age As Integer)\n Me.age = age\n End Sub\n\n <Pure>\n Private Function Age() As Integer\n Return Me.age\n End Function\n\n ' or remove Pure attribute from the method\n\n Private Sub WriteAge()\n Console.WriteLine(Me.age)\n End Sub\n\nEnd Class\n\n
Nullable value types can hold either a value or\nNothing.
The value stored in the nullable type can be accessed with the Value property or by casting it to the underlying type. Still, both\noperations throw an InvalidOperationException when the value is Nothing. A nullable type should always be tested before\naccessing the value to avoid raising exceptions.
\nSub Sample(condition As Boolean)\n Dim nullableValue As Integer? = If(condition, 42, Nothing)\n Console.WriteLine(nullableValue.Value) ' Noncompliant: InvalidOperationException is raised\n\n Dim nullableCast As Integer? = If(condition, 42, Nothing)\n Console.WriteLine(CType(nullableCast, Integer)) ' Noncompliant: InvalidOperationException is raised\nEnd Sub\n\n
\nSub Sample(condition As Boolean)\n Dim nullableValue As Integer? = If(condition, 42, Nothing)\n If nullableValue.HasValue Then\n Console.WriteLine(nullableValue.Value)\n End If\n\n Dim nullableCast As Integer? = If(condition, 42, Nothing)\n If nullableCast.HasValue Then\n Console.WriteLine(CType(nullableCast, Integer))\n End If\nEnd Sub\n\n
This rule raises an issue when the code cognitive complexity of a function is above a certain threshold.
\nCognitive Complexity is a measure of how hard it is to understand the control flow of a unit of code. Code with high cognitive complexity is hard\nto read, understand, test, and modify.
\nAs a rule of thumb, high cognitive complexity is a sign that the code should be refactored into smaller, easier-to-manage pieces.
\nHere are the core concepts:
\nThe method of computation is fully detailed in the pdf linked in the resources.
\nDevelopers spend more time reading and understanding code than writing it. High cognitive complexity slows down changes and increases the cost of\nmaintenance.
\n\nFunction Abs(ByVal n As Integer) As Integer ' Noncompliant: cognitive complexity = 5\n If n >= 0 Then ' +1\n Return n\n Else ' +2, due to nesting\n If n = Integer.MinValue Then ' +1\n Throw New ArgumentException(\"The absolute value of int.MinValue is outside of int boundaries\")\n Else ' +1\n Return -n\n End If\n End If\nEnd Function\n\n
They should be refactored to have lower complexity:
\n\nFunction Abs(ByVal n As Integer) As Integer ' Compliant: cognitive complexity = 3\n If n = Integer.MinValue Then ' +1\n Throw New ArgumentException(\"The absolute value of int.MinValue is outside of int boundaries\")\n Else If n >= 0 Then ' +1\n Return n\n Else ' +1\n Return -n\n End If\nEnd Function\n\n
Since Visual Studio 2010 SP1, the ByVal parameter modifier is implicitly applied, and therefore not required anymore. Removing it from\nyour source code will improve readability.
\nSub Foo(ByVal bar As String)\n ' ...\nEnd Sub\n\n
\nSub Foo(bar As String)\n ' ...\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3860.json", "content": "{\n \"title\": \"\\\"ByVal\\\" should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3860\",\n \"sqKey\": \"S3860\",\n \"scope\": \"All\",\n \"quickfix\": \"covered\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3866.html", "content": "
Visual Basic .NET offers a non-short-circuit conditional function, IIf(), which returns either its second or third parameter based on\nthe expression in the first parameter. Using it is slower than using If() because each parameter is unconditionally evaluated. Further,\nits use can lead to runtime exceptions because IIf always evaluates all three of its arguments.
The newer version, If(), should be used instead because it short-circuits the evaluation of its parameters.
\nPublic Class Foo\n Public Sub Bar()\n Dim var As Object = IIf(Date.Now.Year = 1999, \"Lets party!\", \"Lets party like it is 1999!\") ' Noncompliant\n End Sub\nEnd Class\n\n
\nPublic Class Foo\n Public Sub Bar()\n Dim var As String = If(Date.Now.Year = 1999, \"Lets party!\", \"Lets party like it is 1999!\")\n End Sub\nEnd Class\n\n
The SafeHandle.DangerousGetHandle method poses significant risks and should be used carefully. This method carries the inherent danger\nof potentially returning an invalid handle, which can result in resource leaks and security vulnerabilities. Although it is technically possible to\nutilize this method without encountering issues, doing so correctly requires a high level of expertise. Therefore, it is recommended to avoid using\nthis method altogether.
The SafeHandle.DangerousGetHandle method is potentially prone to leaks and vulnerabilities due to its nature and usage. Here are a few\nreasons why:
SafeHandle class, there is an increased risk of failing to dispose system resources correctly.SafeHandle.DangerousGetHandle without proper validation can lead to security vulnerabilities that can be exploited by an attacker.\nSub Dangerous(fieldInfo As System.Reflection.FieldInfo)\n Dim handle As SafeHandle = CType(fieldInfo.GetValue(fieldInfo), SafeHandle)\n Dim dangerousHandle As IntPtr = handle.DangerousGetHandle ' Noncompliant\nEnd Sub\n\n
The point of having custom exception types is to convey more information than is available in standard types. But custom exception types must be\npublic for that to work.
If a method throws a non-public exception, the best you can do on the caller’s side is to catch the closest public base\nof the class. However, you lose all the information that the new exception type carries.
This rule will raise an issue if you directly inherit one of the following exception types in a non-public class:
\n\nFriend Class MyException ' Noncompliant\n Inherits Exception\n ' ...\nEnd Class\n\n
\nPublic Class MyException\n Inherits Exception\n ' ...\nEnd Class\n\n
There’s no point in creating an array solely for the purpose of passing it to a ParamArray parameter. Simply pass the elements\ndirectly. They will be consolidated into an array automatically.
\nClass SurroundingClass\n Public Sub Base()\n Method(New String() { \"s1\", \"s2\" }) ' Noncompliant: unnecessary\n Method(New String(12) {}) ' Compliant\n End Sub\n\n Public Sub Method(ParamArray args As String())\n ' Do something\n End Sub\nEnd Class\n\n\nClass SurroundingClass\n Public Sub Base()\n Method(\"s1\", \"s2\")\n Method(New String(12) {})\n End Sub\n\n Public Sub Method(ParamArray args As String())\n ' Do something\n End Sub\nEnd Class\n\n\n"
},
{
"path": "analyzers/rspec/vbnet/S3878.json",
"content": "{\n \"title\": \"Arrays should not be created for ParamArray parameters\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"clumsy\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-3878\",\n \"sqKey\": \"S3878\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/vbnet/S3884.html",
"content": "This rule is deprecated, and will eventually be removed.
\nCoSetProxyBlanket and CoInitializeSecurity both work to set the permissions context in which the process invoked\nimmediately after is executed. Calling them from within that process is useless because it’s too late at that point; the permissions context has\nalready been set.
Specifically, these methods are meant to be called from non-managed code such as a C++ wrapper that then invokes the managed, i.e. C# or VB.NET,\ncode.
\n\nPublic Class Noncompliant\n\n <DllImport(\"ole32.dll\")>\n Public Shared Function CoSetProxyBlanket(<MarshalAs(UnmanagedType.IUnknown)>pProxy As Object, dwAuthnSvc as UInt32, dwAuthzSvc As UInt32, <MarshalAs(UnmanagedType.LPWStr)> pServerPrincName As String, dwAuthnLevel As UInt32, dwImpLevel As UInt32, pAuthInfo As IntPtr, dwCapabilities As UInt32) As Integer\n End Function\n\n Public Enum RpcAuthnLevel\n [Default] = 0\n None = 1\n Connect = 2\n [Call] = 3\n Pkt = 4\n PktIntegrity = 5\n PktPrivacy = 6\n End Enum\n\n Public Enum RpcImpLevel\n [Default] = 0\n Anonymous = 1\n Identify = 2\n Impersonate = 3\n [Delegate] = 4\n End Enum\n\n Public Enum EoAuthnCap\n None = &H00\n MutualAuth = &H01\n StaticCloaking = &H20\n DynamicCloaking = &H40\n AnyAuthority = &H80\n MakeFullSIC = &H100\n [Default] = &H800\n SecureRefs = &H02\n AccessControl = &H04\n AppID = &H08\n Dynamic = &H10\n RequireFullSIC = &H200\n AutoImpersonate = &H400\n NoCustomMarshal = &H2000\n DisableAAA = &H1000\n End Enum\n\n <DllImport(\"ole32.dll\")>\n Public Shared Function CoInitializeSecurity(pVoid As IntPtr, cAuthSvc As Integer, asAuthSvc As IntPtr, pReserved1 As IntPtr, level As RpcAuthnLevel, impers As RpcImpLevel, pAuthList As IntPtr, dwCapabilities As EoAuthnCap, pReserved3 As IntPtr) As Integer\n End Function\n\n Public Sub DoSomething()\n Dim Hres1 As Integer = CoSetProxyBlanket(Nothing, 0, 0, Nothing, 0, 0, IntPtr.Zero, 0) ' Noncompliant\n Dim Hres2 As Integer = CoInitializeSecurity(IntPtr.Zero, -1, IntPtr.Zero, IntPtr.Zero, RpcAuthnLevel.None, RpcImpLevel.Impersonate, IntPtr.Zero, EoAuthnCap.None, IntPtr.Zero) ' Noncompliant\n End Sub\n\nEnd Class\n\n
Thread.Suspend and Thread.Resume can give unpredictable results, and both methods have been deprecated. Indeed, if\nThread.Suspend is not used very carefully, a thread can be suspended while\nholding a lock, thus leading to a
There are other synchronization mechanisms that are safer and should be used instead, such as:
\nMonitor provides a mechanism that synchronizes access to objects.Mutex provides a mechanism that synchronizes interprocess access to a protected resource.Semaphore provides a mechanism that allows limiting the number of threads that have access to a protected resources\n concurrently.Events enable a class to notify others when something of interest occurs.If you’re using a Structure, it is likely because you’re interested in performance. But by failing to implement\nIEquatable<T> you’re loosing performance when comparisons are made because without IEquatable<T>, boxing and\nreflection are used to make comparisons.
\nStructure MyStruct ' Noncompliant\n\n Public Property Value As Integer\n\nEnd Structure\n\n
\nStructure MyStruct\n Implements IEquatable(Of MyStruct)\n\n Public Property Value As Integer\n\n Public Overloads Function Equals(other As MyStruct) As Boolean Implements IEquatable(Of MyStruct).Equals\n ' ...\n End Function\n\nEnd Structure\n\n
Methods declared as Public, Protected, or Protected Friend can be accessed from other assemblies, which\nmeans you should validate parameters to be within the expected constraints. In general, checking against Nothing is recommended in\ndefensive programming.
This rule raises an issue when a parameter of a publicly accessible method is not validated against Nothing before being\ndereferenced.
\nPublic Class Sample\n\n Public Property Message As String\n\n Public Sub PublicMethod(Arg As Exception)\n Message = Arg.Message ' Noncompliant\n End Sub\n\n Protected Sub ProtectedMethod(Arg As Exception)\n Message = Arg.Message ' Noncompliant\n End Sub\n\nEnd Class\n\n
\nPublic Class Sample\n\n Public Property Message As String\n\n Public Sub PublicMethod(Arg As Exception)\n If Arg IsNot Nothing Then Message = Arg.Message ' Noncompliant\n End Sub\n\n Protected Sub ProtectedMethod(Arg As Exception)\n ArgumentNullException.ThrowIfNull(Arg)\n Message = Arg.Message ' Noncompliant\n End Sub\n\n Private Sub PrivateMethod(Arg As Exception)\n Message = Arg.Message ' Compliant: method is not publicly accessible\n End Sub\n\nEnd Class\n\n
Nothing via helper methods should be annotated with the [NotNull] attribute.[NotNull] ValidatedNotNullAttribute and mark the parameter that is\n validated for null in your method declaration with it:\nImports System.Runtime.CompilerServices\n\n<AttributeUsage(AttributeTargets.Parameter, Inherited:=False)>\nPublic NotInheritable Class ValidatedNotNullAttribute\n Inherits Attribute\n\nEnd Class\n\nPublic Module Guard\n\n Public Sub NotNull(Of T As Class)(<ValidatedNotNullAttribute> Value As T, <CallerArgumentExpression(\"Value\")> Optional Name As String = \"\")\n If Value Is Nothing Then Throw New ArgumentNullException(Name)\n End Sub\n\nEnd Module\n\nPublic Module SampleUsage\n\n Public Function CustomToUpper(Value As String) As String\n Guard.NotNull(Value)\n Return Value.ToUpper\n End Function\n\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3900.json", "content": "{\n \"title\": \"Arguments of public methods should be validated against Nothing\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"convention\",\n \"symbolic-execution\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3900\",\n \"sqKey\": \"S3900\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3903.html", "content": "
Types are declared in namespaces in order to prevent name collisions and as a way to organize them into the object hierarchy. Types that are\ndefined outside any named namespace are in a global namespace that cannot be referenced in code.
\n\nPublic Class Foo\nEnd Class\n\nPublic Structure Bar\nEnd Structure\n\n
\nNamespace SomeSpace\n Public Class Foo\n End Class\n\n Public Structure Bar\n End Structure\nEnd Namespace\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3903.json", "content": "{\n \"title\": \"Types should be defined in named namespaces\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"MODULAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3903\",\n \"sqKey\": \"S3903\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3904.html", "content": "
The AssemblyVersion attribute is used to\nspecify the version number of an assembly. An assembly is a compiled unit of code, which can be marked with a version number by applying the attribute\nto an assembly’s source code file.
\nThe AssemblyVersion attribute is useful for many reasons:
AssemblyVersion attribute, you can ensure that the correct version of the referenced assembly is used. This\n helps avoid compatibility issues and ensures that the expected behavior and functionality are maintained.If no AssemblyVersion is provided, the same default version will be used for every build. Since the version number is used by .NET\nFramework to uniquely identify an assembly, this can lead to broken dependencies.
\nImports System.Reflection\n<Assembly: AssemblyTitle(\"MyAssembly\")> ' Noncompliant\nNamespace MyLibrary\n' ...\nEnd Namespace\n\n
\nImports System.Reflection\n<Assembly: AssemblyTitle(\"MyAssembly\")>\n<Assembly: AssemblyVersion(\"42.1.125.0\")>\nNamespace MyLibrary\n' ...\nEnd Namespace\n\n
Having all branches of a Select Case or If chain with the same implementation indicates a problem.
In the following code:
\n\nDim b As Integer = If(a > 12, 4, 4) // Noncompliant\n\nIf b = 0 Then // Noncompliant\n DoTheThing()\nElse\n DoTheThing()\nEnd If\n\nSelect Case i // Noncompliant\n Case 1\n DoSomething()\n Case 2\n DoSomething()\n Case 3\n DoSomething()\n Case Else\n DoSomething()\nEnd Select\n\n
Either there is a copy-paste error that needs fixing or an unnecessary Select Case or If chain that needs removing.
This rule does not apply to If chains without Else, nor to Select Case without a Case Else\nclause.
\nIf b = 0 Then ' No issue, this could have been done on purpose to make the code more readable\n DoTheThing()\nElseIf\n DoTheThing()\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3923.json", "content": "{\n \"title\": \"All branches in a conditional structure should not have exactly the same implementation\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3923\",\n \"sqKey\": \"S3923\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3926.html", "content": "
Fields marked with System.Runtime.Serialization.OptionalFieldAttribute are serialized just like any other field. But such fields are\nignored on deserialization, and retain the default values associated with their types. Therefore, deserialization event handlers should be declared to\nset such fields during the deserialization process.
This rule raises when at least one field with the System.Runtime.Serialization.OptionalFieldAttribute attribute is declared but one\n(or both) of the following event handlers System.Runtime.Serialization.OnDeserializingAttribute or\nSystem.Runtime.Serialization.OnDeserializedAttribute are not present.
\n<Serializable>\nPublic Class Foo ' Noncompliant\n <OptionalField(VersionAdded:=2)>\n Private optionalField As Integer = 5\nEnd Class\n\n
\n<Serializable>\nPublic Class Foo\n <OptionalField(VersionAdded:=2)>\n Private optionalField As Integer = 5\n\n <OnDeserializing>\n Private Sub OnDeserializing(ByVal context As StreamingContext)\n optionalField = 5\n End Sub\n\n <OnDeserialized>\n Private Sub OnDeserialized(ByVal context As StreamingContext)\n End Sub\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3926.json", "content": "{\n \"title\": \"Deserialization methods should be provided for \\\"OptionalField\\\" members\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"serialization\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3926\",\n \"sqKey\": \"S3926\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3927.html", "content": "
Serialization event handlers that don’t have the correct signature will not be called, bypassing augmentations to automated serialization and\ndeserialization events.
\nA method is designated a serialization event handler by applying one of the following serialization event attributes:
\nOnSerializingAttributeOnSerializedAttributeOnDeserializingAttributeOnDeserializedAttributeSerialization event handlers take a single parameter of type StreamingContext, return\nvoid, and have private visibility.
This rule raises an issue when any of these constraints are not respected.
\n\n<Serializable>\nPublic Class Foo\n <OnSerializing>\n Public Sub OnSerializing(ByVal context As StreamingContext) ' Noncompliant: should be private\n End Sub\n\n <OnSerialized>\n Private Function OnSerialized(ByVal context As StreamingContext) As Integer ' Noncompliant: should return void\n End Function\n\n <OnDeserializing>\n Private Sub OnDeserializing() ' Noncompliant: should have a single parameter of type StreamingContext\n End Sub\n\n <OnSerializing>\n Public Sub OnSerializing2(Of T)(ByVal context As StreamingContext) ' Noncompliant: should have no type parameters\n End Sub\n\n <OnDeserialized>\n Private Sub OnDeserialized(ByVal context As StreamingContext, ByVal str As String) ' Noncompliant: should have a single parameter of type StreamingContext\n End Sub\nEnd Class\n\n
\n<Serializable>\nPublic Class Foo\n <OnSerializing>\n Private Sub OnSerializing(ByVal context As StreamingContext)\n End Sub\n\n <OnSerialized>\n Private Sub OnSerialized(ByVal context As StreamingContext)\n End Sub\n\n <OnDeserializing>\n Private Sub OnDeserializing(ByVal context As StreamingContext)\n End Sub\n\n <OnDeserialized>\n Private Sub OnDeserialized(ByVal context As StreamingContext)\n End Sub\nEnd Class\n\n
Numbers are infinite, but the types that hold them are not. Each numeric type has hard upper and lower bounds. Try to calculate numbers beyond\nthose bounds, and the result will be an OverflowException. When the compilation is configured to remove integer overflow checking, the\nvalue will be silently wrapped around from the expected positive value to a negative one, or vice versa.
\nPublic Function Transform(Value As Integer) As Integer\n If Value <= 0 Then Return Value\n Dim Number As Integer = Integer.MaxValue\n Return Number + Value ' Noncompliant\nEnd Function\n\n
\nPublic Function Transform(Value As Integer) As Long\n If Value <= 0 Then Return Value\n Dim Number As Long = Integer.MaxValue\n Return Number + Value\nEnd Function\n\n
Disposing an object twice in the same method, either with the Dispose directly, is confusing and error-prone. For example, another developer might try to use an already-disposed object, or there can\nbe runtime errors for specific paths in the code.
In addition, even if the Dispose method multiple times should not throw an exception, some implementations still do it. Thus it is safer to not\ndispose of an object twice when possible.
\nDim foo As New Disposable()\nfoo.Dispose()\nfoo.Dispose() ' Noncompliant\n\n
\nUsing bar As New Disposable() ' Noncompliant\n bar.Dispose()\nEnd Using\n\n
\nDim foo As New Disposable()\nfoo.Dispose()\n\n
\nUsing bar As New Disposable() ' Compliant\n\nEnd Using\n\n
The size of a collection and the length of an array are always greater than or equal to zero. Testing it doesn’t make sense, since the result is\nalways true.
\nIf Collection.Count >= 0 Then ... 'Noncompliant always true\n\nIf array.Length >= 0 Then ... 'Noncompliant always true\n\n
Similarly testing that it is less than zero will always return false.
\nIf Enumerable.Count < 0 Then ... 'Noncompliant always false\n\nDim result As Boolean = Array.Length >= 0 'Noncompliant always true\n\n
Fix the code to properly check for emptiness if it was the intent, or remove the redundant code to keep the current behavior.
\n\n" }, { "path": "analyzers/rspec/vbnet/S3981.json", "content": "{\n \"title\": \"Collection sizes and array length comparisons should make sense\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"confusing\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3981\",\n \"sqKey\": \"S3981\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3990.html", "content": "Assemblies should conform with the Common Language Specification (CLS) in order to be usable across programming languages. To be compliant an\nassembly has to indicate it with System.CLSCompliantAttribute.
\n<Assembly: CLSCompliant(True)>\n\nNamespace MyLibrary\n\nEnd Namespace\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3990.json", "content": "{\n \"title\": \"Assemblies should be marked as CLS compliant\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"COMPLETE\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3990\",\n \"sqKey\": \"S3990\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3992.html", "content": "
Assemblies should explicitly indicate whether they are meant to be COM visible or not. If the ComVisibleAttribute is not present, the\ndefault is to make the content of the assembly visible to COM clients.
Note that COM visibility can be overridden for individual types and members.
\n\nNamespace MyLibrary ' Noncompliant\n\nEnd Namespace\n\n
\n<Assembly: Runtime.InteropServices.ComVisible(False)>\n\nNamespace MyLibrary\n\nEnd Namespace\n\n\n" }, { "path": "analyzers/rspec/vbnet/S3992.json", "content": "{\n \"title\": \"Assemblies should explicitly specify COM visibility\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"api-design\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-3992\",\n \"sqKey\": \"S3992\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S3998.html", "content": "
Objects that can be accessed across application\ndomain boundaries are said to have weak identity. This means that these objects can be considered shared resources outside of the domain, which\ncan be lead to them being accessed or modified by multiple threads or concurrent parts of a program, outside of the domain.
\nA thread acquiring a
Types with weak identity are:
\n\nPublic Class Sample\n Private ReadOnly myLock As New StackOverflowException\n\n Public Sub Go()\n SyncLock myLock ' Noncompliant\n ' ...\n End SyncLock\n End Sub\nEnd Class\n\n
\nPublic Class Sample\n Private ReadOnly myLock As New Object\n\n Public Sub Go()\n SyncLock myLock\n ' ...\n End SyncLock\n End Sub\nEnd Class\n\n
Having a field in a child class with a name that differs from a parent class' field only by capitalization is sure to cause confusion. Such child\nclass fields should be renamed.
\n\nPublic Class Fruit\n\n Protected PlantingSeason As String\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n Protected Plantingseason As String ' Noncompliant\n\n ' ...\n\nEnd Class\n\n
\nPublic Class Fruit\n\n Protected PlantingSeason As String\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n Protected WhenToPlant As String\n\n ' ...\n\nEnd Class\n\n
Or
\n\nPublic Class Fruit\n\n Protected PlantingSeason As String\n\n ' ...\n\nEnd Class\n\nPublic Class Raspberry\n Inherits Fruit\n\n ' Field removed, parent field will be used instead\n\nEnd Class\n\n
This rule ignores same-name fields that are Shared in both the parent and child classes. It also ignores Private parent\nclass fields and fields explicitly declared as Shadows, but in all other such cases, the child class field should be renamed.
When you run an OS command, it is always important to protect yourself against the risk of accidental or malicious replacement of the executables\nin the production system.
\nTo do so, it is important to point to the specific executable that should be used.
\nFor example, if you call git (without specifying a path), the operating system will search for the executable in the directories\nspecified in the PATH environment variable.\n
\n An attacker could have added, in a permissive directory covered by PATH , another executable called git, but with a\n completely different behavior, for example exfiltrating data or exploiting a vulnerability in your own code.
However, by calling /usr/bin/git or ../git (relative path) directly, the operating system will always use the intended\nexecutable.\n
\n Note that you still need to make sure that the executable is not world-writeable and potentially overwritten. This is not the scope of this\n rule.
There is a risk if you answered no to this question.
\nIf you wish to rely on the PATH environment variable to locate the OS command, make sure that each of its listed directories is fixed,\nnot susceptible to change, and not writable by unprivileged users.
If you determine that these folders cannot be altered, and that you are sure that the program you intended to use will be used, then you can\ndetermine that these risks are under your control.
\nA good practice you can use is to also hardcode the PATH variable you want to use, if you can do so in the framework you use.
If the previous recommendations cannot be followed due to their complexity or other requirements, then consider using the absolute path of the\ncommand instead.
\n\n$ whereis git\ngit: /usr/bin/git /usr/share/man/man1/git.1.gz\n$ ls -l /usr/bin/git\n-rwxr-xr-x 1 root root 3376112 Jan 28 10:13 /usr/bin/git\n\n
\nDim p As New Process()\np.StartInfo.FileName = \"binary\" ' Sensitive\n\n
\nDim p As New Process()\np.StartInfo.FileName = \"C:\\Apps\\binary.exe\"\n\n
The .NET framework class library provides methods for retrieving custom attributes. Sealing the attribute eliminates the search through the\ninheritance hierarchy, and can improve performance.
\nThis rule raises an issue when a public type inherits from System.Attribute, is not abstract, and is not sealed.
\nPublic Class MyAttribute ' Noncompliant\n Inherits Attribute\n\n Public ReadOnly Property Name As String\n\n Public Sub New(Name As String)\n Me.Name = Name\n End Sub\n\nEnd Class\n\n
\nPublic NotInheritable Class MyAttribute\n Inherits Attribute\n\n Public ReadOnly Property Name As String\n\n Public Sub New(Name As String)\n Me.Name = Name\n End Sub\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4060.json", "content": "{\n \"title\": \"Non-abstract attributes should be sealed\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4060\",\n \"sqKey\": \"S4060\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4136.html", "content": "
For clarity, all overloads of the same method should be grouped together. That lets both users and maintainers quickly understand all the current\navailable options.
\n\nInterface IMyInterface\n Function DoTheThing() As Integer\n Function DoTheOtherThing() As String // Noncompliant\n Function DoTheThing(ByVal Path As String) As Integer\nEnd Interface\n\n
\nInterface IMyInterface\n Function DoTheThing() As Integer\n Function DoTheThing(ByVal Path As String) As Integer\n Function DoTheOtherThing() As String\nEnd Interface\n\n
As it is common practice to group method declarations by implemented interface, no issue will be raised for interface implementations if grouped\ntogether with other members of that interface.
\nAs it is also a common practice to group method declarations by accessibility level, no issue will be raised for method overloads having different\naccess modifiers.
\nExample:
\n\nClass MyClass\n\n Private Sub DoTheThing(s As String) ' Ok - this method is declared as Private while the other one is Public\n ' ...\n End Sub\n\n Private Sub DoTheOtherThing(s As String)\n ' ...\n End Sub\n\n Public Sub DoTheThing()\n ' ...\n End Sub\n\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4136.json", "content": "{\n \"title\": \"Method overloads should be grouped together\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FORMATTED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [\n \"convention\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4136\",\n \"sqKey\": \"S4136\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4143.html", "content": "
Storing a value inside a collection at a given key or index and then unconditionally overwriting it without reading the initial value is a case of\na \"dead store\".
\n\ntowns.Item(x) = \"London\"\ntowns.Item(x) = \"Chicago\"; // Noncompliant\n\n
This practice is redundant and will cause confusion for the reader. More importantly, it is often an error and not what the developer intended to\ndo.
\n\n" }, { "path": "analyzers/rspec/vbnet/S4143.json", "content": "{\n \"title\": \"Map values should not be replaced unconditionally\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4143\",\n \"sqKey\": \"S4143\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4144.html", "content": "Two methods having the same implementation are suspicious. It might be that something else was intended. Or the duplication is intentional, which\nbecomes a maintenance burden.
\n\nPrivate Const CODE As String = \"bounteous\"\nPrivate callCount As Integer = 0\n\nPublic Function GetCode() As String\n callCount = callCount + 1\n Return CODE\nEnd Function\n\nPublic Function GetName() As String ' Noncompliant: duplicates GetCode\n callCount = callCount + 1\n Return CODE\nEnd Function\n\n
If the identical logic is intentional, the code should be refactored to avoid duplication. For example, by having both methods call the same method\nor by having one implementation invoke the other.
\n\nPrivate Const CODE As String = \"bounteous\"\nPrivate callCount As Integer = 0\n\nPublic Function GetCode() As String\n callCount = callCount + 1\n Return CODE\nEnd Function\n\nPublic Function GetName() As String ' Intent is clear\n Return GetCode()\nEnd Function\n\n
Empty methods, methods with only one line of code and methods with the same name (overload) are ignored.
\n\n" }, { "path": "analyzers/rspec/vbnet/S4144.json", "content": "{\n \"title\": \"Methods should not have identical implementations\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"DISTINCT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"confusing\",\n \"duplicate\",\n \"suspicious\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4144\",\n \"sqKey\": \"S4144\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4158.html", "content": "When a collection is empty, iterating it has no effect. Doing so anyway is likely a bug; either population was accidentally omitted, or the\niteration needs to be revised.
\n\nPublic Sub Method()\n Dim Values As New List(Of String)\n Values.Remove(\"bar\") ' Noncompliant\n If Values.Contains(\"foo\") Then ' Noncompliant\n End If\n For Each Value As String In Values ' Noncompliant\n Next\nEnd Sub\n\n
\nPublic Sub Method()\n Dim Values As List(Of String) = LoadValues()\n Values.Remove(\"bar\")\n If Values.Contains(\"foo\") Then\n End If\n For Each Value As String In Values\n Next\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4158.json", "content": "{\n \"title\": \"Empty collections should not be accessed or iterated\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"LOW\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [\n \"symbolic-execution\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4158\",\n \"sqKey\": \"S4158\",\n \"scope\": \"All\",\n \"quickfix\": \"infeasible\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4159.html", "content": "
The Attributed Programming Model,\nalso known as Attribute-oriented programming (@OP), is a programming model\nused to embed attributes within codes.
\nIn this model, objects are required to conform to a specific structure so that they can be used by the
MEF provides a way to discover available components implicitly, via composition. A MEF component, called a part,\ndeclaratively specifies:
\nThe ExportAttribute declares that a part \"exports\",\nor provides to the composition container, an object that fulfills a particular contract.
\nDuring composition, parts with imports that have matching contracts will have those dependencies filled by the exported object.
\nIf the type doesn’t implement the interface it is exporting there will be an issue at runtime (either a cast exception or just a container not\nfilled with the exported type) leading to unexpected behaviors/crashes.
\nThe rule raises an issue when a class doesn’t implement or inherit the type declared in the ExportAttribute.
\n<Export(GetType(ISomeType))>\nPublic Class SomeType ' Noncompliant: doesn't implement 'ISomeType'.\nEnd Class\n\n
\n<Export(GetType(ISomeType))>\nPublic Class SomeType\n Inherits ISomeType\nEnd Class\n\n
There’s no need to null test in conjunction with an TypeOf ... Is test. Nothing is not an instance of anything, so a null\ncheck is redundant.
\nIf (x IsNot Nothing And TypeOf x Is MyClass)\n ' ...\nEnd If\n\nIf (x Is Nothing Or TypeOf x IsNot MyClass)\n ' ...\nEnd If\n\n
\nIf (TypeOf x Is MyClass)\n ' ...\nEnd If\n\nIf (TypeOf x IsNot MyClass)\n ' ...\nEnd If\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4201.json", "content": "{\n \"title\": \"Null checks should not be combined with \\\"TypeOf Is\\\" operator checks\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"redundant\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4201\",\n \"sqKey\": \"S4201\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4210.html", "content": "
When an assembly uses Windows Forms (classes and interfaces from the System.Windows.Forms namespace) its entry point should be marked\nwith the STAThreadAttribute to indicate that the threading model should be \"Single-Threaded Apartment\" (STA) which is the only one\nsupported by Windows Forms.
This rule raises an issue when the entry point (Shared Sub Main method) of an assembly using Windows Forms is not marked as STA.
\nImports System.Windows.Forms\n\nPublic Class Foo\n Shared Sub Main()\n Dim winForm As Form = New Form\n Application.Run(winForm)\n End Sub\nEnd Class\n\n
\nImports System.Windows.Forms\n\nPublic Class Foo\n <STAThread()> Shared Sub Main()\n Dim winForm As Form = New Form\n Application.Run(winForm)\n End Sub\nEnd Class\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4210.json", "content": "{\n \"title\": \"Windows Forms entry points should be marked with STAThread\",\n \"type\": \"BUG\",\n \"code\": {\n \"impacts\": {\n \"RELIABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"2min\"\n },\n \"tags\": [\n \"winforms\",\n \"pitfall\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4210\",\n \"sqKey\": \"S4210\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4225.html", "content": "
Creating an extension method that extends Object is not recommended because it makes the method available on every type.\nExtensions should be applied at the most specialized level possible, and that is very unlikely to be Object.
\nImports System.Runtime.CompilerServices\n\nModule MyExtensions\n <Extension>\n Sub SomeExtension(obj As Object) ' Noncompliant\n ' ...\n End Sub\nEnd Module\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4225.json", "content": "{\n \"title\": \"Extension methods should not extend \\\"Object\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"FOCUSED\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"15min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4225\",\n \"sqKey\": \"S4225\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4260.html", "content": "
When creating a custom Markup Extension\nthat accepts parameters in WPF, the ConstructorArgument markup\nmust be used to identify the discrete properties that match these parameters. However since this is done via a string, the compiler won’t give you any\nwarning in case there are typos.
This rule raises an issue when the string argument to ConstructorArgumentAttribute doesn’t match any parameter of any constructor.
\nImports System\n\nNamespace MyLibrary\n Public Class MyExtension\n Inherits MarkupExtension\n\n Public Sub New()\n End Sub\n\n Public Sub New(ByVal value1 As Object)\n Value1 = value1\n End Sub\n\n <ConstructorArgument(\"value2\")> ' Noncompliant\n Public Property Value1 As Object\n End Class\nEnd Namespace\n\n
\nImports System\n\nNamespace MyLibrary\n Public Class MyExtension\n Inherits MarkupExtension\n\n Public Sub New()\n End Sub\n\n Public Sub New(ByVal value1 As Object)\n Value1 = value1\n End Sub\n\n <ConstructorArgument(\"value1\")>\n Public Property Value1 As Object\n End Class\nEnd Namespace\n\n
Properties provide a way to enforce encapsulation by providing\nproperty procedures that give controlled access to Private fields. However, in classes with multiple fields, it is not unusual that
\nClass C\n Private _x As Integer\n Private _Y As Integer\n\n Public ReadOnly Property Y As Integer\n Get\n Return _x ' Noncompliant: The returned field should be '_y'\n End Get\n End Property\nEnd Class\n\n
This rule raises an issue in any of these cases:
\nFor simple properties, it is better to use
Field and property names are compared as case-insensitive. All underscore characters are ignored.
\n\nPublic Class Sample\n\n Private _x As Integer\n Private _y As Integer\n\n Public Property Y As Integer\n Get\n Return _x ' Noncompliant: field '_y' is not used in the return value\n End Get\n Set(value As Integer)\n _x = value ' Noncompliant: field '_y' is not updated\n End Set\n End Property\n\nEnd Class\n\n
\nPublic Class Sample\n\n Private _x As Integer\n Private _y As Integer\n\n Public Property Y As Integer\n Get\n Return _y\n End Get\n Set(value As Integer)\n _y = value\n End Set\n End Property\n\nEnd Class\n\n
Marking a class with PartCreationPolicy(CreationPolicy.Shared), which is\npart of Managed Extensibility Framework (MEF), means that a single, shared\ninstance of the exported object will be created. Therefore it doesn’t make sense to create new instances using the constructor and it will most likely\nresult in unexpected behaviours.
This rule raises an issue when a constructor of a class marked shared with a PartCreationPolicyAttribute is invoked.
\n<Export(GetType(IFooBar))>\n<PartCreationPolicy(CreationPolicy.[Shared])>\nPublic Class FooBar\n Inherits IFooBar\nEnd Class\n\nPublic Class Program\n Public Shared Sub Main()\n Dim fooBar = New FooBar() ' Noncompliant\n End Sub\nEnd Class\n\n
\n<Export(GetType(IFooBar))>\n<PartCreationPolicy(CreationPolicy.[Shared])>\nPublic Class FooBar\n Inherits IFooBar\nEnd Class\n\nPublic Class Program\n Public Shared Sub Main()\n Dim fooBar = serviceProvider.GetService(Of IFooBar)()\n End Sub\nEnd Class\n\n
PartCreationPolicyCreationPolicy.SharedThis vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nTo provide communication security over a network, SSL and TLS are generally used. However, it is important to note that the following protocols are\nall considered weak by the cryptographic community, and are officially deprecated:
\nWhen these unsecured protocols are used, it is best practice to expect a breach: that a user or organization with malicious intent will perform\nmathematical attacks on this data after obtaining it by other means.
\nAfter retrieving encrypted data and performing cryptographic attacks on it on a given timeframe, attackers can recover the plaintext that\nencryption was supposed to protect.
\nDepending on the recovered data, the impact may vary.
\nBelow are some real-world scenarios that illustrate the potential impact of an attacker exploiting the vulnerability.
\nBy modifying the plaintext of the encrypted message, an attacker may be able to trigger additional vulnerabilities in the code. An attacker can\nfurther exploit a system to obtain more information.\n
\n Encrypted values are often considered trustworthy because it would not be possible for a third party to modify them under normal circumstances.
When encrypted data contains personal or sensitive information, its retrieval by an attacker can lead to privacy violations, identity theft,\nfinancial loss, reputational damage, or unauthorized access to confidential systems.
\nIn this scenario, the company, its employees, users, and partners could be seriously affected.
\nThe impact is twofold, as data breaches and exposure of encrypted data can undermine trust in the organization, as customers, clients and\nstakeholders may lose confidence in the organization’s ability to protect their sensitive data.
\nIn many industries and locations, there are legal and compliance requirements to protect sensitive data. If encrypted data is compromised and the\nplaintext can be recovered, companies face legal consequences, penalties, or violations of privacy laws.
\nThese samples use a default TLS algorithm, which is a weak cryptographical algorithm: TLSv1.0.
\n\nImports System.Net\nImports System.Security.Authentication\n\nPublic Sub Encrypt()\n ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls ' Noncompliant\nEnd Sub\n\n
\nImports System.Net.Http\nImports System.Security.Authentication\n\nPublic Sub Encrypt()\n Dim Handler As New HttpClientHandler With {\n .SslProtocols = SslProtocols.Tls ' Noncompliant\n }\nEnd Sub\n\n\nImports System.Net\nImports System.Security.Authentication\n\nPublic Sub Encrypt()\n ServicePointManager.SecurityProtocol = _\n SecurityProtocolType.Tls12 _\n Or SecurityProtocolType.Tls13\nEnd Sub\n\n
\nImports System.Net.Http\nImports System.Security.Authentication\n\nPublic Sub Encrypt()\n Dim Handler As New HttpClientHandler With {\n .SslProtocols = SslProtocols.Tls12\n }\nEnd Sub\n\nAs a rule of thumb, by default you should use the cryptographic algorithms and mechanisms that are considered strong by the cryptographic\ncommunity.
\nThe best choices at the moment are the following.
\nEven though TLS V1.3 is available, using TLS v1.2 is still considered good and secure practice by the cryptography community.\n
The use of TLS v1.2 ensures compatibility with a wide range of platforms and enables seamless communication between different systems that do not\nyet have TLS v1.3 support.
\nThe only drawback depends on whether the framework used is outdated: its TLS v1.2 settings may enable older and insecure cipher suites that are\ndeprecated as insecure.
\nOn the other hand, TLS v1.3 removes support for older and weaker cryptographic algorithms, eliminates known vulnerabilities from previous TLS\nversions, and improves performance.
\nTo customize the default behavior for an export in the Managed Extensibility\nFramework (MEF), applying the PartCreationPolicyAttribute\nis necessary. For the PartCreationPolicyAttribute\nto be meaningful in the context of an export, the class must also be annotated with the ExportAttribute.
This rule raises an issue when a class is annotated with the PartCreationPolicyAttribute but not with the\nExportAttribute.
\nImports System.ComponentModel.Composition\n\n<PartCreationPolicy(CreationPolicy.Any)> ' Noncompliant\nPublic Class FooBar\n Inherits IFooBar\nEnd Class\n\n
\nImports System.ComponentModel.Composition\n\n<Export(GetType(IFooBar))>\n<PartCreationPolicy(CreationPolicy.Any)>\nPublic Class FooBar\n Inherits IFooBar\nEnd Class\n\n
Development tools and frameworks usually have options to make debugging easier for developers. Although these features are useful during\ndevelopment, they should never be enabled for applications deployed in production. Debug instructions or error messages can leak detailed information\nabout the system, like the application’s path or file names.
\nThere is a risk if you answered yes to any of those questions.
\nDo not enable debugging features on production servers.
\nThe .Net Core framework offers multiple features which help during debug.\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDeveloperExceptionPage and\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDatabaseErrorPage are two of them. Make sure that those features are disabled in\nproduction.
Use If env.IsDevelopment() to disable debug code.
This rule raises issues when the following .Net Core methods are called:\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDeveloperExceptionPage,\nMicrosoft.AspNetCore.Builder.IApplicationBuilder.UseDatabaseErrorPage.
\nImports Microsoft.AspNetCore.Builder\nImports Microsoft.AspNetCore.Hosting\n\nNamespace MyMvcApp\n Public Class Startup\n Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IHostingEnvironment)\n ' Those calls are Sensitive because it seems that they will run in production\n app.UseDeveloperExceptionPage() 'Sensitive\n app.UseDatabaseErrorPage() 'Sensitive\n End Sub\n End Class\nEnd Namespace\n\n
\nImports Microsoft.AspNetCore.Builder\nImports Microsoft.AspNetCore.Hosting\n\nNamespace MyMvcApp\n Public Class Startup\n Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IHostingEnvironment)\n If env.IsDevelopment() Then ' Compliant\n ' The following calls are ok because they are disabled in production\n app.UseDeveloperExceptionPage()\n app.UseDatabaseErrorPage()\n End If\n End Sub\n End Class\nEnd Namespace\n\n
The DebuggerDisplayAttribute is used to determine how an object is displayed in the debugger window.
The DebuggerDisplayAttribute constructor takes a single mandatory argument: the string to be displayed in the value column for\ninstances of the type. Any text within curly braces is evaluated as the name of a field or property, or any complex expression containing method calls\nand operators.
Naming a non-existent member between curly braces will result in a BC30451 error in the debug window when debugging objects. Although there is no\nimpact on the production code, providing a wrong value can lead to difficulties when debugging the application.
\nThis rule raises an issue when text specified between curly braces refers to members that don’t exist in the current context.
\n\n<DebuggerDisplay(\"Name: {Name}\")> ' Noncompliant - Name doesn't exist in this context\nPublic Class Person\n\n Public Property FullName As String\n\nEnd Class\n\n\n<DebuggerDisplay(\"Name: {FullName}\")>\nPublic Class Person\n\n Public Property FullName As String\n\nEnd Class\n\n\n"
},
{
"path": "analyzers/rspec/vbnet/S4545.json",
"content": "{\n \"title\": \"\\\"DebuggerDisplayAttribute\\\" strings should reference existing members\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"LOGICAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4545\",\n \"sqKey\": \"S4545\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n"
},
{
"path": "analyzers/rspec/vbnet/S4581.html",
"content": "When the syntax new Guid() (i.e. parameterless instantiation) is used, it must be that one of three things is wanted:
Guid.Empty is clearer.Guid.NewGuid() should be used.This rule raises an issue when a parameterless instantiation of the Guid struct is found.
\nPublic Sub Foo()\n Dim G1 As New Guid ' Noncompliant - what's the intent?\n Dim G2 As Guid = Nothing ' Noncompliant\nEnd Sub\n\n
\npublic void Foo(byte[] bytes)\nPublic Sub Foo(Bytes As Byte())\n Dim G1 As Guid = Guid.Empty\n Dim G2 As Guid = Guid.NewGuid()\n Dim G3 As Guid = New Guid(Bytes)\nEnd Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S4581.json", "content": "{\n \"title\": \"\\\"new Guid()\\\" should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CONVENTIONAL\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5 min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-4581\",\n \"sqKey\": \"S4581\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4583.html", "content": "
When calling the BeginInvoke method of a delegate,\nresources are allocated that are only freed up when EndInvoke is called. Failing to pair BeginInvoke with\nEndInvoke can lead to resource leaks and incomplete asynchronous calls.
This rule raises an issue in the following scenarios:
\nBeginInvoke method is called without any callback, and it is not paired with a call to EndInvoke in the same\n block.IAsyncResult does not contain a call to EndInvoke in the same block.BeginInvoke without callback:
\nPublic Delegate Function AsyncMethodCaller() As String\n\nPublic Class Sample\n\n Public Sub DoSomething()\n Dim Example As New AsyncExample()\n Dim Caller As New AsyncMethodCaller(Example.SomeMethod)\n ' Initiate the asynchronous call.\n Dim Result As IAsyncResult = Caller.BeginInvoke(Nothing, Nothing) ' Noncompliant: Not paired With EndInvoke\n End Sub\n\nEnd Class\n\n
BeginInvoke with callback:
\nPublic Delegate Function AsyncMethodCaller() As String\n\nPublic Class Sample\n\n Public Sub DoSomething()\n Dim Example As New AsyncExample()\n Dim Caller As New AsyncMethodCaller(Example.SomeMethod)\n ' Initiate the asynchronous call.\n Dim Result As IAsyncResult = Caller.BeginInvoke(New AsyncCallback(Sub(ar)\n End Sub), Nothing) ' Noncompliant: Not paired With EndInvoke\n End Sub\n\nEnd Class\n\n
BeginInvoke without callback:
\nPublic Delegate Function AsyncMethodCaller() As String\n\nPublic Class Sample\n\n Public Function DoSomething() As String\n Dim Example As New AsyncExample()\n Dim Caller As New AsyncMethodCaller(Example.SomeMethod)\n ' Initiate the asynchronous call.\n Dim Result As IAsyncResult = Caller.BeginInvoke(Nothing, Nothing)\n ' ...\n Return Caller.EndInvoke(Result)\n End Function\n\nEnd Class\n\n
BeginInvoke with callback:
\nPublic Delegate Function AsyncMethodCaller() As String\n\nPublic Class Sample\n\n Public Sub DoSomething()\n Dim Example As New AsyncExample()\n Dim Caller As New AsyncMethodCaller(Example.SomeMethod)\n ' Initiate the asynchronous call.\n Dim Result As IAsyncResult = Caller.BeginInvoke(New AsyncCallback(Sub(ar)\n ' Call EndInvoke to retrieve the results.\n Dim Ret As String = Caller.EndInvoke(ar)\n ' ...\n End Sub), Nothing)\n End Sub\n\nEnd Class\n\n
Returning Nothing from a non-Async Task/Task(Of TResult) procedure will cause a\nNullReferenceException at runtime if the procedure is awaited. This problem can be avoided by returning Task.CompletedTask or Task.FromResult(Of TResult)(Nothing)\nrespectively.
\nPublic Function DoFooAsync() As Task\n Return Nothing ' Noncompliant: Causes a NullReferenceException if awaited.\nEnd Function\n\nPublic Async Function Main() As Task\n Await DoFooAsync() ' NullReferenceException\nEnd Function\n\n
Instead of Nothing Task.CompletedTask or Task.FromResult(Of TResult)(Nothing)\nshould be returned.
A Task returning procedure can be fixed like so:
\nPublic Function DoFooAsync() As Task\n Return Nothing ' Noncompliant: Causes a NullReferenceException if awaited.\nEnd Function\n\n
\nPublic Function DoFooAsync() As Task\n Return Task.CompletedTask ' Compliant: Method can be awaited.\nEnd Function\n\n
A Task(Of TResult) returning procedure can be fixed like so:
\nPublic Function GetFooAsync() As Task(Of Object)\n Return Nothing ' Noncompliant: Causes a NullReferenceException if awaited.\nEnd Function\n\n
\nPublic Function GetFooAsync() As Task(Of Object)\n Return Task.FromResult(Of Object)(Nothing) ' Compliant: Method can be awaited.\nEnd Function\n\n
Task.CompletedTask PropertyTask.FromResult<TResult>(TResult)\n MethodEmpty comments, as shown in the example, hurt readability and might indicate an oversight.
\n\n'\n\n'''\n\n
Some meaningful text should be added to the comment, or the comment markers should be removed.
\n\n" }, { "path": "analyzers/rspec/vbnet/S4663.json", "content": "{\n \"title\": \"Comments should not be empty\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"1min\"\n },\n \"tags\": [],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-4663\",\n \"sqKey\": \"S4663\",\n \"scope\": \"Main\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S4790.html", "content": "Cryptographic hash algorithms such as MD2, MD4, MD5, MD6, HAVAL-128,\nDSA (which uses SHA-1), RIPEMD, RIPEMD-128, RIPEMD-160and SHA-1 are no\nlonger considered secure, because it is possible to have collisions (little computational effort is enough to find two or more different\ninputs that produce the same hash).
Message authentication code (MAC) algorithms such as HMAC-MD5 or HMAC-SHA1 use weak hash functions as building blocks.\nAlthough they are not all proven to be weak, they are considered legacy algorithms and should be avoided.
The hashed value is used in a security context like:
\nThere is a risk if you answered yes to any of those questions.
\nSafer alternatives, such as SHA-256, SHA-512, SHA-3 are recommended, and for password hashing, it’s even\nbetter to use algorithms that do not compute too \"quickly\", like bcrypt, scrypt, argon2 or pbkdf2\nbecause it slows down brute force attacks.
\nImports System.Security.Cryptography\n\nSub ComputeHash()\n\n ' Review all instantiations of classes that inherit from HashAlgorithm, for example:\n Dim hashAlgo As HashAlgorithm = HashAlgorithm.Create() ' Sensitive\n Dim hashAlgo2 As HashAlgorithm = HashAlgorithm.Create(\"SHA1\") ' Sensitive\n Dim sha As SHA1 = New SHA1CryptoServiceProvider() ' Sensitive\n Dim md5 As MD5 = New MD5CryptoServiceProvider() ' Sensitive\n\n ' ...\nEnd Sub\n\nClass MyHashAlgorithm\n Inherits HashAlgorithm ' Sensitive\n\n ' ...\nEnd Class\n\n
\nImports System.Security.Cryptography\n\nSub ComputeHash()\n Dim sha256 = New SHA256CryptoServiceProvider() ' Compliant\n Dim sha384 = New SHA384CryptoServiceProvider() ' Compliant\n Dim sha512 = New SHA512CryptoServiceProvider() ' Compliant\n\n ' ...\nEnd Sub\n\n
This rule is deprecated, and will eventually be removed.
\nConfiguring loggers is security-sensitive. It has led in the past to the following vulnerabilities:
\nLogs are useful before, during and after a security incident.
\nLogs are also a target for attackers because they might contain sensitive information. Configuring loggers has an impact on the type of information\nlogged and how they are logged.
\nThis rule flags for review code that initiates loggers configuration. The goal is to guide security code reviews.
\nThere is a risk if you answered yes to any of those questions.
\nRemember that configuring loggers properly doesn’t make them bullet-proof. Here is a list of recommendations explaining on how to use your\nlogs:
\n.Net Core: configure programmatically
\n\nImports System\nImports System.Collections\nImports System.Collections.Generic\nImports Microsoft.AspNetCore\nImports Microsoft.AspNetCore.Builder\nImports Microsoft.AspNetCore.Hosting\nImports Microsoft.Extensions.Configuration\nImports Microsoft.Extensions.DependencyInjection\nImports Microsoft.Extensions.Logging\nImports Microsoft.Extensions.Options\n\nNamespace MvcApp\n\n Public Class ProgramLogging\n\n Public Shared Function CreateWebHostBuilder(args As String()) As IWebHostBuilder\n\n WebHost.CreateDefaultBuilder(args) _\n .ConfigureLogging(Function(hostingContext, Logging) ' Sensitive\n ' ...\n End Function) _\n .UseStartup(Of StartupLogging)()\n\n '...\n End Function\n End Class\n\n\n Public Class StartupLogging\n\n Public Sub ConfigureServices(services As IServiceCollection)\n\n services.AddLogging(Function(logging) ' Sensitive\n '...\n End Function)\n End Sub\n\n Public Sub Configure(app As IApplicationBuilder, env As IHostingEnvironment, loggerFactory As ILoggerFactory)\n\n Dim config As IConfiguration = Nothing\n Dim level As LogLevel = LogLevel.Critical\n Dim includeScopes As Boolean = False\n Dim filter As Func(Of String, Microsoft.Extensions.Logging.LogLevel, Boolean) = Nothing\n Dim consoleSettings As Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings = Nothing\n Dim azureSettings As Microsoft.Extensions.Logging.AzureAppServices.AzureAppServicesDiagnosticsSettings = Nothing\n Dim eventLogSettings As Microsoft.Extensions.Logging.EventLog.EventLogSettings = Nothing\n\n ' An issue will be raised for each call to an ILoggerFactory extension methods adding loggers.\n loggerFactory.AddAzureWebAppDiagnostics() ' Sensitive\n loggerFactory.AddAzureWebAppDiagnostics(azureSettings) ' Sensitive\n loggerFactory.AddConsole() ' Sensitive\n loggerFactory.AddConsole(level) ' Sensitive\n loggerFactory.AddConsole(level, includeScopes) ' Sensitive\n loggerFactory.AddConsole(filter) ' Sensitive\n loggerFactory.AddConsole(filter, includeScopes) ' Sensitive\n loggerFactory.AddConsole(config) ' Sensitive\n loggerFactory.AddConsole(consoleSettings) ' Sensitive\n loggerFactory.AddDebug() ' Sensitive\n loggerFactory.AddDebug(level) ' Sensitive\n loggerFactory.AddDebug(filter) ' Sensitive\n loggerFactory.AddEventLog() ' Sensitive\n loggerFactory.AddEventLog(eventLogSettings) ' Sensitive\n loggerFactory.AddEventLog(level) ' Sensitive\n ' Only available for NET Standard 2.0 and above\n 'loggerFactory.AddEventSourceLogger() ' Sensitive\n\n Dim providers As IEnumerable(Of ILoggerProvider) = Nothing\n Dim filterOptions1 As LoggerFilterOptions = Nothing\n Dim filterOptions2 As IOptionsMonitor(Of LoggerFilterOptions) = Nothing\n\n Dim factory As LoggerFactory = New LoggerFactory() ' Sensitive\n factory = New LoggerFactory(providers) ' Sensitive\n factory = New LoggerFactory(providers, filterOptions1) ' Sensitive\n factory = New LoggerFactory(providers, filterOptions2) ' Sensitive\n End Sub\n End Class\nEnd Namespace\n\n
Log4Net
\n\nImports System\nImports System.IO\nImports System.Xml\nImports log4net.Appender\nImports log4net.Config\nImports log4net.Repository\n\nNamespace Logging\n Class Log4netLogging\n Private Sub Foo(ByVal repository As ILoggerRepository, ByVal element As XmlElement, ByVal configFile As FileInfo, ByVal configUri As Uri, ByVal configStream As Stream, ByVal appender As IAppender, ParamArray appenders As IAppender())\n log4net.Config.XmlConfigurator.Configure(repository) ' Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, element) ' Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configFile) ' Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configUri) ' Sensitive\n log4net.Config.XmlConfigurator.Configure(repository, configStream) ' Sensitive\n log4net.Config.XmlConfigurator.ConfigureAndWatch(repository, configFile) ' Sensitive\n\n log4net.Config.DOMConfigurator.Configure() ' Sensitive\n log4net.Config.DOMConfigurator.Configure(repository) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(element) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, element) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(configFile) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, configFile) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(configStream) ' Sensitive\n log4net.Config.DOMConfigurator.Configure(repository, configStream) ' Sensitive\n log4net.Config.DOMConfigurator.ConfigureAndWatch(configFile) ' Sensitive\n log4net.Config.DOMConfigurator.ConfigureAndWatch(repository, configFile) ' Sensitive\n\n log4net.Config.BasicConfigurator.Configure() ' Sensitive\n log4net.Config.BasicConfigurator.Configure(appender) ' Sensitive\n log4net.Config.BasicConfigurator.Configure(appenders) ' Sensitive\n log4net.Config.BasicConfigurator.Configure(repository) ' Sensitive\n log4net.Config.BasicConfigurator.Configure(repository, appender) ' Sensitive\n log4net.Config.BasicConfigurator.Configure(repository, appenders) ' Sensitive\n End Sub\n End Class\nEnd Namespace\n\n
NLog: configure programmatically
\n\nNamespace Logging\n Class NLogLogging\n Private Sub Foo(ByVal config As NLog.Config.LoggingConfiguration)\n NLog.LogManager.Configuration = config ' Sensitive\n End Sub\n End Class\nEnd Namespace\n\n
Serilog
\n\nNamespace Logging\n Class SerilogLogging\n Private Sub Foo()\n Dim config As Serilog.LoggerConfiguration = New Serilog.LoggerConfiguration() ' Sensitive\n End Sub\n End Class\nEnd Namespace\n\n
This vulnerability makes it possible that an encrypted communication is intercepted.
\nTransport Layer Security (TLS) provides secure communication between systems over the internet by encrypting the data sent between them.\nCertificate validation adds an extra layer of trust and security to this process to ensure that a system is indeed the one it claims to be.
\nWhen certificate validation is disabled, the client skips a critical security check. This creates an opportunity for attackers to pose as a trusted\nentity and intercept, manipulate, or steal the data being transmitted.
\nEstablishing trust in a secure way is a non-trivial task. When you disable certificate validation, you are removing a key mechanism designed to\nbuild this trust in internet communication, opening your system up to a number of potential threats.
\nIf a system does not validate certificates, it cannot confirm the identity of the other party involved in the communication. An attacker can\nexploit this by creating a fake server and masquerading as a legitimate one. For example, they might set up a server that looks like your bank’s\nserver, tricking your system into thinking it is communicating with the bank. This scenario, called identity spoofing, allows the attacker to collect\nany data your system sends to them, potentially leading to significant data breaches.
\nWhen TLS certificate validation is disabled, the integrity of the data you send and receive cannot be guaranteed. An attacker could modify the data\nin transit, and you would have no way of knowing. This could range from subtle manipulations of the data you receive to the injection of malicious\ncode or malware into your system. The consequences of such breaches of data integrity can be severe, depending on the nature of the data and the\nsystem.
\nIn the following example, the callback change impacts the entirety of HTTP requests made by the application.
\nThe certificate validation gets disabled by overriding ServerCertificateValidationCallback with an empty implementation. It is highly\nrecommended to use the original implementation.
\nImports System.Net\n\nPublic Sub Send()\n ServicePointManager.ServerCertificateValidationCallback =\n Function(sender, certificate, chain, errors) True ' Noncompliant\n\n Dim request As System.Net.HttpWebRequest = System.Net.HttpWebRequest.Create(New System.Uri(\"https://example.com\"))\n request.Method = System.Net.WebRequestMethods.Http.Get\n Dim response As System.Net.HttpWebResponse = request.GetResponse()\n response.Close()\nEnd Sub\n\n
Addressing the vulnerability of disabled TLS certificate validation primarily involves re-enabling the default validation.
\nTo avoid running into problems with invalid certificates, consider the following sections.
\nIf possible, always use a certificate issued by a well-known, trusted CA for your server. Most programming environments come with a predefined list\nof trusted root CAs, and certificates issued by these authorities are validated automatically. This is the best practice, and it requires no\nadditional code or configuration.
\nIn some cases, you might need to work with a server using a self-signed certificate, or a certificate issued by a CA not included in your trusted\nroots. Rather than disabling certificate validation in your code, you can add the necessary certificates to your trust store.
\nSuccessful Zip Bomb attacks occur when an application expands untrusted archive files without controlling the size of the expanded data, which can\nlead to denial of service. A Zip bomb is usually a malicious archive file of a few kilobytes of compressed data but turned into gigabytes of\nuncompressed data. To achieve this extreme compression ratio, attackers will\ncompress irrelevant data (eg: a long string of repeated bytes).
\nArchives to expand are untrusted and:
\nThere is a risk if you answered yes to any of those questions.
\n\nFor Each entry As ZipArchiveEntry in archive.Entries\n ' entry.FullName could contain parent directory references \"..\" and the destinationPath variable could become outside of the desired path\n string destinationPath = Path.GetFullPath(Path.Combine(path, entry.FullName))\n entry.ExtractToFile(destinationPath) ' Sensitive, extracts the entry to a file\n\n Dim stream As Stream\n stream = entry.Open() ' Sensitive, the entry is about to be extracted\nNext\n\n
\nConst ThresholdRatio As Double = 10\nConst ThresholdSize As Integer = 1024 * 1024 * 1024 ' 1 GB\nConst ThresholdEntries As Integer = 10000\nDim TotalSizeArchive, TotalEntryArchive, TotalEntrySize, Cnt As Integer\nDim Buffer(1023) As Byte\nUsing ZipToOpen As New FileStream(\"ZipBomb.zip\", FileMode.Open), Archive As New ZipArchive(ZipToOpen, ZipArchiveMode.Read)\n For Each Entry As ZipArchiveEntry In Archive.Entries\n Using s As Stream = Entry.Open\n TotalEntryArchive += 1\n TotalEntrySize = 0\n Do\n Cnt = s.Read(Buffer, 0, Buffer.Length)\n TotalEntrySize += Cnt\n TotalSizeArchive += Cnt\n If TotalEntrySize / Entry.CompressedLength > ThresholdRatio Then Exit Do ' Ratio between compressed And uncompressed data Is highly suspicious, looks Like a Zip Bomb Attack\n Loop While Cnt > 0\n End Using\n If TotalSizeArchive > ThresholdSize Then Exit For ' The uncompressed data size Is too much for the application resource capacity\n If TotalEntryArchive > ThresholdEntries Then Exit For ' Too much entries in this archive, can lead to inodes exhaustion of the system\n Next\nEnd Using\n\n
Operating systems have global directories where any user has write access. Those folders are mostly used as temporary storage areas like\n/tmp in Linux based systems. An application manipulating files from these folders is exposed to race conditions on filenames: a malicious\nuser can try to create a file with a predictable name before the application does. A successful attack can result in other files being accessed,\nmodified, corrupted or deleted. This risk is even higher if the application runs with elevated permissions.
In the past, it has led to the following vulnerabilities:
\nThis rule raises an issue whenever it detects a hard-coded path to a publicly writable directory like /tmp (see examples bellow). It\nalso detects access to environment variables that point to publicly writable directories, e.g., TMP, TMPDIR and\nTEMP.
/tmp/var/tmp/usr/tmp/dev/shm/dev/mqueue/run/lock/var/run/lock/Library/Caches/Users/Shared/private/tmp/private/var/tmp\\Windows\\Temp\\Temp\\TMP%USERPROFILE%\\AppData\\Local\\TempThere is a risk if you answered yes to any of those questions.
\nOut of the box, .NET is missing secure-by-design APIs to create temporary files. To overcome this, one of the following options can be used:
\n\nUsing Writer As New StreamWriter(\"/tmp/f\") ' Sensitive\n' ...\nEnd Using\n\n
\nDim Tmp As String = Environment.GetEnvironmentVariable(\"TMP\") ' Sensitive\n\n
\nDim RandomPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName())\n\n' Creates a new file with write, non inheritable permissions which is deleted on close.\nUsing FileStream As New FileStream(RandomPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.DeleteOnClose)\n Using Writer As New StreamWriter(FileStream) ' Sensitive\n ' ...\n End Using\nEnd Using\n\n
Temporary files are considered insecurely created when the file existence check is performed separately from the actual file creation. Such a\nsituation can occur when creating temporary files using normal file handling functions or when using dedicated temporary file handling functions that\nare not atomic.
\nCreating temporary files in a non-atomic way introduces race condition issues in the application’s behavior. Indeed, a third party can create a\ngiven file between when the application chooses its name and when it creates it.
\nIn such a situation, the application might use a temporary file that it does not entirely control. In particular, this file’s permissions might be\ndifferent than expected. This can lead to trust boundary issues.
\nAttackers with control over a temporary file used by a vulnerable application will be able to modify it in a way that will affect the application’s\nlogic. By changing this file’s Access Control List or other operating system-level properties, they could prevent the file from being deleted or\nemptied. They may also alter the file’s content before or while the application uses it.
\nDepending on why and how the affected temporary files are used, the exploitation of a race condition in an application can have various\nconsequences. They can range from sensitive information disclosure to more serious application or hosting infrastructure compromise.
\nBecause attackers can control the permissions set on temporary files and prevent their removal, they can read what the application stores in them.\nThis might be especially critical if this information is sensitive.
\nFor example, an application might use temporary files to store users' session-related information. In such a case, attackers controlling those\nfiles can access session-stored information. This might allow them to take over authenticated users' identities and entitlements.
\nAn application might use temporary files to store technical data for further reuse or as a communication channel between multiple components. In\nthat case, it might consider those files part of the trust boundaries and use their content without additional security validation or sanitation. In\nsuch a case, an attacker controlling the file content might use it as an attack vector for further compromise.
\nFor example, an application might store serialized data in temporary files for later use. In such a case, attackers controlling those files'\ncontent can change it in a way that will lead to an insecure deserialization exploitation. It might allow them to execute arbitrary code on the\napplication hosting server and take it over.
\nThe following code example is vulnerable to a race condition attack because it creates a temporary file using an unsafe API function.
\n\nImports System.IO\n\nSub Example()\n Dim TempPath = Path.GetTempFileName() 'Noncompliant\n\n Using Writer As New StreamWriter(TempPath)\n Writer.WriteLine(\"content\")\n End Using\nEnd Sub\n\n
\nImports System.IO\n\nSub Example()\n Dim RandomPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName())\n\n Using FileStream As New FileStream(RandomPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.DeleteOnClose)\n Using Writer As New StreamWriter(FileStream)\n Writer.WriteLine(\"content\")\n End Using\n End Using\nEnd Sub\n\n
Applications should create temporary files so that no third party can read or modify their content. It requires that the files' name, location, and\npermissions are carefully chosen and set. This can be achieved in multiple ways depending on the applications' technology stacks.
\nTemporary files can be created using unsafe functions and API as long as strong security controls are applied. Non-temporary file-handling\nfunctions and APIs can also be used for that purpose.
\nIn general, applications should ensure that attackers can not create a file before them. This turns into the following requirements when creating\nthe files:
\nMoreover, when possible, it is recommended that applications destroy temporary files after they have finished using them.
\nHere the example compliant code uses the Path.GetTempPath and Path.GetRandomFileName functions to generate a unique\nrandom file name. The file is then open with the FileMode.CreateNew option that will ensure the creation fails if the file already\nexists. The FileShare.None option will additionally prevent the file from being opened again by any process. To finish, this code ensures\nthe file will get destroyed once the application has finished using it with the FileOptions.DeleteOnClose option.
This vulnerability exposes encrypted data to a number of attacks whose goal is to recover the plaintext.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communications in a variety of domains. They are used\nfor several important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nFor AES, the weakest mode is ECB (Electronic Codebook). Repeated blocks of data are encrypted to the same value, making them easy to identify and\nreducing the difficulty of recovering the original cleartext.
\nUnauthenticated modes such as CBC (Cipher Block Chaining) may be used but are prone to attacks that manipulate the ciphertext. They must be used\nwith caution.
\nFor RSA, the weakest algorithms are either using it without padding or using the PKCS1v1.5 padding scheme.
\nThe cleartext of an encrypted message might be recoverable. Additionally, it might be possible to modify the cleartext of an encrypted message.
\nBelow are some real-world scenarios that illustrate possible impacts of an attacker exploiting the vulnerability.
\nThe encrypted message might contain data that is considered sensitive and should not be known to third parties.
\nBy using a weak algorithm the likelihood that an attacker might be able to recover the cleartext drastically increases.
\nBy modifying the cleartext of the encrypted message it might be possible for an attacker to trigger other vulnerabilities in the code. Encrypted\nvalues are often considered trusted, since under normal circumstances it would not be possible for a third party to modify them.
\nExample with a symmetric cipher, AES:
\n\nImports System.Security.Cryptography\n\nPublic Module Example\n\n Public Sub Encrypt()\n Dim Algorithm As New AesManaged() With {\n .KeySize = 128,\n .BlockSize = 128,\n .Mode = CipherMode.ECB, ' Noncompliant\n .Padding = PaddingMode.PKCS7\n }\n End Sub\nEnd Module\n\nExample with an asymmetric cipher, RSA:
\n\nImports System.Security.Cryptography\n\nPublic Module Example\n\n Public Sub Encrypt()\n Dim data(10) As Byte\n Dim RsaCsp = New RSACryptoServiceProvider()\n RsaCsp.Encrypt(data, False) ' Noncompliant\n End Sub\nEnd Module\n\n
For the AES symmetric cipher, use the GCM mode:
\n\nImports System.Security.Cryptography\n\nPublic Module Example\n\n Public Sub Encrypt()\n Dim data(10) As Byte\n Dim Algorithm As New AesGcm(data)\n End Sub\nEnd Module\n\n
For the RSA asymmetric cipher, use the Optimal Asymmetric Encryption Padding (OAEP):
\n\nImports System.Security.Cryptography\n\nPublic Module Example\n\n Public Sub Encrypt()\n Dim data(10) As Byte\n Dim RsaCsp = New RSACryptoServiceProvider()\n RsaCsp.Encrypt(data, True) ' Noncompliant\n End Sub\nEnd Module\n\n
As a rule of thumb, use the cryptographic algorithms and mechanisms that are considered strong by the cryptographic community.
\nAppropriate choices are currently the following.
\nThe best-known authenticated encryption mode for AES is Galois/Counter mode (GCM).
\nGCM mode combines encryption with authentication and integrity checks using a cryptographic hash function and provides both confidentiality and\nauthenticity of data.
\nOther similar modes are:
\nCounter with CBC-MACCipher Block Chaining with Message Authentication CodeEncrypt-and-AuthenticateInteger Authenticated Parallelizable ModeOffset Codebook ModeIt is also possible to use AES-CBC with HMAC for integrity checks. However, it is considered more straightforward to use AES-GCM directly\ninstead.
\nThe Optimal Asymmetric Encryption Padding scheme (OAEP) adds randomness and a secure hash function that strengthens the regular inner workings of\nRSA.
\nThis vulnerability makes it possible that the cleartext of the encrypted message might be recoverable without prior knowledge of the key.
\nEncryption algorithms are essential for protecting sensitive information and ensuring secure communication in various domains. They are used for\nseveral important reasons:
\nWhen selecting encryption algorithms, tools, or combinations, you should also consider two things:
\nFor these reasons, as soon as cryptography is included in a project, it is important to choose encryption algorithms that are considered strong and\nsecure by the cryptography community.
\nThe cleartext of an encrypted message might be recoverable. Additionally, it might be possible to modify the cleartext of an encrypted message.
\nBelow are some real-world scenarios that illustrate some impacts of an attacker exploiting the vulnerability.
\nThe encrypted message might contain data that is considered sensitive and should not be known to third parties.
\nBy using a weak algorithm the likelihood that an attacker might be able to recover the cleartext drastically increases.
\nBy modifying the cleartext of the encrypted message it might be possible for an attacker to trigger other vulnerabilities in the code. Encrypted\nvalues are often considered trusted, since under normal circumstances it would not be possible for a third party to modify them.
\nThe following code contains examples of algorithms that are not considered highly resistant to cryptanalysis and thus should be avoided.
\n\nImports System.Security.Cryptography\n\nPublic Sub Encrypt()\n Dim SimpleDES As New DESCryptoServiceProvider() ' Noncompliant\nEnd Sub\n\n
\nImports System.Security.Cryptography\n\nPublic Sub Encrypt()\n Dim AES128ECB = Aes.Create()\nEnd Sub\n\n
It is highly recommended to use an algorithm that is currently considered secure by the cryptographic community. A common choice for such an\nalgorithm is the Advanced Encryption Standard (AES).
\nFor block ciphers, it is not recommended to use algorithms with a block size that is smaller than 128 bits.
\nThe following code contains examples of algorithms that are not considered highly resistant to cryptanalysis and thus should be avoided.
\n\n```suggestion\nImports Org.BouncyCastle.Crypto.Engines\nImports Org.BouncyCastle.Crypto.Parameters\n\nPublic Sub Encrypt()\n Dim AesFast As new AesFastEngine() ' Noncompliant\nEnd Sub\n\n
\nImports Org.BouncyCastle.Crypto.Engines\nImports Org.BouncyCastle.Crypto.Parameters\n\n```suggestion\nPublic Sub Encrypt()\n Dim AES As new AESEngine()\nEnd Sub\n\n
It is highly recommended to use an algorithm that is currently considered secure by the cryptographic community. A common choice for such an\nalgorithm is the Advanced Encryption Standard (AES).
\nFor block ciphers, it is not recommended to use algorithms with a block size that is smaller than 128 bits.
\nThis vulnerability allows forging of JSON Web Tokens to impersonate other users.
\nJSON Web Tokens (JWTs), a popular method of securely transmitting information between parties as a JSON object, can become a significant security\nrisk when they are not properly signed with a robust cipher algorithm, left unsigned altogether, or if the signature is not verified. This\nvulnerability class allows malicious actors to craft fraudulent tokens, effectively impersonating user identities. In essence, the integrity of a JWT\nhinges on the strength and presence of its signature.
\nWhen a JSON Web Token is not appropriately signed with a strong cipher algorithm or if the signature is not verified, it becomes a significant\nthreat to data security and the privacy of user identities.
\nJWTs are commonly used to represent user authorization claims. They contain information about the user’s identity, user roles, and access rights.\nWhen these tokens are not securely signed, it allows an attacker to forge them. In essence, a weak or missing signature gives an attacker the power to\ncraft a token that could impersonate any user. For instance, they could create a token for an administrator account, gaining access to high-level\npermissions and sensitive data.
\nWhen a JWT is not securely signed, it can be tampered with by an attacker, and the integrity of the data it carries cannot be trusted. An attacker\ncan manipulate the content of the token and grant themselves permissions they should not have, leading to unauthorized data access.
\nThe following code contains examples of JWT encoding and decoding without a strong cipher algorithm.
\n\nImports JWT\n\nPublic Sub Decode(decoder AS IJwtDecoder)\n Dim decoded As String = decoder.Decode(token, secret, verify:= false) ' Noncompliant\nEnd Sub\n\n
\nImports JWT\n\nPublic Sub Decode()\n Dim decoded As String = new JwtBuilder()\n .WithSecret(secret)\n .Decode(token) ' Noncompliant\nEnd Sub\n\n
\nImports JWT\n\nPublic Sub Decode(decoder AS IJwtDecoder)\n Dim decoded As String = decoder.Decode(token, secret, verify:= true)\nEnd Sub\n\n
When using JwtBuilder, make sure to call MustVerifySignature().
\nImports JWT\n\nPublic Sub Decode()\n Dim decoded As String = new JwtBuilder()\n .WithSecret(secret)\n .MustVerifySignature()\n .Decode(token)\nEnd Sub\n\n
Resolving a vulnerability concerning the validation of JWT token signatures is mainly about incorporating a critical step into your process:\nvalidating the signature every time a token is decoded. Just having a signed token using a secure algorithm is not enough. If you are not validating\nsignatures, they are not serving their purpose.
\nEvery time your application receives a JWT, it needs to decode the token to extract the information contained within. It is during this decoding\nprocess that the signature of the JWT should also be checked.
\nTo resolve the issue, follow these instructions:
\nBy following these practices, you can ensure the security of your application’s JWT handling process, making it resistant to attacks that rely on\ntampering with tokens. Validation of the signature needs to be an integral and non-negotiable part of your token handling process.
\nEnsure that your secret keys are stored securely. They should not be hard-coded into your application code or checked into your version control\nsystem. Instead, consider using environment variables, secure key management systems, or vault services.
\nEven with the strongest cipher algorithms, there is a risk that your secret keys may be compromised. Therefore, it is a good practice to\nperiodically rotate your secret keys. By doing so, you limit the amount of time that an attacker can misuse a stolen key. When you rotate keys, be\nsure to allow a grace period where tokens signed with the old key are still accepted to prevent service disruptions.
\nRejecting requests with significant content length is a good practice to control the network traffic intensity and thus resource consumption in\norder to prevent DoS attacks.
\nThere is a risk if you answered yes to any of those questions.
\nIt is recommended to customize the rule with the limit values that correspond to the web application.
\n\nImports Microsoft.AspNetCore.Mvc\n\nPublic Class MyController\n Inherits Controller\n\n <HttpPost>\n <DisableRequestSizeLimit> ' Sensitive: No size limit\n <RequestSizeLimit(10485760)> ' Sensitive: 10485760 B = 10240 KB = 10 MB is more than the recommended limit of 8MB\n Public Function PostRequest(Model model) As IActionResult\n ' ...\n End Function\n\n <HttpPost>\n <RequestFormLimits(MultipartBodyLengthLimit = 10485760)> ' Sensitive: 10485760 B = 10240 KB = 10 MB is more than the recommended limit of 8MB\n Public Function MultipartFormRequest(Model model) As IActionResult\n ' ...\n End Function\n\nEnd Class\n\n
\nImports Microsoft.AspNetCore.Mvc\n\nPublic Class MyController\n Inherits Controller\n\n <HttpPost>\n <RequestSizeLimit(8388608)> ' Compliant: 8388608 B = 8192 KB = 8 MB\n Public Function PostRequest(Model model) As IActionResult\n ' ...\n End Function\n\n <HttpPost>\n <RequestFormLimits(MultipartBodyLengthLimit = 8388608)> ' Compliant: 8388608 B = 8192 KB = 8 MB\n Public Function MultipartFormRequest(Model model) AS IActionResult\n ' ...\n End Function\n\nEnd Class\n\n
ASP.NET 1.1+ comes with a feature called Request Validation, preventing the server to accept content containing un-encoded HTML. This\nfeature comes as a first protection layer against Cross-Site Scripting (XSS) attacks and act as a simple Web Application Firewall (WAF) rejecting\nrequests potentially containing malicious content.
\nWhile this feature is not a silver bullet to prevent all XSS attacks, it helps to catch basic ones. It will for example prevent <script\ntype=\"text/javascript\" src=\"https://malicious.domain/payload.js\"> to reach your Controller.
Note: Request Validation feature being only available for ASP.NET, no Security Hotspot is raised on ASP.NET Core applications.
\nThere is a risk if you answered yes to any of those questions.
\nAt Controller level:
\n\n<ValidateInput(False)>\nPublic Function Welcome(Name As String) As ActionResult\n ...\nEnd Function\n\n
At application level, configured in the Web.config file:
\n\n<configuration>\n <system.web>\n <pages validateRequest=\"false\" />\n ...\n <httpRuntime requestValidationMode=\"0.0\" />\n </system.web>\n</configuration>\n\n
At Controller level:
\n\n<ValidateInput(True)>\nPublic Function Welcome(Name As String) As ActionResult\n ...\nEnd Function\n\n
or
\n\nPublic Function Welcome(Name As String) As ActionResult\n ...\nEnd Function\n\n
At application level, configured in the Web.config file:
\n\n<configuration>\n <system.web>\n <pages validateRequest=\"true\" />\n ...\n <httpRuntime requestValidationMode=\"4.5\" />\n </system.web>\n</configuration>\n\n
Deserialization is the process of converting serialized data (such as objects or data structures) back into their original form. Types allowed to\nbe unserialized should be strictly controlled.
\nDuring the deserialization process, the state of an object will be reconstructed from the serialized data stream. By allowing unrestricted\ndeserialization of types, the application makes it possible for attackers to use types with dangerous or otherwise sensitive behavior during the\ndeserialization process.
\nWhen an application deserializes untrusted data without proper restrictions, an attacker can craft malicious serialized objects. Depending on the\naffected objects and properties, the consequences can vary.
\nIf attackers can craft malicious serialized objects that contain executable code, this code will run within the application’s context, potentially\ngaining full control over the system. This can lead to unauthorized access, data breaches, or even complete system compromise.
\nFor example, a well-known attack vector consists in serializing an object of type
Unrestricted deserialization can also enable attackers to escalate their privileges within the application. By manipulating the serialized data, an\nattacker can modify object properties or bypass security checks, granting them elevated privileges that they should not have. This can result in\nunauthorized access to sensitive data, unauthorized actions, or even administrative control over the application.
\nIn some cases, an attacker can abuse the deserialization process to cause a denial of service (DoS) condition. By providing specially crafted\nserialized data, the attacker can trigger excessive resource consumption, leading to system instability or unresponsiveness. This can disrupt the\navailability of the application, impacting its functionality and causing inconvenience to users.
\nWith BinaryFormatter,\nNetDataContractSerializer\nor SoapFormatter:
\nDim myBinaryFormatter = New BinaryFormatter()\nmyBinaryFormatter.Deserialize(stream) ' Noncompliant\n\n
With JavaScriptSerializer:
\nDim serializer1 As JavaScriptSerializer = New JavaScriptSerializer(New SimpleTypeResolver()) ' Noncompliant: SimpleTypeResolver is insecure (every type is resolved)\nserializer1.Deserialize(Of ExpectedType)(json)\n\n
With BinaryFormatter,\nNetDataContractSerializer\nor SoapFormatter:
\nNotInheritable Class CustomBinder\n Inherits SerializationBinder\n Public Overrides Function BindToType(assemblyName As String, typeName As String) As Type\n If Not (Equals(typeName, \"type1\") OrElse Equals(typeName, \"type2\") OrElse Equals(typeName, \"type3\")) Then\n Throw New SerializationException(\"Only type1, type2 and type3 are allowed\")\n End If\n Return Assembly.Load(assemblyName).[GetType](typeName)\n End Function\nEnd Class\n\nDim myBinaryFormatter = New BinaryFormatter()\nmyBinaryFormatter.Binder = New CustomBinder()\nmyBinaryFormatter.Deserialize(stream)\n\n
With JavaScriptSerializer:
\nPublic Class CustomSafeTypeResolver\n Inherits JavaScriptTypeResolver\n Public Overrides Function ResolveType(id As String) As Type\n If Not Equals(id, \"ExpectedType\") Then\n Throw New ArgumentNullException(\"Only ExpectedType is allowed during deserialization\")\n End If\n Return Type.[GetType](id)\n End Function\nEnd Class\n\nDim serializer As JavaScriptSerializer = New JavaScriptSerializer(New CustomSafeTypeResolver())\nserializer.Deserialize(Of ExpectedType)(json)\n\n
Instead of using BinaryFormatter\nand similar serializers, it is recommended to use safer alternatives in most of the cases, such as XmlSerializer or DataContractSerializer.
If it’s not possible then try to mitigate the risk by restricting the types allowed to be deserialized:
\nRegular expressions have their own syntax that is\nunderstood by regular expression engines. Those engines will throw an exception at runtime if they are given a regular expression that does not\nconform to that syntax.
\nTo avoid syntax errors, special characters should be
Negative
\nSub Regexes(Input As String)\n Dim Rx As New Regex(\"[A\") ' Noncompliant: unmatched \"[\"\n Dim Match = Regex.Match(Input, \"[A\") ' Noncompliant\n Dim NegativeLookahead As New Regex(\"a(?!b)\", RegexOptions.NonBacktracking) ' Noncompliant: negative lookahead without backtracking\n Dim NegativeLookbehind As New Regex(\"(?<!a)b\", RegexOptions.NonBacktracking) ' Noncompliant: negative lookbehind without backtracking\nEnd Sub\n\n
\nSub Regexes(Input As String)\n Dim Rx As New Regex(\"[A-Z]\")\n Dim Match = Regex.Match(Input, \"[A-Z]\")\n Dim NegativeLookahead As New Regex(\"a(?!b)\")\n Dim NegativeLookbehind As New Regex(\"(?<!a)b\")\nEnd Sub\n\n
Functions can return values using two different syntaxes. The modern, and correct, way to do it is to use a Return statement. The VB6\nway, i.e. old way, is to assign a return value to the function’s name .
The VB6 syntax is obsolete as it was introduced to simplify migration from VB6 projects. The compiler will create a local variable which is\nimplicitly returned when execution exits the function’s scope.
\nReturn statement should be used instead as they are easier to read and understand.
\nPublic Function FunctionName() As Integer\n FunctionName = 42 ' Noncompliant\nEnd Function\n\nPublic Function FunctionNameFromVariable() As Integer\n Dim Value As Integer = 42\n FunctionNameFromVariable = Value ' Noncompliant\nEnd Function\n\n
\nPublic Function FunctionName() As Integer\n Return 42\nEnd Function\n\nPublic Function FunctionNameFromVariable() As Integer\n Dim Value As Integer = 42\n Return Value\nEnd Function\n\n
There are several compilations options available for Visual Basic source code and Option Strict defines compiler behavior for implicit\ndata type conversions. Specifying Option Strict Off will allow:
Object typeThis behavior can lead to unexpected runtime errors due to type mismatch or missing members.
\nOption Strict can be set in project properties or overridden in individual source files.
\nOption Strict Off ' Noncompliant\n\nPublic Class KnownType\n\n Public ReadOnly Property Name As String\n\nEnd Class\n\nPublic Module MainMod\n\n Public Function DoSomething(Arg) As String ' Type for \"Arg\" argument is not defined.\n Dim Item As KnownType = Arg ' Implicit narrowing conversion doesn't enforce \"Arg\" to be of type \"KnownType\"\n Return Arg.Title ' \"Title\" might not exist in \"Arg\"\n End Function\n\nEnd Module\n\n
\nOption Strict On\n\nPublic Class KnownType\n\n Public ReadOnly Property Name As String\n\nEnd Class\n\nPublic Module MainMod\n\n Public Function DoSomething(Arg As KnownType) As String\n Dim Item As KnownType = Arg\n Return Arg.Name\n End Function\n\nEnd Module\n\n
There are several compilations options available for Visual Basic source code and Option Explicit defines compiler behavior for\nimplicit variable declarations. Specifying Option Explicit Off will allow creating a variable by it’s first usage. This behavior can lead\nto unexpected runtime errors due to typos in variable names.
Option Explicit can be set in project properties or overridden in individual source files.
\nOption Explicit Off ' Noncompliant\n\nModule MainMod\n\n Public Sub DoSomething(First As String, Second As String)\n Parameter = Fist ' New local variable \"Fist\" is created and assigned to new local variable \"Parameter\" instead of \"First\" argument.\n DoSomething(Parameter)\n Parametr = Second ' \"Second\" argument is assigned to newly created variable \"Parametr\" instead of intended \"Parameter\".\n DoSomething(Parameter) ' Value of \"Parameter\" is always Nothing\n End Sub\n\n Private Sub DoSomething(Parameter As String)\n ' ...\n End Sub\n\nEnd Module\n\n
\nOption Explicit On\n\nModule MainMod\n\n Public Sub DoSomething(First As String, Second As String)\n Dim Parameter As String = First\n DoSomething(Parameter)\n Parameter = Second\n DoSomething(Parameter)\n End Sub\n\n Private Sub DoSomething(Parameter As String)\n ' ...\n End Sub\n\nEnd Module\n\n
One of the principles of a unit test is that it must have full control of the system under test. This is problematic when production code includes\ncalls to static methods, which cannot be changed or controlled. Date/time functions are usually provided by system libraries as static methods.
\nThis can be improved by wrapping the system calls in an object or service that can be controlled inside the unit test.
\n\nPublic Class Foo\n Public Function HelloTime() As String\n Return $\"Hello at {DateTime.UtcNow}\"\n End Function\nEnd Class\n\nThere are different approaches to solve this problem. One of them is suggested below. There are also open source libraries (such as NodaTime) which\nalready implement an IClock interface and a FakeClock testing class.
\nPublic Interface IClock\n Function UtcNow() As Date\nEnd Interface\n\nPublic Class Foo\n Public Function HelloTime(clock As IClock) As String\n Return $\"Hello at {clock.UtcNow()}\"\n End Function\nEnd Class\n\nPublic Class FooTest\n Public Class TestClock\n Implements IClock\n ' implement\n End Class\n\n <Fact>\n Public Sub HelloTime_Gives_CorrectTime()\n Dim dateTime = New DateTime(2017, 06, 11)\n Assert.Equal((New Foo()).HelloTime(New TestClock(dateTime)), $\"Hello at {dateTime}\")\n End Sub\nEnd Class\n\nAnother possible solution is using an adaptable module, ideally supports an IDisposable method, that not only adjusts the time behaviour for the\ncurrent thread only, but also for scope of the using.
\n\nPublic Module Clock\n Public Function UtcNow() As Date\n End Function\n\n Public Function SetTimeForCurrentThread(time As Func(Of Date)) As IDisposable\n End Function\nEnd Module\n\nPublic Class Foo\n Public Function HelloTime() As String\n Return $\"Hello at {Clock.UtcNow()}\"\n End Function\nEnd Class\n\nPublic Class FooTest\n <Fact>\n Public Sub HelloTime_Gives_CorrectTime()\n Dim dateTime = New DateTime(2017, 06, 11)\n\n Using SetTimeForCurrentThread(Function() dateTime)\n Assert.Equal((New Foo()).HelloTime(), $\"Hello at {dateTime}\")\n End Using\n End Sub\nEnd Class\n\nHard-coding secrets in source code or binaries makes it easy for attackers to extract sensitive information, especially in distributed or\nopen-source applications. This practice exposes credentials and tokens, increasing the risk of unauthorized access and data breaches.
\nThis rule detects variables/fields/properties having a name matching a list of words (secret, token, credential, auth, api[_.-]?key) being assigned\na pseudorandom hard-coded value. The pseudorandomness of the hard-coded value is based on its entropy and the probability to be human-readable. The\nrandomness sensibility can be adjusted if needed. Lower values will detect less random values, raising potentially more false positives.
\nSecrets should be stored in a configuration file that is not committed to the code repository, in a database, or managed by your cloud provider’s\nsecrets management service. If a secret is exposed in the source code, it must be rotated immediately.
\n\nPrivate MySecret As String = \"47828a8dd77ee1eb9dde2d5e93cb221ce8c32b37\"\n\n
\nPrivate MySecret As String = Environment.GetEnvironmentVariable(\"MYSECRET\")\n\n
Not specifying a timeout for regular expressions can lead to a Denial-of-Service attack. Pass a timeout when using\nSystem.Text.RegularExpressions to process untrusted input because a malicious user might craft a value for which the evaluation lasts\nexcessively long.
There is a risk if you answered yes to any of those questions.
\nmatchTimeout when executing a\n regular expression.RegexOptions.NonBacktracking.\nPublic Sub RegexPattern(Input As String)\n Dim EmailPattern As New Regex(\".+@.+\", RegexOptions.None)\n Dim IsNumber as Boolean = Regex.IsMatch(Input, \"[0-9]+\")\n Dim IsLetterA as Boolean = Regex.IsMatch(Input, \"(a+)+\")\nEnd Sub\n\n
\nPublic Sub RegexPattern(Input As String)\n Dim EmailPattern As New Regex(\".+@.+\", RegexOptions.None, TimeSpan.FromMilliseconds(100))\n Dim IsNumber as Boolean = Regex.IsMatch(Input, \"[0-9]+\", RegexOptions.None, TimeSpan.FromMilliseconds(100))\n Dim IsLetterA As Boolean = Regex.IsMatch(Input, \"(a+)+\", RegexOptions.NonBacktracking) '.Net 7 And above\n AppDomain.CurrentDomain.SetData(\"REGEX_DEFAULT_MATCH_TIMEOUT\", TimeSpan.FromMilliseconds(100)) 'process-wide setting\nEnd Sub\n\n
The Justification property was added to\nthe ExcludeFromCodeCoverageAttribute as an opportunity to document the rationale for the exclusion. This rule raises an issue when no\nsuch justification is given.
\nPublic Structure Coordinates\n\n Public ReadOnly Property X As Integer\n Public ReadOnly Property Y As Integer\n\n <ExcludeFromCodeCoverage> ' Noncompliant\n Public Overrides Function Equals(obj As Object) As Boolean\n If Not (TypeOf obj Is Coordinates) Then\n Return False\n End If\n\n Dim coordinates = DirectCast(obj, Coordinates)\n Return X = coordinates.X AndAlso\n Y = coordinates.Y\n End Function\n\n <ExcludeFromCodeCoverage> ' Noncompliant\n Public Overrides Function GetHashCode() As Integer\n Dim hashCode As Long = 1861411795\n hashCode = (hashCode * -1521134295 + X.GetHashCode()).GetHashCode()\n hashCode = (hashCode * -1521134295 + Y.GetHashCode()).GetHashCode()\n Return hashCode\n End Function\nEnd Structure\n\n
\nPublic Structure Coordinates\n\n Public ReadOnly Property X As Integer\n Public ReadOnly Property Y As Integer\n\n <ExcludeFromCodeCoverage(Justification:=\"Code generated by Visual Studio refactoring\")> ' Compliant\n Public Overrides Function Equals(obj As Object) As Boolean\n If Not (TypeOf obj Is Coordinates) Then\n Return False\n End If\n\n Dim coordinates = DirectCast(obj, Coordinates)\n Return X = coordinates.X AndAlso\n Y = coordinates.Y\n End Function\n\n <ExcludeFromCodeCoverage(Justification:=\"Code generated by Visual Studio refactoring\")> ' Compliant\n Public Overrides Function GetHashCode() As Integer\n Dim hashCode As Long = 1861411795\n hashCode = (hashCode * -1521134295 + X.GetHashCode()).GetHashCode()\n hashCode = (hashCode * -1521134295 + Y.GetHashCode()).GetHashCode()\n Return hashCode\n End Function\nEnd Structure\n\n
The rule targets the use of DateTime.Now call followed by some arithmetic operation.
Using DateTime.Now calls within a subtraction operation to measure elapsed time is not recommended. This property is subject to\nchanges such as daylight savings transitions, which can invalidate the calculation if the change occurs during the benchmark session, or when updating\na timer. Moreover, DateTime.Now is dependent on the system clock, which may have low resolution on older systems (as low as 15\nmilliseconds).
If the purpose is to benchmark something then, instead of the DateTime.Now property, it’s recommended to use Stopwatch,\nwhich is not affected by changes in time such as daylight savings (DST) and automatically checks for the existence of high-precision timers. As a\nbonus, the StopWatch class is also lightweight and computationally faster than DateTime.
\nDim start = DateTime.Now ' First call, on March 26th 2:59 am\n' Method to be benchmarked\n\nConsole.WriteLine($\"{CInt((DateTime.Now - start).TotalMilliseconds)} ms\") ' Second call happens 2 minutes later but `Now` is March 26th, 4:01 am as there's a shift to summer time\n\n\nDim stopWatch = Stopwatch.StartNew() ' Compliant\n' Method to be benchmarked\nstopWatch.Stop()\n\nConsole.WriteLine($\"{stopWatch.ElapsedMilliseconds} ms\")\n\nIf, on the other hand, the goal is to refresh a timer prefer using the DateTime.UtcNow property, which guarantees reliable results\nwhen doing arithmetic operations during DST transitions.
\nIf (Date.Now - lastRefresh).TotalMilliseconds > MinRefreshInterval Then\n lastRefresh = Date.Now\n ' Refresh\nEnd If\n\n
\nIf (Date.UtcNow - lastRefresh).TotalMilliseconds > MinRefreshInterval Then\n lastRefresh = Date.UtcNow\n ' Refresh\nEnd If\n\n
Not knowing the Kind of the DateTime object that an application is using can lead to misunderstandings when displaying or\ncomparing them. Explicitly setting the Kind property helps the application to stay consistent, and its maintainers understand what kind\nof date is being managed. To achieve this, when instantiating a new DateTime object you should always use a constructor overload that\nallows you to define the Kind property.
Creating the DateTime object without specifying the property Kind will set it to the default value of\nDateTimeKind.Unspecified. In this case, calling the method ToUniversalTime will assume that Kind is\nDateTimeKind.Local and calling the method ToLocalTime will assume that it’s DateTimeKind.Utc. As a result, you\nmight have mismatched DateTime objects in your application.
To resolve this issue, use a constructor overload that lets you\nspecify the DateTimeKind when creating the\nDateTime object. From .Net 6 onwards, use the DateOnly type if the time portion of the date is not\nrelevant.
\nPrivate Sub CreateNewTime()\n Dim birthDate = New DateTime(1994, 7, 5, 16, 23, 42)\nEnd Sub\n\n
\nPrivate Sub CreateNewTime()\n Dim birthDate = New DateTime(1994, 7, 5, 16, 23, 42, DateTimeKind.Utc)\n ' or from .Net 6 onwards, use DateOnly:\n Dim birthDate = New DateOnly(1994, 7, 5)\nEnd Sub\n\n
You should avoid recording time instants with the use of property DateTime.Now. The property DateTime.Now returns the\ncurrent date and time expressed in the machine’s local time without containing any timezone-related information (for example, the offset from\nCoordinated Universal Time). Not having this information means that if you need to display this DateTime object or use it for\ncomputations in another machine placed in a different time zone, you won’t be able to reconstruct it in the second machine’s local time without\nknowing the origin’s offset. This will likely lead to confusion and potential bugs.
Instead, you should record the DateTime instants in UTC, which gives you the date and time as it is in the Coordinated Universal Time.\nUTC is a time standard for all time zones and is not subjected to Daylight Saving Time (DST).
Similarly, the use of the DateTime.Today property should also be avoided, as it can return different date values depending on the time\nzone.
Generally, unless the purpose is to only display the Date and Time to a user on their local machine, you should always use UTC (for example, when\nstoring dates in a datebase or using them for calculations).
\nYou can end up with DateTime instants that have no meaning for anyone except the machine they were recorded on. Using UTC gives an\nunambiguous representation of an instant, and this UTC instant can be transformed into any equivalent local time. This operation isn’t reversible as\nsome local times are ambiguous and can be matched to more than one UTC instant (for example, due to daylight savings).
Instead of DateTime.Now use any of the following:
DateTime.UtcNow,DateTimeOffSet.Now (as it contains offset information)DateTimeOffSet.UtcNowInstead of DateTime.Today use any of the following:
DateTime.UtcNow.Date,DateOnly.FromDateTime(DateTime.UtcNow) (.NET 6.0+)\nPrivate Sub LogDateTime()\n Using streamWriter = New StreamWriter(\"logs.txt\", True)\n End Using\n\n streamWriter.WriteLine($\"DateTime:{DateTime.Now.ToString(\"o\")}\") ' This log won't have any meaning if it's reconstructed in a machine in a different timezone.\nEnd Sub\n\n\nPrivate Sub LogDateTime()\n Using streamWriter = New StreamWriter(\"logs.txt\", True)\n End Using\n\n streamWriter.WriteLine($\"DateTime:{DateTime.UtcNow.ToString(\"o\")}\")\nEnd Sub\n\nThis rule recommends using DateTimeOffset instead of DateTime for projects targeting .NET Framework 2.0 or later.
You should use DateTimeOffset instead of DateTime as it provides all the information that the DateTime\nstruct has, and additionally, the offset from Coordinated Universal Time (UTC). This way you can avoid potential problems created by the lack of\ntimezone awareness (see the \"Pitfalls\" section below for more information).
However, it’s important to note that although DateTimeOffset contains more information than DateTime by storing the\noffset to UTC, it isn’t tied to a specific time zone. This information must be stored separately to have a full picture of the moment in time with the\nuse of TimeZoneInfo.
In most cases, you can directly replace DateTime with DateTimeOffset. When hardcoding dates with local kind, remember\nthat the offset is timezone dependent, so it should be set according to which timezone that data represents. For more information, refer to\nDateTime and DateTimeOffset documentation from Microsoft (see the \"Resources\" section below).
\nDim myDate As DateTime = New DateTime(2008, 6, 19, 7, 0, 0, DateTimeKind.Local) ' Noncompliant\n\nDim now = DateTime.Now ' Noncompliant\n\n
\nDim myDate As DateTimeOffset = New DateTimeOffset(2008, 6, 19, 7, 0, 0, TimeSpan.FromHours(-7)) ' Compliant\n\nDim now = DateTimeOffset.Now ' Compliant\n\n
Common DateTime pitfalls include:
DateTime of kind Local consider the time offset of the machine where the program is running. Not\n storing the offset from UTC separately can result in meaningless data when retrieved from a different location.DateTime of kind Unknown, calling ToUniversalTime() presumes the\n DateTime.Kind is local and converts to UTC, if you call the method ToLocalTime(), it assumes the\n DateTime.Kind is UTC and converts it to local.DateTimes objects, the user must ensure they are within the same time zone. DateTime doesn’t consider\n UTC/Local when comparing; it only cares about the number of Ticks on the objects.Since .NET 6 you don’t have to use the TimeZoneConverter library to manually do the conversion between IANA and Windows timezones. The\n.NET 6.0 introduced new Time Zone enhancements, one being the TimeZoneInfo.FindSystemTimeZoneById(string timezone) method now accepts as\ninput both IANA and Windows time zone IDs on any operating system with installed time zone data. TimeZoneInfo.FindSystemTimeZoneById will\nautomatically convert its input from IANA to Windows and vice versa if the requested time zone is not found on the system.
The method TimeZoneInfo.FindSystemTimeZoneById(string timezone) can get both IANA and Windows timezones as input and automatically\nconvert one to the other if the requested time zone is not found on the system. Because one does not need to handle the conversion, the code will be\nless complex and easier to maintain.
There’s no need to translate manually between time zones; it is enough to call TimeZoneInfo.FindSystemTimeZoneById(string timezone),\nwhere the timezone can be IANA or Windows format. Depending on the OS, the equivalent time zone will be returned (Windows Time Zones for Windows and\nIANA timezones for Linux, macOS).
\n// Assuming we are in Windows OS and we need to get the Tokyo Time Zone.\nDim ianaTimeZone = \"Asia/Tokyo\"\nDim windowsTimeZone = TZConvert.IanaToWindows(ianaTimeZone)\nDim tokyoWindowsTimeZone As TimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(windowsTimeZone)\n\n
\n// Assuming we are in Windows OS and we need to get the Tokyo Time Zone.\nDim ianaTimeZone = \"Asia/Tokyo\"\nDim tokyoWindowsTimeZone As TimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(ianaTimeZone)\n\n
When converting a string representation of a date and time to a DateTime object or any other temporal type with one of the available\nsystem parsing methods, you should always provide an IFormatProvider parameter.
If you try to parse a string representation of a date or time without a format provider, the method will use the machine’s\nCultureInfo; if the given string does not follow it, you’ll have an object that does not match the string representation or an unexpected\nruntime error.
This rule raises an issue for the following date and time string representation parsing methods:
\nParseParseExactTryParseTryParseExactOf the following types:
\nSystem.DateOnlySystem.DateTimeSystem.DateTimeOffsetSystem.TimeOnlySystem.TimeSpanAlway use an overload of the parse method, where you can provide an IFormatProvider parameter.
\nDim dateTimeString = \"4/12/2023 4:05:48 PM\" ' This is an en-US format string - 12 of April 2023\nDim dateTimeObject = DateTime.Parse(dateTimeString) ' This is wrongly parsed as 4th of December, when it's read in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe)\n\nDim dateTimeString2 = \"4/13/2023 4:05:48 PM\" ' This is an en-US format string - 13 of April 2023\nDim dateTimeObject2 = DateTime.Parse(dateTimeString2) ' Runtime Error, when it's parsed in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe).\n\nDim timeInSaudiArabia = New TimeOnly(16, 23).ToString(New CultureInfo(\"ar-SA\"))\nDim timeObject = TimeOnly.Parse(timeInSaudiArabia) ' Runtime Error, when it's parsed in a machine with \"CultureInfo.CurrentCulture\" en-150 (English Europe).\n\n
\nDim dateTimeString = \"4/12/2023 4:05:48 PM\" ' This is an en-US format string - 12 of April 2023\nDim dateTimeObject = DateTime.Parse(dateTimeString, New CultureInfo(\"en-US\"))\n\nDim dateTimeString2 = \"4/13/2023 4:05:48 PM\" ' This is an en-US format string - 13 of April 2023\nDim dateTimeObject2 = DateTime.Parse(dateTimeString2, New CultureInfo(\"en-US\"))\n\nDim timeInSaudiArabia = New TimeOnly(16, 23).ToString(New CultureInfo(\"ar-SA\"))\nDim timeObject = TimeOnly.Parse(timeInSaudiArabia, New CultureInfo(\"ar-SA\"))\n\n
Hardcoding the date and time format strings can lead to formats that consumers misunderstand. Also, if the same format is meant to be used in\nmultiple places, it is easier to make a mistake when it’s hardcoded instead of using a format provided by an IFormatProvider or using one\nof the standard format strings.
If a non-conventional format is used, the formatted date and time can be misunderstood. Also, if a mistake is made in the format, the formatted\ndate can be incomplete. For example, you might switch the place of the minutes and month parts of a date or simply forget to print the year.
\nInstead of hardcoding the format, provide one from the available formats through an IFormatProvider or use one of the standard format\nstrings.
\nPrivate Sub PrintTime()\n Console.WriteLine(DateTime.UtcNow.ToString(\"dd/MM/yyyy HH:mm:ss\"))\n\n Console.WriteLine(DateTime.UtcNow.ToString(\"dd/mm/yyyy HH:MM:ss\")) ' Months and minutes have changed their places\nEnd Sub\n\n
\nPrivate Sub PrintTime()\n Console.WriteLine(DateTime.UtcNow.ToString(CultureInfo.GetCultureInfo(\"es-MX\")))\n\n Console.WriteLine(DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)) ' Better provide a well known culture, so this kind of issues do not pop up\nEnd Sub\n\n
With .NET Core the UnixEpoch field was introduced to DateTime and DateTimeOffset types. Using this field\nclearly states that the intention is to use the beginning of the Unix epoch.
You should not use the DateTime or DateTimeOffset constructors to set the time to the 1st of January 1970 to represent\nthe beginning of the Unix epoch. Not everyone is familiar with what this particular date is representing and it can be misleading.
To fix this issue, use the UnixEpoch field of DateTime or DateTimeOffset instead of the constructor.
\nPrivate Sub GetEpochTime()\n Dim epochTime = New DateTime(1970, 1, 1)\nEnd Sub\n\n
\nPrivate Sub GetEpochTime()\n Dim epochTime = DateTime.UnixEpoch\nEnd Sub\n\n
Both the List.Find method and the Enumerable.FirstOrDefault method can be used to locate the first element that meets a\nspecified condition within a collection. However, for List objects, List.Find may offer superior performance compared to\nEnumerable.FirstOrDefault. While the performance difference might be negligible for small collections, it can become significant for\nlarger collections. This observation also holds true for ImmutableList and arrays.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the FirstOrDefault closer to the performance of collection-specific Find methods in most scenarios.
Applies to
\nWe measured at least 2x improvement in the execution time. For more details see the Benchmarks section from the More info\ntab.
The Find method is defined on the collection class, and it has the same signature as FirstOrDefault extension method. The\nfunction can be replaced in place.
\nFunction GetValue(data As List(Of Integer)) As Integer\n Return data.FirstOrDefault(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction GetValue(data() As Integer) As Integer\n Return data.FirstOrDefault(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction GetValue(data As List(Of Integer)) As Integer\n Return data.Find(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction GetValue(data() As Integer) As Integer\n Return Array.Find(data, Function(x) x Mod 2 = 0)\nEnd Function\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 10.515 μs \n | \n \n 0.1410 μs \n | \n \n 32 B \n | \n
| \n ArrayFind \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 4.417 μs \n | \n \n 0.0729 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 2.262 μs \n | \n \n 0.0135 μs \n | \n \n - \n | \n
| \n ArrayFind \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 3.428 μs \n | \n \n 0.0206 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 45.074 μs \n | \n \n 0.7517 μs \n | \n \n 32 B \n | \n
| \n ArrayFind \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 13.948 μs \n | \n \n 0.1496 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 83.796 μs \n | \n \n 1.3199 μs \n | \n \n 72 B \n | \n
| \n ImmutableListFind \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 59.720 μs \n | \n \n 1.0723 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 81.984 μs \n | \n \n 1.0886 μs \n | \n \n 72 B \n | \n
| \n ImmutableListFind \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 58.288 μs \n | \n \n 0.8079 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 446.893 μs \n | \n \n 9.8430 μs \n | \n \n 76 B \n | \n
| \n ImmutableListFind \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 427.476 μs \n | \n \n 3.3371 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 14.808 μs \n | \n \n 0.1723 μs \n | \n \n 40 B \n | \n
| \n ListFind \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 6.040 μs \n | \n \n 0.1104 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 2.233 μs \n | \n \n 0.0154 μs \n | \n \n - \n | \n
| \n ListFind \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 4.458 μs \n | \n \n 0.0745 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListFirstOrDefault \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 57.290 μs \n | \n \n 1.0494 μs \n | \n \n 40 B \n | \n
| \n ListFind \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 18.476 μs \n | \n \n 0.0504 μs \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == 1;\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == 1;\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate int[] array;\npublic const int N = 10_000;\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic int ListFirstOrDefault() =>\n list.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic int ListFind() =>\n list.Find(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic int ImmutableListFirstOrDefault() =>\n immutableList.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic int ImmutableListFind() =>\n immutableList.Find(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic int ArrayFirstOrDefault() =>\n array.FirstOrDefault(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic int ArrayFind() =>\n Array.Find(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6602.json", "content": "{\n \"title\": \"\\\"Find\\\" method should be used instead of the \\\"FirstOrDefault\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6602\",\n \"sqKey\": \"S6602\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6603.html", "content": "
Both the List.TrueForAll method and the IEnumerable.All method can be used to check if all list elements satisfy a given\ncondition in a collection. However, List.TrueForAll can be faster than IEnumerable.All for List objects. The\nperformance difference may be minor for small collections, but for large collections, it can be noticeable.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the All closer to the performance of collection-specific TrueForAll methods in most scenarios.
Applies to
\nWe measured at least 4x improvement both in execution time. For more details see the Benchmarks section from the More\ninfo tab.
The TrueForAll method is defined on the collection class, and it has the same signature as the All extension method. The\nmethod can be replaced in place.
\nPublic Function AreAllEven(data As List(Of Integer)) As Boolean\n Return data.All(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nPublic Function AreAllEven(data As Integer()) As Boolean\n Return data.All(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nPublic Function AreAllEven(data As List(Of Integer)) As Boolean\n Return data.TrueForAll(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nPublic Function AreAllEven(data As Integer()) As Boolean\n Return Array.TrueForAll(data, Function(x) x Mod 2 = 0)\nEnd Function\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayAll \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 109.25 μs \n | \n \n 1.767 μs \n | \n \n 32 B \n | \n
| \n ArrayTrueForAll \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 45.01 μs \n | \n \n 0.547 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAll \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 22.28 μs \n | \n \n 0.254 μs \n | \n \n - \n | \n
| \n ArrayTrueForAll \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 37.60 μs \n | \n \n 0.382 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAll \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 495.90 μs \n | \n \n 4.342 μs \n | \n \n 40 B \n | \n
| \n ArrayTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 164.52 μs \n | \n \n 2.030 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 940.29 μs \n | \n \n 5.600 μs \n | \n \n 72 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 679.46 μs \n | \n \n 2.371 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 922.43 μs \n | \n \n 14.564 μs \n | \n \n 72 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 692.31 μs \n | \n \n 8.897 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 4,578.72 μs \n | \n \n 77.920 μs \n | \n \n 128 B \n | \n
| \n ImmutableListTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 4,393.49 μs \n | \n \n 122.061 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 970.45 μs \n | \n \n 13.598 μs \n | \n \n 73 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 687.82 μs \n | \n \n 6.142 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 981.17 μs \n | \n \n 12.966 μs \n | \n \n 72 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T>.Builder \n | \n \n 710.19 μs \n | \n \n 16.195 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListBuilderAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T>.Builder \n | \n \n 4,780.50 μs \n | \n \n 43.282 μs \n | \n \n 128 B \n | \n
| \n ImmutableListBuilderTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T>.Builder \n | \n \n 4,493.82 μs \n | \n \n 76.530 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 151.12 μs \n | \n \n 2.028 μs \n | \n \n 40 B \n | \n
| \n ListTrueForAll \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 58.03 μs \n | \n \n 0.493 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 22.14 μs \n | \n \n 0.327 μs \n | \n \n - \n | \n
| \n ListTrueForAll \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 46.01 μs \n | \n \n 0.327 μs \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAll \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 619.86 μs \n | \n \n 6.037 μs \n | \n \n 48 B \n | \n
| \n ListTrueForAll \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 208.49 μs \n | \n \n 2.340 μs \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == Math.Abs(x);\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == Math.Abs(x);\n\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate ImmutableList<int>.Builder immutableListBuilder;\nprivate int[] array;\n\n[Params(100_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n immutableListBuilder = ImmutableList.CreateBuilder<int>();\n immutableListBuilder.AddRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic bool ListAll() =>\n list.All(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic bool ListTrueForAll() =>\n list.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic bool ImmutableListAll() =>\n immutableList.All(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic bool ImmutableListTrueForAll() =>\n immutableList.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>.Builder\"), Benchmark(Baseline = true)]\npublic bool ImmutableListBuilderAll() =>\n immutableListBuilder.All(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>.Builder\"), Benchmark]\npublic bool ImmutableListBuilderTrueForAll() =>\n immutableListBuilder.TrueForAll(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic bool ArrayAll() =>\n array.All(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic bool ArrayTrueForAll() =>\n Array.TrueForAll(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6603.json", "content": "{\n \"title\": \"The collection-specific \\\"TrueForAll\\\" method should be used instead of the \\\"All\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6603\",\n \"sqKey\": \"S6603\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6605.html", "content": "
Both the List.Exists method and IEnumerable.Any method can be used to find the first element that satisfies a predicate\nin a collection. However, List.Exists can be faster than IEnumerable.Any for List objects, as well as requires\nsignificantly less memory. For small collections, the performance difference may be negligible, but for large collections, it can be noticeable. The\nsame applies to ImmutableList and arrays too.
It is important to enable this rule with caution, as performance outcomes can vary significantly across different runtimes. Notably, the Any closer to the performance of collection-specific Exists methods in most scenarios.
Applies to
\nWe measured at least 3x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
Also, no memory allocations were needed for the Exists method, since the search is done in-place.
Since LINQ to\nEntities relies a lot on System.Linq for
The Exists method is defined on the collection class, and it has the same signature as Any extension method if a\npredicate is used. The method can be replaced in place.
\nFunction ContainsEven(data As List(Of Integer)) As Boolean\n Return data.Any(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction ContainsEven(data() As Integer) As Boolean\n Return data.Any(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction ContainsEven(data As List(Of Integer)) As Boolean\n Return data.Exists(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nFunction ContainsEven(data() As Integer) As Boolean\n Return Array.Exists(data, Function(x) x Mod 2 = 0)\nEnd Function\n\n
| Method | \nRuntime | \nCategories | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|---|
| \n ArrayAny \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 1,174.0 ns \n | \n \n 16.44 ns \n | \n \n 32 B \n | \n
| \n ArrayExists \n | \n \n .NET 8.0 \n | \n \n Array \n | \n \n 570.6 ns \n | \n \n 7.12 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAny \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 358.5 ns \n | \n \n 5.57 ns \n | \n \n - \n | \n
| \n ArrayExists \n | \n \n .NET 9.0 \n | \n \n Array \n | \n \n 581.6 ns \n | \n \n 6.17 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ArrayAny \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 4,896.0 ns \n | \n \n 102.83 ns \n | \n \n 32 B \n | \n
| \n ArrayExists \n | \n \n .NET Framework 4.8.1 \n | \n \n Array \n | \n \n 1,649.4 ns \n | \n \n 29.81 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 7,859.3 ns \n | \n \n 91.45 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET 8.0 \n | \n \n ImmutableList<T> \n | \n \n 5,898.1 ns \n | \n \n 81.69 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 7,748.9 ns \n | \n \n 119.10 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET 9.0 \n | \n \n ImmutableList<T> \n | \n \n 5,705.0 ns \n | \n \n 31.53 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ImmutableListAny \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 45,118.5 ns \n | \n \n 168.72 ns \n | \n \n 72 B \n | \n
| \n ImmutableListExists \n | \n \n .NET Framework 4.8.1 \n | \n \n ImmutableList<T> \n | \n \n 41,966.0 ns \n | \n \n 631.59 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 1,643.5 ns \n | \n \n 13.09 ns \n | \n \n 40 B \n | \n
| \n ListExists \n | \n \n .NET 8.0 \n | \n \n List<T> \n | \n \n 726.2 ns \n | \n \n 11.99 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 398.6 ns \n | \n \n 8.20 ns \n | \n \n - \n | \n
| \n ListExists \n | \n \n .NET 9.0 \n | \n \n List<T> \n | \n \n 612.4 ns \n | \n \n 18.73 ns \n | \n \n - \n | \n
| \n | \n | \n | \n | \n | \n |
| \n ListAny \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 5,621.5 ns \n | \n \n 35.80 ns \n | \n \n 40 B \n | \n
| \n ListExists \n | \n \n .NET Framework 4.8.1 \n | \n \n List<T> \n | \n \n 1,748.0 ns \n | \n \n 11.76 ns \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n// Explicitly cache the delegates to avoid allocations inside the benchmark.\nprivate readonly static Func<int, bool> ConditionFunc = static x => x == -1 * Math.Abs(x);\nprivate readonly static Predicate<int> ConditionPredicate = static x => x == -1 * Math.Abs(x);\n\nprivate List<int> list;\nprivate ImmutableList<int> immutableList;\nprivate int[] array;\n\n[Params(1_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void GlobalSetup()\n{\n list = Enumerable.Range(0, N).Select(x => N - x).ToList();\n immutableList = ImmutableList.CreateRange(list);\n array = list.ToArray();\n}\n\n[BenchmarkCategory(\"List<T>\"), Benchmark]\npublic bool ListAny() =>\n list.Any(ConditionFunc);\n\n[BenchmarkCategory(\"List<T>\"), Benchmark(Baseline = true)]\npublic bool ListExists() =>\n list.Exists(ConditionPredicate);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark(Baseline = true)]\npublic bool ImmutableListAny() =>\n immutableList.Any(ConditionFunc);\n\n[BenchmarkCategory(\"ImmutableList<T>\"), Benchmark]\npublic bool ImmutableListExists() =>\n immutableList.Exists(ConditionPredicate);\n\n[BenchmarkCategory(\"Array\"), Benchmark(Baseline = true)]\npublic bool ArrayAny() =>\n array.Any(ConditionFunc);\n\n[BenchmarkCategory(\"Array\"), Benchmark]\npublic bool ArrayExists() =>\n Array.Exists(array, ConditionPredicate);\n\nHardware configuration:
\n\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n .NET 8.0 : .NET 8.0.10 (8.0.1024.46610), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET 9.0 : .NET 9.0.0 (9.0.24.47305), X64 RyuJIT AVX-512F+CD+BW+DQ+VL+VBMI\n .NET Framework 4.8.1 : .NET Framework 4.8.1 (4.8.9277.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6605.json", "content": "{\n \"title\": \"Collection-specific \\\"Exists\\\" method should be used instead of the \\\"Any\\\" extension\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6605\",\n \"sqKey\": \"S6605\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6607.html", "content": "
When working with LINQ in C#, it is recommended to pay attention to the order in which methods are chained, especially when using\nWhere and OrderBy methods. It is advised to call the Where method before OrderBy because\nWhere filters the elements of the sequence based on a given condition and returns a new sequence containing only the elements that\nsatisfy that condition. Calling OrderBy before Where, may end up sorting elements that will be later discarded, which can\nlead to inefficiency. Conversely, calling Where before OrderBy, will first filter the sequence to include only the elements\nof interest, and then sort them based on the specified order.
We measured at least 2x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
The issue can be fixed by calling Where before OrderBy.
\nPublic Function GetSortedFilteredList(data As IEnumerable(Of Integer)) As IEnumerable(Of Integer)\n Return data.OrderBy(Function(x) x).Where(Function(x) x Mod 2 = 0)\nEnd Function\n\n
\nPublic Function GetSortedFilteredList(data As IEnumerable(Of Integer)) As IEnumerable(Of Integer)\n Return data.Where(Function(x) x Mod 2 = 0).OrderBy(Function(x) x)\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n OrderByThenWhere \n | \n \n .NET 7.0 \n | \n \n 175.36 ms \n | \n \n 5.101 ms \n | \n
| \n WhereThenOrderBy \n | \n \n .NET 7.0 \n | \n \n 85.58 ms \n | \n \n 1.697 ms \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate IList<int> data;\nprivate static readonly Random Random = new Random();\n\n[Params(1_000_000)]\npublic int NumberOfEntries;\n\n[GlobalSetup]\npublic void Setup() =>\n data = Enumerable.Range(0, NumberOfEntries).Select(x => Random.Next(0, NumberOfEntries)).ToList();\n\n[Benchmark(Baseline = true)]\npublic void OrderByThenWhere() =>\n _ = data.OrderBy(x => x).Where(x => x % 2 == 0 ).ToList(); // OrderBy followed by Where\n\n[Benchmark]\npublic void WhereThenOrderBy() =>\n _ = data.Where(x => x % 2 == 0 ).OrderBy(x => x).ToList(); // Where followed by OrderBy\n\n
Hardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n12th Gen Intel Core i7-12800H, 1 CPU, 20 logical and 14 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6607.json", "content": "{\n \"title\": \"The collection should be filtered before sorting by using \\\"Where\\\" before \\\"OrderBy\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6607\",\n \"sqKey\": \"S6607\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6608.html", "content": "
Indexes in C# provide direct access to an element at a specific position within an array or collection. When compared to Enumerable\nmethods, indexing can be more efficient for certain scenarios, such as iterating over a large collection, due to avoiding the overhead of checking the\nunderlying collection type before accessing it.
This applies to types that implement one of these interfaces:
\nWe measured a significant improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
If the type you are using implements IList, IList<T> or IReadonlyList<T>, it implements\nthis[int index]. This means calls to First, Last, or ElementAt(index) can be replaced with\nindexing at 0, Count-1 and index respectively.
\nFunction GetAt(data As List(Of Integer), index As Integer) As Integer\n Return data.ElementAt(index)\nEnd Function\n\n
\nFunction GetFirst(data As List(Of Integer)) As Integer\n Return data.First()\nEnd Function\n\n
\nFunction GetLast(data As List(Of Integer)) As Integer\n Return data.Last()\nEnd Function\n\n
\nFunction GetAt(data As List(Of Integer), index As Integer) As Integer\n Return data(index)\nEnd Function\n\n
\nFunction GetFirst(data As List(Of Integer)) As Integer\n Return data(0)\nEnd Function\n\n
\nFunction GetLast(data As List(Of Integer)) As Integer\n Return data(data.Count-1)\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \n
|---|---|---|---|
| \n ElementAt \n | \n \n 3,403.4 ns \n | \n \n 28.52 ns \n | \n \n 26.67 ns \n | \n
| \n Index \n | \n \n 478.0 ns \n | \n \n 6.93 ns \n | \n \n 6.48 ns \n | \n
| \n First \n | \n \n 6,160.0 ns \n | \n \n 57.66 ns \n | \n \n 53.93 ns \n | \n
| \n First_Index \n | \n \n 485.7 ns \n | \n \n 5.81 ns \n | \n \n 5.15 ns \n | \n
| \n Last \n | \n \n 6,034.3 ns \n | \n \n 20.34 ns \n | \n \n 16.98 ns \n | \n
| \n Last_Index \n | \n \n 408.3 ns \n | \n \n 2.54 ns \n | \n \n 2.38 ns \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate List<byte> data;\nprivate Random random;\n\n[Params(1_000_000)]\npublic int SampleSize;\n\n[Params(1_000)]\npublic int LoopSize;\n\n[GlobalSetup]\npublic void Setup()\n{\n random = new Random(42);\n\n var bytes = new byte[SampleSize];\n random.NextBytes(bytes);\n data = bytes.ToList();\n}\n\n[Benchmark]\npublic int ElementAt()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.ElementAt(i);\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[i];\n }\n\n return result;\n}\n\n[Benchmark]\npublic int First()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.First();\n }\n\n return result;\n}\n\n[Benchmark]\npublic int First_Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[0];\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Last()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data.Last();\n }\n\n return result;\n}\n\n[Benchmark]\npublic int Last_Index()\n{\n int result = default;\n\n for (var i = 0; i < LoopSize; i++)\n {\n result = data[data.Count - 1];\n }\n\n return result;\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.4412/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=8.0.301\n [Host] : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2\n .NET 8.0 : .NET 8.0.6 (8.0.624.26715), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6608.json", "content": "{\n \"title\": \"Prefer indexing instead of \\\"Enumerable\\\" methods on types implementing \\\"IList\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6608\",\n \"sqKey\": \"S6608\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6609.html", "content": "
Both the Enumerable.Max extension method and the SortedSet<T>.Max property can be used to find the maximum value in\na SortedSet<T>. However, SortedSet<T>.Max is much faster than Enumerable.Max. For small\ncollections, the performance difference may be minor, but for large collections, it can be noticeable. The same applies for the Min\nproperty as well.
Max and Min in SortedSet<T> exploit the fact that the set is implemented via a Red-Black\ntree. The algorithm to find the Max/Min is \"go left/right whenever possible\". The operation has the time complexity\nof O(h) which becomes O(ln(n)) due to the fact that the tree is balanced. This is much better than the O(n)\ntime complexity of extension methods.
Max and Min in ImmutableSortedSet<T> exploits a tree augmentation technique, storing the\nMin, Max and Count values on each node of the data structure. The time complexity in this case is\nO(1) that is significantly better than O(n) of extension methods.
Applies to:
\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
The Min and Max properties are defined on the following classes, and the extension method call can be replaced by calling\nthe propery instead:
SortedSet<T>ImmutableSortedSet<T>ImmutableSortedSet<T>.Builder\nFunction GetMax(data As SortedSet(Of Integer)) As Integer\n Return Enumerable.Max(data)\nEnd Function\n\n
\nFunction GetMin(data As SortedSet(Of Integer)) As Integer\n Return Enumerable.Min(data)\nEnd Function\n\n
\nFunction GetMax(data As SortedSet(Of Integer)) As Integer\n Return data.Max()\nEnd Function\n\n
\nFunction GetMin(data As SortedSet(Of Integer)) As Integer\n Return data.Min()\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n MaxMethod \n | \n \n .NET 7.0 \n | \n \n 68,961.483 us \n | \n \n 499.6623 us \n | \n \n 248063 B \n | \n
| \n MaxProperty \n | \n \n .NET 7.0 \n | \n \n 4.638 us \n | \n \n 0.0634 us \n | \n \n - \n | \n
| \n MaxMethod \n | \n \n .NET Framework 4.6.2 \n | \n \n 85,827.359 us \n | \n \n 1,531.1611 us \n | \n \n 281259 B \n | \n
| \n MaxProperty \n | \n \n .NET Framework 4.6.2 \n | \n \n 67.682 us \n | \n \n 0.3757 us \n | \n \n 312919 B \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate SortedSet<string> data;\n\n[Params(1_000)]\npublic int Iterations;\n\n[GlobalSetup]\npublic void Setup() =>\n data = new SortedSet<string>(Enumerable.Range(0, Iterations).Select(x => Guid.NewGuid().ToString()));\n\n[Benchmark(Baseline = true)]\npublic void MaxMethod()\n{\n for (var i = 0; i < Iterations; i++)\n {\n _ = data.Max(); // Max() extension method\n }\n}\n\n[Benchmark]\npublic void MaxProperty()\n{\n for (var i = 0; i < Iterations; i++)\n {\n _ = data.Max; // Max property\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6609.json", "content": "{\n \"title\": \"\\\"Min\\/Max\\\" properties of \\\"Set\\\" types should be used instead of the \\\"Enumerable\\\" extension methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6609\",\n \"sqKey\": \"S6609\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6610.html", "content": "
With string.StartsWith(char) and string.EndsWith(char), only the first character of the string is compared to the\nprovided character, whereas the string versions of those methods have to do checks about the current StringComparison and\nCultureInfo. Thus, the char overloads are significantly faster for default comparison scenarios.
These overloads were introduced in .NET Core 2.0.
We measured at least 3.5x improvement in execution time. For more details see the Benchmarks section from the More info\ntab.
If you are targeting a runtime version equal or greater than .NET Core 2.0, the string.StartsWith and\nstring.EndsWith overloads are available, with the argument’s type being char instead of string. Thus, an\nargument of char type can be provided.
\nFunction StartsWithSlash(s As String) As Boolean\n Return s.StartsWith(\"/\")\nEnd Function\n\n
\nFunction EndsWithSlash(s As String) As Boolean\n Return s.EndsWith(\"/\")\nEnd Function\n\n
\nFunction StartsWithSlash(s As String) As Boolean\n Return s.StartsWith(\"/\"c)\nEnd Function\n\n
\nFunction EndsWithSlash(s As String) As Boolean\n Return s.EndsWith(\"/\"c)\nEnd Function\n\n
| Method | \nMean | \nStandard Deviation | \n
|---|---|---|
| \n StartsWith_String \n | \n \n 30.965 ms \n | \n \n 3.2732 ms \n | \n
| \n StartsWith_Char \n | \n \n 7.568 ms \n | \n \n 0.3235 ms \n | \n
| \n EndsWith_String \n | \n \n 30.421 ms \n | \n \n 5.1136 ms \n | \n
| \n EndsWith_Char \n | \n \n 8.067 ms \n | \n \n 0.7092 ms \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate List<string> data;\n\n[Params(1_000_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void Setup() =>\n data = Enumerable.Range(0, N).Select(_ => Guid.NewGuid().ToString()).ToList();\n\n[Benchmark]\npublic void StartsWith_String()\n{\n _ = data.Where(guid => guid.StartsWith(\"d\")).ToList();\n}\n\n[Benchmark]\npublic void StartsWith_Char()\n{\n _ = data.Where(guid => guid.StartsWith('d')).ToList();\n}\n\n[Benchmark]\npublic void EndsWith_String()\n{\n _ = data.Where(guid => guid.EndsWith(\"d\")).ToList();\n}\n\n[Benchmark]\npublic void EndsWith_Char()\n{\n _ = data.Where(guid => guid.EndsWith('d')).ToList();\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6610.json", "content": "{\n \"title\": \"\\\"StartsWith\\\" and \\\"EndsWith\\\" overloads that take a \\\"char\\\" should be used instead of the ones that take a \\\"string\\\"\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6610\",\n \"sqKey\": \"S6610\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6612.html", "content": "
When using the ConcurrentDictionary, there are many overloads of the GetOrAdd and AddOrUpdate methods that\ntake both a TKey argument and a lambda that expects a TKey parameter. This means that the right side of the lambda can be\nwritten using either the lambda’s parameter or the method’s argument. However, using the method’s argument leads to the lambda capturing it, and the\ncompiler will need to generate a class and instantiate it before the call. This means memory allocations, as well as more time spend during Garbage\nCollection.
We measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
When you are using the ConcurrentDictionary methods GetOrAdd or AddOrUpdate, reference the key by using the\nlambda’s parameter instead of the method’s one.
\nFunction UpdateValue(dict As ConcurrentDictionary(Of Integer, Integer), key As Integer) As Integer\n Return dict.GetOrAdd(key, Function(k)\n Return key + 42\n End Function)\nEnd Function\n\n
\nFunction UpdateValue(dict As ConcurrentDictionary(Of Integer, Integer), key As Integer) As Integer\n Return dict.GetOrAdd(key, Function(k)\n Return k + 42\n End Function)\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n Capture \n | \n \n .NET 7.0 \n | \n \n 68.52 ms \n | \n \n 4.450 ms \n | \n \n 88000063 B \n | \n
| \n Lambda \n | \n \n .NET 7.0 \n | \n \n 39.29 ms \n | \n \n 3.712 ms \n | \n \n 50 B \n | \n
| \n Capture \n | \n \n .NET Framework 4.6.2 \n | \n \n 74.58 ms \n | \n \n 5.199 ms \n | \n \n 88259787 B \n | \n
| \n Lambda \n | \n \n .NET Framework 4.6.2 \n | \n \n 42.03 ms \n | \n \n 2.752 ms \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate ConcurrentDictionary<int, string> dict;\nprivate List<int> data;\n\n[Params(1_000_000)]\npublic int N { get; set; }\n\n[GlobalSetup]\npublic void Setup()\n{\n dict = new ConcurrentDictionary<int, string>();\n data = Enumerable.Range(0, N).OrderBy(_ => Guid.NewGuid()).ToList();\n}\n\n[Benchmark(baseline=true)]\npublic void Capture()\n{\n foreach (var guid in data)\n {\n dict.GetOrAdd(guid, _ => $\"{guid}\"); // \"guid\" is captured\n }\n}\n\n[Benchmark]\npublic void Lambda()\n{\n foreach (var guid in data)\n {\n dict.GetOrAdd(guid, x => $\"{x}\"); // no capture\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8.1 (4.8.9139.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6612.json", "content": "{\n \"title\": \"The lambda parameter should be used instead of capturing arguments in \\\"ConcurrentDictionary\\\" methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6612\",\n \"sqKey\": \"S6612\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6613.html", "content": "
Both the Enumerable.First extension method and the LinkedList<T>.First property can be used to find the first value\nin a LinkedList<T>. However, LinkedList<T>.First is much faster than Enumerable.First. For small\ncollections, the performance difference may be minor, but for large collections, it can be noticeable. The same applies for the Last\nproperty as well.
Applies to:
\n\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
The First and Last properties are defined on the LinkedList class, and the extension method call can be\nreplaced by calling the propery instead.
\nFunction GetFirst(data As LinkedList(Of Integer)) As Integer\n Return Enumerable.First(data)\nEnd Function\n\n
\nFunction GetLast(data As LinkedList(Of Integer)) As Integer\n Return Enumerable.Last(data)\nEnd Function\n\n
\nFunction GetFirst(data As LinkedList(Of Integer)) As Integer\n Return data.First.Value\nEnd Function\n\n
\nFunction GetLast(data As LinkedList(Of Integer)) As Integer\n Return data.Last.Value\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n LastMethod \n | \n \n .NET 7.0 \n | \n \n 919,577,629.0 ns \n | \n \n 44,299,688.61 ns \n | \n \n 48504 B \n | \n
| \n LastProperty \n | \n \n .NET 7.0 \n | \n \n 271.8 ns \n | \n \n 15.63 ns \n | \n \n - \n | \n
| \n LastMethod \n | \n \n .NET Framework 4.6.2 \n | \n \n 810,316,427.1 ns \n | \n \n 47,768,482.31 ns \n | \n \n 57344 B \n | \n
| \n LastProperty \n | \n \n .NET Framework 4.6.2 \n | \n \n 372.0 ns \n | \n \n 13.38 ns \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\nprivate LinkedList<int> data;\nprivate Random random = new Random();\n\n[Params(100_000)]\npublic int Size { get; set; }\n\n[Params(1_000)]\npublic int Runs { get; set; }\n\n[GlobalSetup]\npublic void Setup() =>\n data = new LinkedList<int>(Enumerable.Range(0, Size).Select(x => random.Next()));\n\n[Benchmark(Baseline = true)]\npublic void LastMethod()\n{\n for (var i = 0; i < Runs; i++)\n {\n _ = data.Last(); // Enumerable.Last()\n }\n}\n\n[Benchmark]\npublic void LastProperty()\n{\n for (var i = 0; i < Runs; i++)\n {\n _ = data.Last; // Last property\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n [Host] : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8 (4.8.4614.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6613.json", "content": "{\n \"title\": \"\\\"First\\\" and \\\"Last\\\" properties of \\\"LinkedList\\\" should be used instead of the \\\"First()\\\" and \\\"Last()\\\" extension methods\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6613\",\n \"sqKey\": \"S6613\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6617.html", "content": "
When testing if a collection contains a specific item by simple equality, both ICollection.Contains(T item) and\nIEnumerable.Any(x ⇒ x == item) can be used. However, Any searches the data structure in a linear manner using a foreach\nloop, whereas Contains is considerably faster in some collection types, because of the underlying implementation. More specifically:
HashSet<T> is a hashtable, and therefore has an O(1) lookupSortedSet<T> is a red-black tree, and therefore has a O(logN) lookupList<T> is a linear search, and therefore has an O(N) lookup, but the EqualityComparer is optimized for the T\n type, which is not the case for AnyFor small collections, the performance difference may be negligible, but for large collections, it can be noticeable.
\nWe measured a significant improvement both in execution time and memory allocation. For more details see the Benchmarks section from\nthe More info tab.
Since LINQ to\nEntities relies a lot on System.Linq for
Contains is a method defined on the ICollection<T> interface and takes a T item argument.\nAny is an extension method defined on the IEnumerable<T> interface and takes a predicate argument. Therefore, calls\nwith simple equality checks like Any(x ⇒ x == item) can be replaced by Contains(item).
This applies to the following collection types:
\n\nFunction ValueExists(data As HashSet(Of Integer)) As Boolean\n Return data.Any(Function(x) x = 42)\nEnd Function\n\n
\nFunction ValueExists(data As List(Of Integer)) As Boolean\n Return data.Any(Function(x) x = 42)\nEnd Function\n\n
\nFunction ValueExists(data As HashSet(Of Integer)) As Boolean\n Return data.Contains(42)\nEnd Function\n\n
\nFunction ValueExists(data As List(Of Integer)) As Boolean\n Return data.Contains(42)\nEnd Function\n\n
| Method | \nRuntime | \nMean | \nStandard Deviation | \nAllocated | \n
|---|---|---|---|---|
| \n HashSet_Any \n | \n \n .NET 7.0 \n | \n \n 35,388.333 us \n | \n \n 620.1863 us \n | \n \n 40132 B \n | \n
| \n HashSet_Contains \n | \n \n .NET 7.0 \n | \n \n 3.799 us \n | \n \n 0.1489 us \n | \n \n - \n | \n
| \n List_Any \n | \n \n .NET 7.0 \n | \n \n 32,851.509 us \n | \n \n 667.1658 us \n | \n \n 40130 B \n | \n
| \n List_Contains \n | \n \n .NET 7.0 \n | \n \n 375.132 us \n | \n \n 8.0764 us \n | \n \n - \n | \n
| \n HashSet_Any \n | \n \n .NET Framework 4.6.2 \n | \n \n 28,979.763 us \n | \n \n 678.0093 us \n | \n \n 40448 B \n | \n
| \n HashSet_Contains \n | \n \n .NET Framework 4.6.2 \n | \n \n 5.987 us \n | \n \n 0.1090 us \n | \n \n - \n | \n
| \n List_Any \n | \n \n .NET Framework 4.6.2 \n | \n \n 25,830.221 us \n | \n \n 487.2470 us \n | \n \n 40448 B \n | \n
| \n List_Contains \n | \n \n .NET Framework 4.6.2 \n | \n \n 5,935.812 us \n | \n \n 57.7569 us \n | \n \n - \n | \n
The results were generated by running the following snippet with BenchmarkDotNet:
\n\n[Params(10_000)]\npublic int SampleSize;\n\n[Params(1_000)]\npublic int Iterations;\n\nprivate static HashSet<int> hashSet;\nprivate static List<int> list;\n\n[GlobalSetup]\npublic void Setup()\n{\n hashSet = new HashSet<int>(Enumerable.Range(0, SampleSize));\n list = Enumerable.Range(0, SampleSize).ToList();\n}\n\n[Benchmark]\npublic void HashSet_Any() =>\n CheckAny(hashSet, SampleSize / 2);\n\n[Benchmark]\npublic void HashSet_Contains() =>\n CheckContains(hashSet, SampleSize / 2);\n\n[Benchmark]\npublic void List_Any() =>\n CheckAny(list, SampleSize / 2);\n\n[Benchmark]\npublic void List_Contains() =>\n CheckContains(list, SampleSize / 2);\n\nvoid CheckAny(IEnumerable<int> values, int target)\n{\n for (int i = 0; i < Iterations; i++)\n {\n _ = values.Any(x => x == target); // Enumerable.Any\n }\n}\n\nvoid CheckContains(ICollection<int> values, int target)\n{\n for (int i = 0; i < Iterations; i++)\n {\n _ = values.Contains(target); // ICollection<T>.Contains\n }\n}\n\nHardware configuration:
\n\nBenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19045.2846/22H2/2022Update)\n11th Gen Intel Core i7-11850H 2.50GHz, 1 CPU, 16 logical and 8 physical cores\n.NET SDK=7.0.203\n [Host] : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET 7.0 : .NET 7.0.5 (7.0.523.17405), X64 RyuJIT AVX2\n .NET Framework 4.6.2 : .NET Framework 4.8.1 (4.8.9139.0), X64 RyuJIT VectorSize=256\n\n\n" }, { "path": "analyzers/rspec/vbnet/S6617.json", "content": "{\n \"title\": \"\\\"Contains\\\" should be used instead of \\\"Any\\\" for simple equality checks\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"LOW\"\n },\n \"attribute\": \"EFFICIENT\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"5min\"\n },\n \"tags\": [\n \"performance\"\n ],\n \"defaultSeverity\": \"Minor\",\n \"ruleSpecification\": \"RSPEC-6617\",\n \"sqKey\": \"S6617\",\n \"scope\": \"All\",\n \"quickfix\": \"targeted\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S6930.html", "content": "
Backslash characters (\\) should be avoided in
Routing in ASP.NET MVC maps
In the former syntax specification of URIs, backslash characters (\\) were not allowed at all (see
For instance, a backslash in the \"path\" part of a /) both by Chrome and Internet\nExplorer (see here).
As an example, \\Calculator\\Evaluate?expression=3\\4 is converted on the fly into /Calculator/Evaluate?expression=3\\4\nbefore the HTTP request is made to the server.
While backslashes are allowed in the \"query\" part of a URL, and it’s common to have them as part of a complex query expression, the route of a\ncontroller is always part of the \"path\".
\nThat is why the use of backslashes in controller templates should be avoided in general.
\nA backslash in the route pattern of a controller would only make sense if the developer intended the backslash in the route to be explicitly\nescaped by the user, using %5C.
For example, the route Something\\[controller] for the HomeController would need to be called as\nSomething%5CHome.
The validity of such a scenario is unlikely and the resulting behavior is surprising.
\n\n<Route(\"Something\\[controller]\")> ' Noncompliant: Replace '\\' with '/'.\nPublic Class HomeController\n Inherits Controller\n\n <HttpGet>\n Public Function Index() As ActionResult\n Return View()\n End Function\nEnd Class\n\n
\n<Route(\"Something/[controller]\")> ' '\\' replaced with '/'\nPublic Class HomeController\n Inherits Controller\n\n <HttpGet>\n Public Function Index() As ActionResult\n Return View()\n End Function\nEnd Class\n\n
\napp.MapControllerRoute(\n name:=\"default\",\n pattern:=\"{controller=Home}\\{action=Index}\") ' Noncompliant: Replace '\\' with '/'.\n\n\napp.MapControllerRoute(\n name:=\"default\",\n pattern:=\"{controller=Home}/{action=Index}\") ' '\\' replaced with '/'\n\nRoute templates for ASP.NET controller\nactions, defined via a RouteAttribute or any derivation of HttpMethodAttribute, should\nnot start with \"/\".
Routing in ASP.NET Core MVC maps
In ASP.NET Core MVC, when an action defines a route template starting with a \"/\", the route is considered absolute and the action is registered at\nthe root of the web application.
\nIn such a scenario, any route defined at the controller level is disregarded, as shown in the following example:
\n\n<Route(\"[controller]\")> ' This route is ignored for the routing of Index1 and Index2\nPublic Class HomeController\n Inherits Controller\n\n <HttpGet(\"/Index1\")> ' This action is mapped to the root of the web application\n Public Function Index1() As ActionResult\n Return View()\n End Function\n\n <Route(\"/Index2\")> ' The same applies here\n Public Function Index2() As ActionResult\n Return View()\n End Function\nEnd Class\n\n
The behavior can be found confusing and surprising because any relative action route is relativized to the controller route.
\nTherefore, in the vast majority of scenarios, controllers group all related actions not only in the source code, but also at the routing level.
\nIn ASP.NET Framework MVC with attribute routing enabled via MapMvcAttributeRoutes,\nthe mere presence of an absolute route at the action level will produce an InvalidOperationException at runtime.
It is then a good practice to avoid absolute routing at the action level and move the \"/\" to the root level, changing the template defined in the\nRouteAttribute of the controller appropriately.
The rule only applies when all route templates of all actions of the controller start with \"/\". Sometimes some actions may have both relative and\nabsolute route templates, for example for backward compatibility reasons (i.e. a former route needs to be preserved). In such scenarios, it may make\nsense to keep the absolute route template at the action level.
\n\n<Route(\"[controller]\")> ' This route is ignored\nPublic Class ReviewsController\n Inherits Controller\n\n ' Route is /reviews\n <HttpGet(\"/reviews\")>\n Public Function Index() As ActionResult\n ' ...\n End Function\n\n ' Route is /reviews/{reviewId}\n <Route(\"/reviews/{reviewId}\")>\n Public Function Show(reviewId As Integer) As ActionResult\n ' ...\n End Function\nEnd Class\n\n\n<Route(\"/\")> ' Turns on attribute routing\nPublic Class ReviewsController\n Inherits Controller\n\n ' Route is /reviews\n <HttpGet(\"reviews\")>\n Public Function Index() As ActionResult\n ' ...\n End Function\n\n ' Route is /reviews/{reviewId}\n <Route(\"reviews/{reviewId}\")>\n Public Function Show(reviewId As Integer) As ActionResult\n ' ...\n End Function\nEnd Class\n\nWhen working with collections that are known to be non-empty, using
Using FirstOrDefault or SingleOrDefault on collections that are known to be non-empty is an issue due to:
FirstOrDefault or SingleOrDefault, it implies that the collection might be\n empty, which can be misleading if you know it is not. It can be confusing for other developers who read your code, making it harder for them to\n understand the actual constraints and behavior of the collection. This leads to confusion and harder-to-maintain code.FirstOrDefault and\n SingleOrDefault can lead to subtle bugs. These methods return a default value (null for reference types and\n default for value types) when the collection is empty, potentially causing issues like NullReferenceException later in the\n code. In contrast, First or Single will throw an InvalidOperationException immediately if the collection is\n empty, making it easier to detect and address issues early in the development process.null, you introduces a condition that cannot be fully tested,\n impacting the code coverage.\nDim Items As New list(Of Integer) From {1, 2, 3}\n\nDim FirstItem As Integer = Items.FirstOrDefault() ' Noncompliant, this implies the collection might be empty, when we know it is not\n\n\nDim Items As New list(Of Integer) From {1, 2, 3}\n\nDim FirstItem As Integer = Items.First() ' Compliant\n\nSingleFirstSingleOrDefaultFirstOrDefaultWhen using ReaderWriterLock and
This rule raises if:
\nIf you use the ReaderWriterLockSlim class, you will get a ReaderWriterLock, you’ll get a runtime exception for trying to release a lock that is not owned by the calling thread.
\nPublic Class Example\n\n Private Shared rwLock As New ReaderWriterLock()\n\n Public Sub Writer()\n rwLock.AcquireWriterLock(2000)\n Try\n ' ...\n Finally\n rwLock.ReleaseReaderLock() ' Noncompliant, will throw runtime exception\n End Try\n End Sub\n\n Public Sub Reader()\n rwLock.AcquireReaderLock(2000)\n Try\n ' ...\n Finally\n rwLock.ReleaseWriterLock() ' Noncompliant, will throw runtime exception\n End Try\n End Sub\n\nEnd Class\n\n
\nPublic Class Example\n\n Private Shared rwLock As New ReaderWriterLock()\n\n Public Shared Sub Writer()\n rwLock.AcquireWriterLock(2000)\n Try\n ' ...\n Finally\n rwLock.ReleaseWriterLock()\n End Try\n End Sub\n\n Public Shared Sub Reader()\n rwLock.AcquireReaderLock(2000)\n Try\n ' ...\n Finally\n rwLock.ReleaseReaderLock()\n End Try\n End Sub\n\nEnd Class\n\n
This rule raises if you acquire a lock with one of the following methods, and do not release it within the same method.
\nThis rule will raise an issue when the code uses the
Not releasing a lock in the same method where you acquire it, and releasing in another one, makes the code less clear and harder to maintain. You\nare also introducing the risk of not releasing a lock at all which can lead to deadlocks or exceptions.
\n\nPublic Class Example\n\n Private Shared rwLock As New ReaderWriterLock\n\n Public Sub AcquireWriterLock()\n rwLock.AcquireWriterLock(2000) ' Noncompliant, as the lock release is on the callers responsibility\n End Sub\n\n Public Sub DoSomething()\n ' ...\n End Sub\n\n Public Sub ReleaseWriterLock()\n rwLock.ReleaseWriterLock()\n End Sub\n\nEnd Class\n\n
\nPublic Class Example\n\n Private Shared rwLock As New ReaderWriterLock\n\n Public Sub DoSomething()\n rwLock.AcquireWriterLock(2000) ' Compliant, locks are released in the same method\n Try\n ' ...\n Finally\n rwLock.ReleaseWriterLock()\n End Try\n End Sub\n\nEnd Class\n\n
GoTo is an unstructured control flow statement. It makes code less readable and maintainable. Structured control flow statements such\nas If, For, While, or Exit should be used instead.
\n Sub GoToStatementDemo()\n Dim number As Integer = 1\n Dim sampleString As String\n ' Evaluate number and branch to appropriate label.\n If number = 1 Then GoTo Line1 Else GoTo Line2\nLine1:\n sampleString = \"Number equals 1\"\n GoTo LastLine\nLine2:\n ' The following statement never gets executed because number = 1.\n sampleString = \"Number equals 2\"\nLastLine:\n ' Write \"Number equals 1\" in the Debug window.\n Debug.WriteLine(sampleString)\n End Sub\n\n
\n Sub GoToStatementDemo()\n Dim number As Integer = 1\n Dim sampleString As String\n ' Evaluate number and branch to appropriate label.\n If number = 1 Then\n sampleString = \"Number equals 1\"\n Else\n sampleString = \"Number equals 2\"\n End If\n Debug.WriteLine(sampleString)\n End Sub\n\n\n" }, { "path": "analyzers/rspec/vbnet/S907.json", "content": "{\n \"title\": \"\\\"GoTo\\\" statements should not be used\",\n \"type\": \"CODE_SMELL\",\n \"code\": {\n \"impacts\": {\n \"MAINTAINABILITY\": \"MEDIUM\"\n },\n \"attribute\": \"CLEAR\"\n },\n \"status\": \"ready\",\n \"remediation\": {\n \"func\": \"Constant\\/Issue\",\n \"constantCost\": \"10min\"\n },\n \"tags\": [\n \"brain-overload\"\n ],\n \"defaultSeverity\": \"Major\",\n \"ruleSpecification\": \"RSPEC-907\",\n \"sqKey\": \"S907\",\n \"scope\": \"All\",\n \"quickfix\": \"unknown\"\n}\n" }, { "path": "analyzers/rspec/vbnet/S927.html", "content": "
Parameters are part of the method signature and its identity.
\nImplementing a method from an interface, a base class, or a partial method and changing one of its parameters' names will confuse and impact the\nmethod’s readability.
\n\nInterface IBankAccount\n Sub AddMoney(money As Integer)\nEnd Interface\n\nClass BankAccount\n Implements IBankAccount\n\n Private Sub AddMoney(amount As Integer) ' Noncompliant: parameter's name differs from base\n ' ...\n End Sub\nEnd Class\n\n
To avoid any ambiguity in the code, a parameter’s name should match the initial declaration, whether its initial declaration is from an interface,\na base class, or a partial method.
\n\nInterface IBankAccount\n Sub AddMoney(money As Integer)\nEnd Interface\n\nClass BankAccount\n Implements IBankAccount\n\n Private Sub AddMoney(money As Integer) ' Compliant: parameter's name match base name\n ' ...\n End Sub\nEnd Class\n\n
The rule is ignored if both the parameter defined in the initial decalaration is a generic type and the implementing member’s declaration is a\nnon-generic type.
\nThis allows the implementing member to be more specific and provide more information.
\n