Code Issues

• It removes also the empty assingments and the usages
• Implements an abstract member as a virtual one
• Adds second accessor to a property.
• Removes redundant braces around a statement.
• Add name for argument including method, indexer invocation and Attibute Usage
• Adds an exception type specifier to general catch clauses.
• Add an exception description to the xml documentation
• Add one or more optional parameters to an invocation.
• Add missing using declaration.
• Converts a loop to a Linq expression
• Changes the access level of an entity declaration
• Computes the value of the current expression and replaces it.
• Converts an anonymous delegate into a lambda
• Convert assignment to 'if'
• Convert 'as' to cast.
• Replace bitwise flag comparison with call to 'Enum.HasFlag'
• Convert cast to 'as'.
• Convert dec to hex.
• Converts a do...while to a while loop (changing semantics).
• Converts '==' to call to 'object.Equals'
• Converts 'Equals' call to '=='
• Convert explicit implementation of an interface method to implicit implementation
• Works on 'foreach' loops that allow direct access to its elements.
• Works on 'for' loops.
• Replace 'Enum.HasFlag' call with bitwise flag comparison
• Convert hex to dec.
• Convert 'if' to '?:'
• Convert 'if' statement to '??' expression.
• Convert 'if' to 'return'
• Convert 'if' statement to 'switch' statement
• Convert implict implementation of an interface method to explicit implementation
• Converts expression of lambda body to statement
• Converts statement of lambda body to expression
• Converts a lambda to an anonymous delegate.
• Convert method group to anoymous method
• Convert method group to lambda expression
• Convert '*'/'/' to '<<'/'>>'
• Convert '??' to '?:'
• Convert 'return' to 'if'
• Convert '<<'/'>>' to '*'/'/'
• Convert 'switch' statement to 'if' statement
• Converts an object or collection initializer to explicit initializations.
• Converts a set of assignments and .Add() calls to an initializer.
• Convert while loop to do...while (changing semantics)
• Copies documented comments from base to overriding methods.
• Copies documented comments from interface to implementing methods.
• Creates a backing field for an auto property.
• Creates a changed event for an property.
• Creates a class declaration out of an object creation.
• Creates a constructor declaration out of an object creation.
• Create custom event implementation.
• Creates a delegate declaration out of an event declaration.
• Creates an enum value for a undefined enum value.
• Creates a standard OnXXX event method.
• Creates a field for a undefined variable.
• Creates an indexer declaration out of an indexer expression.
• Creates a local variable for a undefined variable.
• Creates a method declaration out of an invocation.
• Create overload without the selected parameter.
• Creates a property for a undefined variable.
• Found method without return type.
• Declare a local variable out of a selected expression.
• Converts the call into static method call syntax.
• Extract anonymous method to method of the containing type
• Extracts a field from a local variable declaration.
• Creates a new method out of selected text.
• Extracts a field from a local variable declaration.
• Swap 'Equals' target and argument
• Swaps left and right arguments.
• Generates a getter for a field.
• Generates a getter and setter for a field.
• Creates switch lables for enumerations.
• Implements abstract members from an abstract class.
• Creates an interface implementation.
• Creates an interface implementation.
• Creates a backing field for a not implemented property.
• Inlines a local variable.
• Inserts a signature to parameterless anonymous methods.
• Creates a constant for a non constant primitive expression.
• Creates a string.format call with the selection as parameter.
• Inverts an '?:' expression.
• Inverts an 'if ... else' expression.
• Inverts if and simplify branching
• Inverts a logical expression
• Iterates an IEnumerable with a foreach loop.
• Join local variable declaration and assignment.
• Join string literals.
• Convert LINQ query to fluent syntax
• Converts a LINQ query to the equivalent fluent syntax.
• Merge two nested 'if' statements.
• Moves a declaration to the parent scope.
• Negate an is expression.
• Negate a relational expression.
• put IDisposable inside 'using' construct
• Removes the backing store of a property and creates an auto property.
• Removes redundant braces around a statement.
• Removes a redundant exception type specifier from catch clauses.
• Removes a pre processor #region/#endregion directive.
• Replace assignment with postfix expression
• Replaces "" with string.Empty
• Replace operator assignment with assignment
• Replace postfix expression with assignment
• Replace assignment with operator assignment
• Reverse the direction of a for loop
• Inverts if and reduces branching
• Inverts if and reduces branching
• Sorts usings by their origin and then alphabetically.
• Splits local variable declaration and assignment.
• Split variable declaration with multiple variables into declarations with a single variable
• Splits an if statement into two nested if statements
• Splits string literal into two.
• Converts a 'is' into an 'as' and null check
• Converts local variable declaration to be explicit typed.
• Convert concatenation of strings and objects to string.Format()
• Converts local variable declaration to be implicit typed.
• Replace with call to OfType (extended cases)
• Parameter name differs in base declaration
• Finds potentially erroneous calls to Object.Equals.
• Type cast expression of incompatible type
• Check if a namespace corresponds to a file location
• This error occurs when trying to assign a value of an incompatible type.
• Since 'function' doesn't return void, a return keyword must be followed by an object expression
• Since 'function' returns void, a return keyword must not be followed by an object expression
• A case label value is duplicate.
• CS0169: Field is never used
• CS0618: Member is obsolete
• If two objects are equal then they must both have the same hash code
• A partial method must have a defining declaration that defines the signature (name, return type and parameters) of the method. The implementation or method body is optional.
• CS1729: Class does not contain a 0 argument constructor
• CS0184:Given expression is never of the provided type.
• Searches for missing interface implementations
• Static constructor should be parameterless
• Condition is always 'true' or always 'false'.
• Convert 'if' to '&&' expression
• Warns about using lock (this) or MethodImplOptions.Synchronized.
• Detects if fields & simple getters are used at the same time inside a class.
• Simplify negative relational expression
• Parameter is assigned but its value is never used.
• Value assigned to a variable or parameter is not used in all execution path.
• Description = ctx.TranslateString("Assignment is redundant");
• Description = ctx.TranslateString("Remove redundant assignment");
• Checks if static events are removed
• Removes 'private' modifiers that are not required.
• Code is unreachable.
• Validate Xml docs
• Access to closure variable from anonymous method when the variable is" +
• Access to closure variable from anonymous method when the variable is modified " +
• One method has the same body as other method
• Expression has some redundant items
• One Else-if was checked before so is not be true
• Finds parameters that can be demoted to a generic list.
• Highlights variables that can be declared in a nested scope.
• Bitwise operation on enum which has no [Flags] attribute
• Possible compare of value type with 'null'
• Comparison of floating point numbers with equality operator.
• '?:' expression has identical true and false branches.
• Delegate subtraction has unpredictable result
• Warns about calls to virtual member functions occuring in the constructor.
• 'for' loop control variable is never modified.
• Finds issues with format strings.
• Function does not reach its end or a 'return' statement by any of possible execution paths.
• Local variable has the same name as a member and hides it.
• Lowercase 'l' is often confused with '1'
• Member hides static member from outer class
• Method with optional parameter is hidden by overload
• Possible unassigned object created by 'new'
• Cannot resolve symbol in text argument
• Operator Is can be used instead of comparing object GetType() and instances of System.Type object.
• The value of an optional parameter in a method does not match the base method.
• Parameter has the same name as a member and hides it.
• Parameter name differs in partial method declaration
• Invocation of polymorphic field event leads to unpredictable result since invocation lists are not virtual
• Check if a readonly field is used as assignment target
• Possible multiple enumeration of IEnumerable
• Warns about static fields in generic types.
• [ThreadStatic] doesn't work with instance fields
• Warns about property or indexer setters and event adders or removers that do not use the value parameter.
• Checks for prohibited modifiers
• CS0183:Given expression is always of the provided type.
• Parameter has no matching param tag in the XML comment
• CS1717:Assignment made to same variable.
• Unassigned readonly field
• Name doesn't match the defined style for this entity.
• Non public methods are not found by NUnit.
• Anonymous method or lambda expression can be simplified to method group.
• Convert 'if' to '?:'
• Convert 'Nullable' to the short form 'T?'
• Convert property to auto property
• Convert to lambda with expression
• If all fields, properties and methods members are static, the class can be made static.
• Foreach loops are more efficient
• If an extension method is called as static method convert it to method syntax
• Use 'var' keyword when possible
• Suggests using the class declaring a static function when calling it.
• Base parameter has 'params' modifier, but missing in overrider
• Convert 'if-do-while' to 'while' statement
• Convert 'if' to '||' expression
• Convert local variable or field to constant
• ';' should be avoided. Use '{}' instead
• Convert field to readonly
• A member doesn't use 'this' object neither explicit nor implicit. It can be made static.
• Finds parameters that can be demoted to a base class.
• Possible mistaken call to 'object.GetType()'
• Constructor in abstract class should not be public
• Check for reference equality instead
• Replace with call to FirstOrDefault()
• Replace with call to LastOrDefault()
• Replace with call to OfType().Any()
• Replace with call to OfType().Count()
• Replace with call to OfType().First()
• Replace with call to OfType().FirstOrDefault()
• Replace with call to OfType
• Replace with call to OfType().Last()
• Replace with call to OfType().LastOrDefault()
• Replace with call to OfType().LongCount()
• Replace with call to OfType().Single()
• Replace with call to OfType().SingleOrDefault()
• Replace with call to OfType().Where()
• Replace with simple assignment
• Replace with single call to Any(...)
• Replace with single call to Average(...)
• Replace with single call to Count(...)
• Replace with single call to First(...)
• Replace with single call to FirstOrDefault(...)
• Replace with single call to Last(...)
• Replace with single call to LastOrDefault(...)
• Replace with single call to LongCount(...)
• Replace with single call to Max(...)
• Replace with single call to Min(...)
• Replace with single call to Single(...)
• Replace with single call to SingleOrDefault(...)
• Replace with single call to Sum(...)
• Uses shorter string.IsNullOrEmpty call instead of a longer condition.
• Conditional expression can be simplified
• Simplify LINQ expression
• Warns when a culture-aware 'Compare' call is used by default.
• Warns when a culture-aware 'string.CompareTo' call is used by default.
• Warns when a culture-aware 'EndsWith' call is used by default.
• Warns when a culture-aware 'IndexOf' call is used by default.
• Warns when a culture-aware 'LastIndexOf' call is used by default.
• Warns when a culture-aware 'StartsWith' call is used by default.
• Use array creation expression
• 'is' operator can be used
• Replace usages of 'Count()' with call to 'Any()'
• Use method IsInstanceOfType
• When initializing explicitly typed local variable or array type, array creation expression can be replaced with array initializer.
• Value of the expression can be determined at compile time
• Finds redundant null coalescing expressions such as expr ?? expr
• Double negation is meaningless.
• Empty statement is redundant
• true is redundant as for statement condition, thus can be safely ommited
• The name can be inferred from the initializer expression
• The parameter is optional with the same default value
• Finds calls to functions where optional parameters are used and the passed argument is the same as the default.
• Parentheses are redundant if attribute has no arguments.
• 'base.' is redundant and can safely be removed.
• Comparison of a boolean value with 'true' or 'false' constant.
• 'case' label is redundant.
• Type cast can be safely removed.
• Catch clause with a single 'throw' statement is redundant.
• Check for inequality before assignment is redundant if (x != value) x = value;
• Redundant comma in array initializer.
• Description = ctx.TranslateString("Redundant comma in object initializer");
• Description = ctx.TranslateString("Redundant comma in collection initializer");
• Description = ctx.TranslateString("Redundant comma in array initializer");
• When 'is' keyword is used, which implicitly check null.
• Explicit delegate creation expression is redundant
• Redundant empty 'default' switch branch
• Redundant empty finally block
• When object creation uses object or collection initializer, empty argument list is redundant.
• Redundant 'IEnumerable.Cast' or 'IEnumerable.OfType' call
• Redundant explicit type in array creation
• Redundant explicit size in array creation
• Redundant 'else' keyword.
• Redundant empty object or collection initializer.
• Removes namespace usages that are obsolete.
• Redundant 'string.ToCharArray()' call
• Redundant conditional expression
• Description = ctx.TranslateString("'this.' is redundant and can be removed safely.");
• Description = ctx.TranslateString("Remove 'this.'");
• Finds value type calls to ToString() which would be generated automatically by the compiler.
• Finds calls to ToString() which would be generated automatically by the compiler.
• Unsafe modifier in redundant in unsafe context or when no unsafe constructs are used.
• Using directive is not required and can safely be removed.
• Remove redundant statement
• Detects when no delegate parameter is used in the anonymous method body.
• An empty public constructor without paramaters is redundant.
• Empty destructor is redundant
• Empty namespace declaration is redundant
• The default underlying type of enums is int, so defining it explicitly is redundant.
• Local variable is never used.
• Class is declared partial but has only one part
• This is generated by the compiler and can be safely removed.
• Initializing field with default value is redundant.
• The override of a virtual member is redundant because it consists of only a call to the base
• 'params' is ignored on overrides
• 'sealed' modifier is redundant in sealed classes
• Label is never referenced
• Parameter is never used.
• Type parameter is never used.
• Tail recursive calls should be avoided.
• Loop can be converted into LINQ expression
• Part of the loop body can be converted into LINQ expression
• Explicit specifiction is redundant because they are inferred from arguments
• Detects usage of old-style TaskCompletionSource/ContinueWith and suggests using async/await instead
• Duplicated call to ToList() or ToArray()
• Finds throws that throws the caught exception and therefore should be empty.
• Finds calls to Object.GetHashCode inside overridden GetHashCode.
• Blocks in if/else can be simplified to any of the branches if they have the same block.
• Detects unnecessary usages of the NotNullAttribute.
• Warns when the task returned by an async call is ignored, which causes exceptions" +
• A warning should be given for the case: if (condition) {…} else if (condition) {…}.
• Detects when a member of a null value is used