Cannot resolve property.
Cannot resolve resource.
Cannot resolve resource item.
Possibly unused #include directive.
Local variable used without being initialized.
A parameter is always rewritten in function body before being read.
Assigned value is never used.
Local variable is never used, but may have side-effects in its destructor.
A declarator is used only in unevaluated context.
A declarator is only assigned but never accessed.
A declarator is never used.
A local variable might not be initialized.
No return statement in a function with non-void return type.
Not all control paths inside a function return a value.
Function parameter is never used.
'static' specifier on an anonymous namespace member is redundant.
'default' is a keyword in the C++ standard and can not be used as an identifier.
Static data members are not allowed in anonymous classes.
Use 'auto'
Parentheses don't change order of operations and may be deleted
Redundant empty statement
Redundant control flow jump statement
Redundant 'else' keyword inside compound statement
Redundant 'else' keyword
Unreachable code
Redundant 'template' keyword.
Redundant 'typename' keyword.
An access specifier does not affect any declaration and is redundant.
An access specifier does not change accessibility level and is redundant.
Qualifier is redundant and can be deleted.
boost::format is invoked with redundant list of arguments (some of them are not utilized).
boost::format is invoked with insufficient list of arguments.
boost::format string should contain either positional (%N%, %|N$...|) or serial (%|...|, %s) arguments, not both.
Constructor of a smart pointer (boost/std::shared_ptr/unique_ptr) used instead of corresponding make_shared/make_unique.
Make functions are exception-safe and more efficient.
boost::format string contains an erroneous format code.
printf() is invoked with insufficient list of arguments (some format codes match to no argument).
Format string contains a potential error.
Format string contains an invalid printf format specifier
Calls to pure virtual functions inside constructors and destructors are a runtime error.
Calls to virtual functions inside constructors and destructors are resolved statically.
Detects plausible acquired resources leaks
Detects leak-prone resource acquisition/freeing constructs
Implicit conversion to less qualified pointer type
Implicit conversion to incompatible pointer type
Implicit pointer to integer conversion.
Implicit integer to pointer conversion.
Using the result of an assignment as a condition.
Tags of the declared class do not match previous declarations
Member function may be 'static'.
A declarator is reassigned in all paths before being read.
A declaration specifier is ignored when there are no declarators.
Class constructor doesn't initialize a field explicitly or implicitly
Possibly unintended object slicing.
Expression which evaluates to zero is used as a null pointer constant.
More than one implicit conversion applied during copy-initialization. This is non-standard Microsoft C++ extension.
Taking an address of class r-value is non-standard Microsoft C++ extension.
Binding r-value to l-value reference is non-standard Microsoft C++ extension.
Casting from nullptr to pointer type with reinterpret_cast is non-standard Microsoft C++ extension.
Class needs a user-defined constructor because of an uninitialized data member.
Implicit default constructor is not available because a base class or a class member does not have an accessible default constructor.
Dependent template without 'template' keyword.
Dependent type without 'typename' keyword.
This is possibly erroneus expression-statement without side-effects.
This is possibly erroneous empty-statement used in a control statement.
This switch statement doesn't cover the whole range of the enumeration used.
A polymorphic class with a non-virtual public destructor.
Class member function hides a non-virtual function from a base class.
Non-virtual class member function is hidden in a derived class.
A function is not implemented.
Zero constant can be replaced with nullptr.
Throw expression can be replaced with a rethrow expression.
boost::format string contains a legacy printf-like code; type specifier is not taken into account.
Member function may be 'const'.
Order of member initializers does not match the initialization order.
Returning from a function by const value is usually not beneficial. Consider returning values as non-const to
take advantage of move semantics.
Result of a postfix operator is discarded. It might be more efficient to use a prefix form of the operator.
Non-explicit converting constructor.
C-style cast used instead of a C++ cast.
An overriding function should have 'override' specifier.
'static' specifier is optional for member allocation/deallocation functions.
A local declaration hides another local declaration.
A declaration does not declare anything.
'virtual' specifier on an override function is redundant.
Redundant base class access specifier.
A non-overriding virtual function in a final or sealed class cannot be overridden, so the 'virtual' specifier is redundant.
Declarator is disambiguated as a function declaration. Make sure a variable definition is not intended instead.
'inline' specifier on a function definition is redundant.
Possibly uninitialized dependent base class.
Unions cannot contain non-static data members of reference types.
Explicit specializations of a template in non-namespace scope.
Default initialization of a const-qualified object of a type without a user-provided default constructor.
Reference class members cannot have 'mutable' specifier.
A template parameter from an outer scope is shadowed by a declaration with the same name.
An incomplete type is used inside a template declaration or definition.
Highlights an unknown property
Highlights an unknown target
Highlights an unknown item group
Highlights an unknown metadata
Highlights an unknown task
Highlights tags where ReSharper failed to find tasks definitions
Highlights an invalid task element
Highlights wrong metadata use
Highlights a tag which has missing required attribute
Highlights an unknown output parameter of a task
Highlights a task that requires an output tag
Highlights a task with multiple output tags
Highlights an unknown task attribute
Highlights an attribute that has invalid value
A 'foreach' ('For Each' for VB.NET) or 'for' statement can be converted into a LINQ-expression
For-loop can be converted into foreach-loop
Invocation of 'virtual' or 'override' field-like event leads to unpredictable result since invocation list is not virtual.
Member hides static member from outer class.
Part of 'foreach' ('For Each' for VB.NET) statement's body can be converted into a LINQ-expression
Method with optional or 'params' parameter is hidden by overload.
Method invocation is skipped. Compiler will not generate method invocation because the method is conditional, or it is partial method without implementation.
Symbol in string is expected to be a reference but cannot be resolved
Value of a boolean expression is always the same at this point.
The expression is always evaluated to 'null' at this point.
Operand of '??' expression condition is known to be null or not null.
Conditional access qualifier expression is known to be null or not null.
'base.' qualifier is redundant and can be safely removed without changing code semantics.
Redundant use of qualifier for a type name or static member usage.
Comparison of a boolean value with 'true' or 'false' constant.
Type cast can be safely removed.
Catch clause with single 'throw' statement is redundant.
Empty 'finally' block is redundant.
Value assigned to a local variable or parameter is not used in any execution path.
Use of ToString() call in a context where it would be generated by the compiler automatically.
For example, in a concatenation with a string or as an argument of a string.Format() call.
Use of ToString() call in a context where it would be generated by the compiler automatically.
For example, in a concatenation with a string or as an argument of a string.Format() call.
Redundant 'string.Format()' call.
Redundant 'IEnumerable.Cast<T>' or 'IEnumerable.OfType<T>' call.
Redundant 'string.ToCharArray()' call.
Specification of method type arguments is redundant because they are inferred from argument types.
Specifying signature in an anonymous method is not necessary because none of its parameters are used in the body.
Explicit delegate creation expression is redundant.
Parentheses are redundant if attribute has no arguments.
'true' is redundant as 'for'-statement condition, and thus can safely be omitted.
Empty 'for' loop is redundant.
Unsafe context declaration is redundant because it is declared in unsafe context, or it doesn't contain unsafe constructs.
When object creation uses object or collection initializer, empty argument list is redundant.
Redundant empty object or collection initializer.
When collection initializer element has only one expression, the braces are redundant.
When array type can be inferred from initializer, array creation expression can be converted to implicitly typed.
When array initializer has the same number of elements as specified in size expression, explicit size specification is redundant.
When initializing explicitly typed local variable or field of array type, array creation expression can be replaced with array initializer.
Redundant 'else' keyword.
'case' label statement is redundant.
Explicit name specification of anonymous type property is redundant. It is inferred from initializer expression.
Value type is implicitly convertible to it's nullable, so explicit nullable type creation is redundant.
Redundant lambda parameter explicit type specification.
When lambda signature contains single implicitly-typed parameter, signature parentheses can be omitted.
Double negation is meaningless <pre>bool b = !!condition;</pre>.
Redundant explicit argument name specification.
Redundant explicit argument name specification when argument is literal expression.
Corresponding parameter is optional and has the same value, so argument could be omitted.
Heuristically unreachable code detected.
Check for inequality before assignment is redundant
<pre>
if (x != value)
x = value;
</pre>
Redundant operand in logical conditional expression, for example
<pre>
expr || false
expr && true
</pre>
Redundant conditional ternary expression usage
<pre>
condition ? true : false
</pre>
Redundant default switch branch
<pre>
switch (foo)
{
case Bar:
DoSomething;
break;
default:
break;
}
</pre>
Redundant comma in array/object/collection/anonymous type initializer: <pre>int[] xs = { 0, };</pre>
Redundant comma in enum declaration: <pre>enum E { A, }</pre>
Redundant comma in attribute list: <pre>[A, B,]</pre>
Using directive is not required by the code and can be safely removed.
Redundant control flow jump statement
Private field is always assigned before being used and can be converted to local variable.
Application of [AttributeUsage] attribute has property assignment to it's default value
Array creation in argument passed to 'params' parameter is redundant
String interpolation expression without arguments is redundant
Immediate delegate invocation is redundant
Semicolon after class/struct/enum/interface/namespace declarations is redundant in C#
Arithmetic overflow checking context contains no operators or conversions with overflow checks
Convert if declaration is of built-in type (e.g. string).
Convert if simple type (not an array and does not have generic parameters).
Convert if declaration is not of built-in or simple type and is not evident from the usage.
'this.' qualifier can be safely added/removed without changing code semantics.
Qualifier can be safely added/removed without changing code semantics.
Remove unnecessary whitespace at the end of line.
CLR type names and corresponding C# keyword are interchangeable and do not affect code semantics.
'internal' modifier can be safely added/removed from types without changing code semantics
'private' modifier can be safely added/removed from type members without changing code semantics
Modifiers order must respect reference order
Parentheses can be safely removed from expressions without changing code semantics
Parentheses can be safely added to expressions to clarify precedence
Attributes have to be declared in separate sections or in a single sections
An expression which can have 'null' value is assigned to an entity marked with 'Value cannot be null' attribute. In particular, this can happen when passing such value to a method whose parameter is marked with 'Value cannot be null' attribute.
Type member marked with '[NotNull]' attribute is not initialized on all execution paths of constructor
Type is marked by 'CannotApplyEqualityOperatorAttribute' attribute but compared with '==' or '!=' operators
Concrete base type is required by '[BaseTypeRequired]' attribute
Invalid type specified in '[BaseTypeRequired]' attribute usage. Only classes and interfaces supported
Type specified in '[BaseTypeRequired]' attribute conflicts with another type
Type required by some attribute (marked with BaseTypeRequired) conflicting type from another attribute
Input string in ContractAnnotation attribute couldn't be parsed
Dereferencing an expression which can have 'null' value. This warning is detected either when there is a comparison with 'null' earlier in the code or when this value is returned by a member marked with 'Value can be null' attribute.
Possible call to method is invalid for the object's current state.
Possible cast expression of incompatible type.
Possible cast expression of incompatible type.
Anonymous type which differs only in property order is detected nearby.
Function does not reach its end or a 'return' statement by any of possible execution paths.
Function or type initialization is recursive on all execution paths.
Local variable has the same name as a field and hides it.
A catch clause that catches System.Exception and has an empty body.
Method parameter has the same name as a field and hides it.
The setter of a property or indexer does not use its 'value' parameter. Also applies to adders and removers of events.
When a virtual method is called, the actual type that executes the method
is not selected until run time. When a constructor calls a virtual method,
it is possible that the constructor for the instance that invokes the method
has not executed. See <a href='http://msdn2.microsoft.com/en-us/library/ms182331.aspx'>http://msdn2.microsoft.com/en-us/library/ms182331.aspx</a>.
A 'throw' statement inside a catch clause which throws the exception caught. In most of cases a 'throw' statement with no argument is to be used.
'Object.ReferenceEquals' is always false because it is called with value type.
Generic type has no value or class constraint, the condition could be always 'false'.
Access to closure variable from anonymous method when the variable is modified externally.
Access to closure variable from anonymous method when the variable is disposed.
Possible ambiguity while accessing member by interface.
Bitwise operation on enum which is not marked by [Flags] attribute.
Possible loss of fraction when divide integral values and assign result to float or decimal.
Possible cyclic constructor call.
Mismatch optional parameter value in overridden method.
C# doesn't support 'ref' or 'out' optional parameters.
Compare of float numbers with equality operator.
Assignment to a property of a readonly field can be useless.
Static field/auto-property/event initializer refers to static field/auto-property/event below or in other part.
Event unsubscription via anonymous delegate is meaningless.
Compare to similar expression for equality is usually senseless.
'?:' expression has identical true and false branches.
Convert the following code:
<pre>
if (condition) return expr1;
return expr2;
</pre>
To:
<pre>
return condition ? expr1 : expr2;
</pre>
Right operand of dynamic shift operation should be convertible to 'int'.
Cannot resolve symbol in text argument.
Possible multiple enumeration of IEnumerable.
Return value of pure method is not used.
Return value of method annotated with [MustUseReturnValue] attribute is not used.
Return value of iterator is not used.
Impure method is called for readonly field of value type.
Non-readonly field or auto-property referenced in 'GetHashCode()'.
Overriden GetHashCode calls base 'Object.GetHashCode()'.
Call to base 'Equals(...)' method is resolved to 'Object.Equals', which is reference equality.
Operator 'is'/'Type Of ... Is ...' can be used instead of comparing objects GetType() and instance of System.Type object.
Long literal ending with 'l' instead of 'L'.
Static field or auto-property in generic type may result in state duplication per each generic type instantiation.
Thread static field has initializer, it is invoked only once on the thread that's running when the static constructor executes.
Possible incorrect implementation of Double-Check Locking pattern. Read access to checked field.
Possible incorrect implementation of Double-Check Locking pattern. Possible multiple write access to checked field.
Possible incorrect implementation of Double-Check Locking. Checked field must be volatile or assigned from local variable after 'Thread.MemoryBarrier()' call.
Invocation is resolved to method with 'params', but more specific method is available and arguments partially match it.
'GC.SuppressFinalize' is invoked for type without destructor.
'Enumerable.Sum' invocation in explicit unchecked context.
Call to base member with implicit default parameters.
Type check ('is' expression) with direct cast(s) after can be replaced with try cast ('as' expression) and a null check.
Co-variant conversion of array could cause run-time exceptions.
Delegate subtraction has unpredictable result.
[ThreadStatic] does nothing with instance fields.
There is base member that has conflicting nullness annotation.
'void' method is annotated by [Pure] attribute.
'void' method is annotated by [MustUseReturnValue] attribute.
Possibly misleading 'DefaultValueAttribute' usage to define optional parameter value. 'DefaultParameterValueAttribute' should be used instead.
Warns that lambda implicitly captures locals.
Possible unintended reference comparison.
Object created by 'new' expression is possibly not assigned anywhere.
Multiple sequential 'OrderBy' invocation is meaningless. Possible 'ThenBy' means.
Compiler generates correct value for parameters marked with [CallerMemberName], [CallerFilePath] or [CallerLineNumber] attributes.
This code can have different behavior when compiled with different versions of compiler. See changes for 'foreach' loop in C# 5.0 and Visual Basic 11.
Tail recursive calls may be replaced with loop for better performance and protection from possible stack overflows.
Loop control variable is never changed inside loop.
The field is sometimes used inside synchronized block and sometimes used without synchronization.
Member initializer value ignored, because member always initialized in all constructors.
Safe cast expression always succeeds and can be replaced with direct cast.
The given expression of 'is' operator is always of the provided type.
The given expression of 'is' operator is never of the provided type.
Assignment in conditional expression; did you mean to use == instead of = ?
Function body is too complex to analyze, consider decomposing it or reducing number of variables
Formatting is specified, but interpolated string expression is not IFormattable
Some values of the enum are not processed inside switch statement
Usage of 'Enumerable.Count()' method can be replaced with direct collection count property access
Value of some context type is already provided by member annotated with [ProvidesContext] annotation
Methods marked with OperationContract attribute as OneWay operations couldn't return values
Interfaces marked as ServiceContract should declare at least one OperationContract
Marking method as OperationContract without ServiceContract attribute on the containing type could cause runtime exception
Local variable is declared in a wider scope than the scope of its actual use.
Type of iteration variable declared in 'foreach' statement is less specific than that which can be inferred from the collection type being iterated.
Make constructor in abstract class protected.
Replace direct comparison to null and empty string with 'String.IsNullOrEmpty' call.
Type parameter could be declared as covariant or contravariant.
Join local variable declaration and assignment.
Access to a static member of a type via a derived type.
Base member has 'params' parameter, but overrider hasn't.
Suggest to replace
!(expr1 != expr2) to expr1 == expr2
!(expr1 == expr2) to expr1 != expr2
Use indexed property in COM import types instead of the accessor usage.
There is base member that has the same nullness annotation.
Nullable attribute usage with declaration having value or void type doesn't affect code analysis.
It is incorrect to use [NotNull] and [CanBeNull] simultaneously.
try-catch and try-finally statements can be merged
Ternary expression contains 'true' or 'false' in result branch, for example
<pre>
condition ? true : elseBranch
condition ? thenBranch : true
</pre>
Specify a culture in string conversion explicitly
Simplify statement
Suggest to replace
bool result = x > 0;
if (y > 0) result = true;
To
bool result = x > 0 || y > 0;
Simplify LINQ expression.
Method has overload with CancellationToken.
Specify string comparison explicitly.
Code is unreachable.
Empty statement is redundant.
Empty control statement body.
Suggest to replace object sequential assignments to newly created object fields by object initializer.
When extension method is invoked as static method, convert invocation to extension method syntax.
Converts property declaration to C# auto-implemented property syntax.
Converts property declaration to C# 3.0 auto-implemented property syntax.
Converts property declaration to C# 3.0 auto-implemented property syntax private setter declared.
Rewrite nullable type in short form.
Convert the following code:
<pre>
var x = expr1;
if (x = null) x = expr2;
</pre>
To:
<pre>
var x = expr1 ?? expr2;
</pre>
Convert the following code:
<pre>
if (condition) x = expr1;
else x = expr1;
</pre>
To:
<pre>
x = condition ? expr1 : expr2;
</pre>
Parameter name differs in partial method declaration.
'?:' expression can be re-written as '??' expression.
Invert 'if' statement to reduce nesting.
Convert series of 'if' statements to single 'switch' statement.
Make class static.
Remove 'sealed' modifier or make constructor public or internal.
Convert to statement-bodied lambda to expression-bodied. Do not suggests conversion when expression contains nested closures or explicit side-effects.
Convert to statement-bodied lambda to expression-bodied when possible.
Convert lambda expression or anonymous method to method group.
Convert statement-bodied property/indexer declaration to expression-bodied form. Do not suggests conversion when expression contains nested closures or explicit side-effects.
Convert statement-bodied method/operator declaration to expression-bodied form. Do not suggests conversion when expression contains nested closures or explicit side-effects.
Convert statement-bodied member declaration to expression-bodied form when possible.
Introduce optional parameters to overload method.
Introduce optional parameters to overload method.
Merge sequential null/type checks in && or || expressions.
Merge conditional expression (?: ternary operator) into conditional access expression.
Replaces if statement with null-propagating code using ?. operator.
Replaces if statement with null-propagating code using ?. operator.
Replace string literal with statically typed 'nameof' expression.
Explicit call to the base class constructor with no arguments. Is generated by the compiler by default and can be omitted.
Empty public constructor declaration with no parameters is redundant. The compiler generates the same by default.
Empty finalizer declaration is redundant.
The override of a virtual member is redundant because it consists of only a call to the base.
Empty namespace declaration is redundant.
'sealed' modifier for member in a sealed class is redundant.
Type is either mentioned in the base types list of other part, or it is interface and appears as other's type base and contains no explicit implementations.
Class is declared as 'partial', but has only single part.
Method is declared as 'partial', but has only single part.
'int' is default underlying type of enum, so it is not necessary to specify it explicitly.
Initializing field/property/event with default value is redundant.
'params' modifier is always ignored on overrides.
Redundant method overload. Use another method with optional parameters.
Redundant method overload. Use another method with optional parameters.
'DefaultParameterValueAttribute' should be used in conjunction with 'OptionalAttribute'.
CS0183: Given expression is always of the provided type
CS0184: Given expression is never of the provided type
CS0162: Code is unreachable
CS0628: Declaring new protected member in sealed class is the same as declaring it as private
CS1522: Empty switch block
CS0469: 'goto case' value is not implicitly convertible to required type
CS0108,CS0114: Keyword 'new' is required
CS0109: Keyword 'new' is redundant
CS0660,CS0661: Operator '==' or operator '!=' with 'Object.Equals(object o)' and 'Object.GetHashCode()' not overriden
CS0642: Possible mistaken empty statement
CS1030: '#warning' directive
CS1717: Assignment made to same variable
CS0252,CS0253: Possible unintended reference comparison
CS1573: Parameter has no matching param tag in the XML comment
CS1712: Type parameter has no matching typeparam tag in the XML comment
CS1574: Ambiguous reference in XML comment
CS1580: Incorrect signature in XML comment
CS1584: Syntax error in XML comment
CS1710: Duplicate typeparam tag in XML comment
CS1571: Duplicate param tag in XML comment
CS1587: XML comment is not placed on a valid language element
CS1592: Badly formed XML in included comments file
CS1590: Invalid XML include element
CS1589: Unable to include XML fragment
CS1570: Invalid XML in XML comment
CS1723: XML comment has cref attribute that refers to a type parameter
CS1591:Missing XML comment for publicly visible type or member
CS0672: Member overrides obsolete member
CS0665: Assignment in conditional expression
CS0659: Class overrides Object.Equals(object o) but not Object.GetHashCode()
CS0465: Introducing a 'Finalize' method can interfere with destructor invocation
CS0693: Type parameter has the same name as a type parameter from the outer type
CS0618: Use of obsolete symbol
CS0612: Use of obsolete symbol (without message)
CS0420:Reference to a volatile field will not be treated as volatile
CS1066: Default value specified for parameter will have no effect because it applies to a member that is used in contexts that do not allow optional arguments
CS1911: Access to a member through 'base' keyword from anonymous method, lambda expression, query expression or iterator results in unverifiable code
CS0197: Taking address of marshal-by-reference class field
CS1957: Multiple override candidates at run-time
CS1998: Async function without await expression
CS4014: Async method invocation without await expression
CS0657: 'attribute modifier' is not a valid attribute location for this declaration. All attributes in this block will be ignored
CS0658: 'attribute modifier' is not a recognized attribute location. All attributes in this block will be ignored
CS7095: Filter expression is a constant, consider removing the filter
CS1058: A previous catch clause already catches all exceptions
CS8094: Alignment value 'value' has a magnitude greater than 'magnitude limit' and may result in a large formatted string.
WME006:Namespace should be default namespace of this project
Field is assigned but its value is never used (compiler warning).
Field is never assigned (compiler warning).
Type or type member is never used.
Type or type member is never used.
Type member is never used with base type or interface, it is always accessed via more specific type.
Type member is never used with base type or interface, it is always accessed via more specific type.
Type member is never used from outside of implementation hierarchy, it is only accessed from overrides through base call.
Type member is never used from outside of implementation hierarchy, it is only accessed from overrides through base call.
Method return value is never used.
Method return value is never used.
Parameter is never used.
Parameter is never used.
Virtual(overridable) member is never overridden and so the 'virtual' ('overridable') modifier can be removed.
Virtual(overridable) member is never overridden and so the 'virtual' ('overridable') modifier can be removed.
Non-abstract class has virtual(overridable) members but has no inheritors.
Non-abstract class has virtual(overridable) members but has no inheritors.
Type parameter is never used.
Local variable is never used.
Local variable is assigned but its value is never used.
Label is never referenced.
Non-static class is never instantiated.
Non-static class is never instantiated.
Field is assigned but its value is never used.
Field is assigned but its value is never used.
Event is never subscribed to.
Event is never subscribed to.
Field is never assigned.
Field is never assigned.
Readonly field is never assigned.
Accessor in auto-property is never used.
Accessor in auto-property is never used.
An abstract or virtual(overridable) event is never invoked in its class or its inheritors.
One type is converted to another but there is no type in the solution which is inherited from both. Also applies to 'is' operator and '==' and '!=' comparisons.
Event never invoked. Note that in C# this warning is the compiler warning CS0067 and is not configured here.
New elements are never added to the collection.
New elements are never added to the collection.
Elements are only added to the collection but never used.
Elements are only added to the collection but never used.
Member can be made private.
Member can be made private.
Member can be made protected.
Member can be made protected.
Member or type can be made internal (friend).
A non-virtual instance member does not use 'this' object (neither implicitly nor explicitly) and can be made static(shared).
A non-virtual instance member does not use 'this' object (neither implicitly nor explicitly) and can be made static(shared).
Class has no inheritors and can be marked sealed (non-inheritable).
Class has no inheritors and can be marked sealed (non-inheritable).
Field has no write usages after initialization and can be made readonly.
Field has no write usages after initialization and can be made readonly.
Auto-property has no write usages after initialization and can be made get-only.
Auto-property has no write usages after initialization and can be made get-only.
Auto-property without setter has no initializer or never assigned in constructor.
Convert local variable or field to constant.
Convert local variable or field to constant.
Parameter can be declared with base type. Note that when the base type is IEnumerable<T>, another inspection 'Parameter type can be IEnumerable<T>' will be applied (this allows you to configure different severities for th
Parameter can be declared with IEnumerable<T> type while it's declared with more specific type (e.g. List<T>)
Parameter can be declared with IEnumerable<T> type while it's declared with more specific type (e.g. List<T>)
All usages of a method (or read-only property/indexer) use returned value as IEnumerable<T> while it's declared with more specific type (e.g. List<T>)
All usages of a method (or read-only property/indexer) use returned value as IEnumerable<T> while it's declared with more specific type (e.g. List<T>)
Local variable is never used (compiler warning).
Local variable is assigned but its value is never used (compiler warning).
Readonly field is never assigned (compiler warning).
Field is never used (compiler warning).
Explicitly specifying System.String as type of a data entry is redundant.
Base resource item and the current item have the same value.
Resource file contains two or more items with identical names.
Base resource contains a non-empty value while this resource is empty.
Resource is not overridden in one or more specific cultures.
Resource is not declared in base culture.
Format string placeholders don't match between cultures.
Resource in base culture has another value type.
You can move this element to a resource.
Cannot resolve symbol.
Replace string construction by 'String.Format()' method invocation with string interpolation expression.
Format string syntax errors (unescaped braces, invalid idices/alignments, unused arguments etc.) and other formatting method invocation problems.
Name doesn't match naming style defined for this kind of symbol
According to ECMA-335 part II (Metadata) paragraph 9.2: 'Generics and recursive inheritance graphs'
Namespace in file does not have a form of project Default Namespace plus folder names in the path to file. You can configure which folders participate in namespace building process on the folder's properties page
'MyClass.' qualifier is redundant and can be safely removed without changing code semantics.
Qualifier is redundant
Code is unreachable
Array lower bound specification is redundant
Converts property declaration to VB.NET auto-implemented property syntax.
Converts property declaration to VB.NET auto-implemented property syntax.
Iterator function without 'Yield' statements
'MyBase.' qualifier is redundant and can be safely removed without changing code semantics.
'Me.' qualifier is redundant and can be safely removed without changing code semantics.
Conditional operator contains 'True' or 'False' in result branch, for example
<pre>
If(condition, True, elseBranch)
If(condition, thenBranch : True)
</pre>
Use implicit 'ByVal' modifier in parameter declaration
WME006:Namespace should be default namespace of this project
Inactive preprocessor branch
Converts property declaration to VB.NET auto-implemented property syntax private setter declared.
Redundant empty 'Case Else' statement
'IIf' contains 'True' or 'False' in result branch, for example
<pre>
IIf(condition, True, elseBranch)
IIf(condition, thenBranch : True)
</pre>
Import clause is not used in the file and could be safely removed
Possible write to 'Me'.
'out' parameter is not assigned upon exit
BC42358: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'Await' operator to the result of the call.
BC400005:Member shadows an overriable member
BC42356:Async method lacks 'Await' operators
BC42349:Redundant DirectCast to the equals value type
BC40056:Namespace or type specified in the Imports 'name' doesn't contain any public member or cannot be found
BC42104:Variable is used before it has been assigned a value
BC42322:Runtime errors might occur when converting X to Y
BC42016:Runtime errors might occur when converting X to Y
BC42025:Access of shared member through an instance
BC40008:Use obsolete member (without message)
BC40000:Use obsolete member
BC42304:Syntax error in XML comment
BC42309:XML comment has a tag with a 'cref' attribute that could not be resolved
BC42353,BC42354,BC42355:Function doesn't return a value on all code paths
BC42105,BC42106,BC42107:Function doesn't return a value on all code paths
Use implicitly typed variable declaration
Use implicitly typed variable declaration when variable type is evident from initializer expression
Explicit set accessor 'value' parameter declaration is redundant
Parameterless property parameter parentheses are redundant
Type cast (assertion) is redundant, as provided value always has type identical to type provided for the cast
Unknown skin
Semicolon is missing at the end of the statement.
Mismatch ASP.NET MVC Model Type
Location element does not correspond to any path in the web site and can be safely removed
Tag prefix does not declare any new alias and can be removed safely
Module qualification required for type resolution
Add namespace element is redundant because it duplicates another element of is cleared later and can be safely removed
Add element is redundant because it is cleared later and can be safely removed
Element or attribute is not applied because of 'configSource' attribute and can be safely removed
Element does not clear anything and can be safely removed
Referenced path cannot be found in the website
Unknown Razor section
Unknown Razor layout
Use of undeclared variable.
Symbol is possibly in inaccessible module
'arguments.caller' and 'arguments.callee' are forbidden in 'strict mode'
Using a variable (property or object) without declaring it is not allowed in 'strict mode'
Calling 'delete' on non-qualified identifier is not allowed in 'strict mode'
Duplicate property declaration is not allowed in 'strict mode'
Duplicate parameter declaration is not allowed in 'strict mode'
Octal literals and escape sequences are not allowed in 'strict mode'
'eval' or 'arguments' cannot be used as a declaration name, as a left-side of an assignment or as an argument of increment/decrement operator in 'strict mode'
Using of future reserved keywords is not allowed in 'strict mode'
'with' statement is not allowed in 'strict mode'
Variable is used in inner scope before it is declared
Function is used before it is declared
Variable is used outside of scope which it is declared
Function is used outside of scope which it is declared
Object constructed by 'new' expression is not used. Function should be called in general manner if used for side-effects
Avoid using 'arguments.caller' or 'arguments.callee' by either giving function expressions a name or use a function declaration
'==' and '!=' both try to coerce values before comparing them which can lead to some unexpected results. Using of strict operators '===' and '!==' makes code more predictable
'==' and '!=' when applied to 'null' or 'undefined' perform check with both of these values
Extending prototype of native object may cause unexpected effects
Overwriting prototype of native object has no effect
Variable is used before it is declared
Local function is redefined later
Comparison of similar expressions like x == x
Assignment to a variable inside a conditional statement is likely to be mistyped '=='
Comparison of 'typeof' expression with incorrect value
Closure on a variable modified in loop of outer scope
There is no .hasOwnProperty() check in a body of 'for in' loop. This will cause an enumeration of prototype properties
When NoImplicitAny compiler option is set, emits errors for implicit any
Use of inappropriate value to the left of assignment operator
Multiple variable declarations are not allowed in 'for-in' loop
'break' and 'continue' statements can only be followed by label name
'throw' statement should be followed by expression
Property getter cannot have parameters
Property setter must have a single parameter
Object property declaration is expected
Cannot resolve symbol
ECMAScript 6 feature is used in ECMAScript 5 or lower
Experimental feature used when targeted to stable ES level
Path for file referenced by a reference comment is not found
Code is unreachable
A variable was assigned a value but never used
'break' and 'continue' without label should be in a loop body
Type assertion in form of <Type>expr can be converted to 'expr as Type' form
If type itself or its descendant is already present in extends or implements list, an extra specification is redundant
Comparisons like 'a === true' and 'a !== true' with boolean 'a' are equivalent to just 'a' and '!a'
Specifying '? true : false' with boolean condition is redundant
Double negation of boolean is identical to it's value
Type cast (assertion) is redundant, as provided value always has exactly the same type as the type provided for the cast
Declaration hides another declaration from an outer scope
Unknown content placeholder
Two import declarations are resolved to the same item
Empty constructor without parameters is redundant
Non-exported import is declared but is never used.
Overload parameter, which doesn't participate in the main signature, doesn't make any sense
Type guard, which doesn't really affect the variable's type, is redundant
Expression cannot be of type for which it's checked against using 'typeof'
Expression cannot be subtype of type against which it's checked using 'instanceof'
Function is provided with type annotation, but return value is empty
In a context of local function inside class member, 'this' refers to the local function itself, not to the containing class
If a parameter-property is referred to without 'this' qualifier in an assignment inside the constructor, the assigned value won't be set for the resulting property, but will be set only for the local constructor parameter
Type parameter with the same name exists in some outer scope, and current declaration hides it
Referenced property is declared later or it references itself in a static initializer
If more specific signature follows less specific, TypeScript overload resolution will choose less specific, nevertheless
If overload is less specific than the main signature, it makes no sense, as TypeScript overload resolution will use less specific overload signature for resolve
For some environments, amd-dependency correspondance with actually existing modules is crucial
If one of the arguments is a string literal, it's possible to create a specialized overload for it
Type guards cannot be applied to expressions, but can be applied to local variables. Introducing variable will allow type guard to be applied.
Presence of 'public' modifier doesn't adhere to code style setting
Corresponds to errors reported by compiler when running with --noImplicitAny flag. Corresponding code style setting should be set for this inspection to be enabled.
If variable type could be derived from context, it may also be explicitly specified. Is affected by code style setting 'Specify types explicitly'.
If variable declaration has an initializer, type specification is redundant, if it's the same type with assigned value type. Is affected by code style setting 'Specify types explicitly'.
Path style inside 'require' doesn't adhere to code style setting.
Parameter of function is declared but never used.
Parameter of function is declared but never used, and that function is inherited.
Local variable or function is declared but never used.
Property or function is declared but never used.
Local function name is redundant because it is never called recursively.
Duplicate declaration of a local variable, function or parameter.
Assignments like 'a = a' are redundant
'else' block is redundant
Block is redundant
The word is reserved for future versions of ECMAScript.
Join local variable declaration and assignment
Function-scope variable (declared by 'var' keyword) can safely be turned into a block-scope variable (declared by 'const' keyword)
A variable had no write usages, thus it can be turned into a constant
A variable had no usages in outer block where it is declared, so it can be safely moved to the inner block
If an expression represents string concatenations with other expressions, it may be converted to a template expression
If a local variable is assigned to some another local variable,
and that local variable doesn't have more than one read usage, it may be safely inlined
A temporary local variable used for swapping values of two other variables may be replaced by a destructuring swap
If the same item is indexed in right-hand side of the subsequent statements (e.g., a = e[1], b = e[2]), that sequential serie of assignments may be replaced by a destructuring declaration or assignment (e.g., [, a, b] = e)
If the same item is indexed in values of object properties (e.g., var x = {a: r[0], b: r[1]}), that properties may be preliminary assigned using a destructuring and then used in a shorthand form, if no name conflicts are detected
If a sequence of properties for the same item is checked for 'undefined' (e.g., var w = x.a === undefined ? def1 : x.a, var s = x.b === undefined ? def : x.b), this can be replaced with an object destructuring pattern (e.g., {a: w, b: s} = x)
Heuristically unreachable code.
Expression is always constant.
Qualifier can be 'null' or 'undefined'.
Qualifier is 'null' or 'undefined'.
Invoked expression is not a function value.
Invocation of non-function expression.
Condition is always constant.
Duplicate declaration of a literal object property.
Duplicate switch label.
Expression statement is neither an assignment statement nor a function call.
Use of 'this' in global context.
Assignment to an implicitly declared global variable.
Assignment to constant may lead to a run-time error
Constant must be assigned
Block scope varialbes cannot be redeclared
Use of implicitly declared global variable.
Use of possibly unassigned property or global variable.
Some of function exits return value but the others don't.
Return statement with a value in the global scope.
Function has return statements with specified value but there are execution paths that don't contain any return statement.
Variable is assigned not on all execution paths.
Parameter name 'arguments' clashes with pre-defined JS function-scope variable
Variable is used but is wasn't assigned a value.
Parameter value is not used because it is overridden in the function body.
Property with qualifier 'this' that is used in an inner function matches by name with property defined in the outer function.
If an element is elided at the end of an array, that element does not contribute to the length of the Array.
Error in Xml doc comment reference.
Newline causes text to be treated as two separate statements, though maybe it was intended to be a single one
Trailing redundant comma in object properties leads to errors in some JS engines (e.g., IE's engine <=9)
Unknown theme
Lambda expressions in form of () => {a: b} are block lambdas with a statement 'b' having a label 'a'
Assignment expression in form of {a: b} = {a: 5} cannot be used in an expression statement if not parenthesized
Quotes around string literal differ from code style setting
Html Dead Code
Html Warning
Unknown html entity
Path error
Unknown tag in HTML and related technologies
Unknown attribute in HTML and related technologies
Unknown event in HTML and related technologies
Not closed tag in HTML and related technologies
Not closed tag in HTML and related technologies
Not closed tag in HTML and related technologies
Link to unknown anchor (no element with such ID or name)
Obsolete or nonstandard element
Path is ignored in project settings
Path is mapped to a different path in project settings
Duplication of id on page
Attribute quote are missed or differ from settings
Cannot resolve symbol with specified name.
Cannot resolve file system path.
Cannot resolve vendor-specific extension.
Cannot resolve CSS class with specified name.
Invalid CSS value.
This value will be ignored.
Hexadecimal value of color with alpha component is not supported.
Syntax is not allowed in specified CSS version.
CSS symbol is considered obsolete in specified language version.
CSS symbol is not compatible with a specific browser.
Standard property should be set after vendor-prefixed property.
Fallback color (hex or RGB) should precede color with new format (rgba, hsl, and hsla).
Code is redundant.
Unit of measure is redundant for zero value.
Declaration doesn't contain any properties.
Path error
Unknown ASP.NET MVC Controller
Unknown ASP.NET MVC Action
Unknown ASP.NET MVC View
Unknown ASP.NET MVC Partial View
Unknown ASP.NET MVC Area
Unknown ASP.NET MVC Template
Unknown ASP.NET MVC Masterpage
Unknown ASP.NET MVC View Component
Unknown ASP.NET MVC View Component View
ASP.NET Dead Code
ASP.NET Warning
ASP.NET Resolve Warning
Wrong image size
Unknown symbol in ASP.NET and related technologies
Attribute with optional value problem
ReSharper does not support pageParserFilterType specified in web.config
Register directive is unused and can be safely removed
Object data source method resolve problem
Use of obsolete type or type member in XAML markup
Use of obsolete type or type member in XAML markup (error)
Attached property setter has no effect in current context and can be removed
Property value is equal to value, provided by explicit style and can be removed
Xaml 2009 language construct is not allowed here
{DynamicResource} can only be used with DependencyProperty of a DependencyObject
Freeze attribute is not used and can be safely removed
Accessibility set by attribute coincides with default one, thus attribute can be safely removed
Name attribute in resource declaration is neglectable and can be safely removed
Namespace alias is not required by code and can be safely removed
Resource is not used and can be safely removed
Property owner type qualifier is redundant and can be safely removed
Empty collection property setter is redundant and can be safely removed
Path is ignored in project settings
Static resource not resolved
Constructor not resolved
Dependency property descriptor field missing or implementation does not comply with Microsoft style guide
Routed event descriptor field missing or implementation does not comply with Microsoft style guide
XAML style of invalid target type
x:Key is allowed for resources and dictionary elements only
Path error
Unresolved binding path when DataContext for data binding is not specified
Unknown DeviceFamily
Style declaration target type is not convertible to style base type
Duplicate style property/event setter
Object/markup extension of invalid type
XAML resource of invalid type
Default RelativeSourceMode value is platform-specific, explicit specification is required to process RelativeSource usage unambiguously
Member of invalid type
Path is mapped to a different path in project settings
Unresolved binding path when DataContext for data binding is specified, but symbol cannot be found
DeveiceFamily-specific view type name does not match generic type name
Grid element column/row index is out of grid definition range
Single grid row/column definition is redundant
Single-cell grid column/row span is redundant
Missing grid column/row setter for non-first child inside non-trivial grid
Element name reference not resolved to any of named elements in scope
Duplicate device family view
An quantifier after an achor is meaningless.
$bool1$ |= true
$bool1$ &= false
$bool1$ |= false;
$bool1$ &= true;
$T$ $x$ = false; if($bool1$) $x$ = true;
$T$ $x$ = true; if($bool1$) $x$ = false;
Array.CreateInstance(typeof($T$), $long$)
Array.CreateInstance(typeof($T$), $long$, $long2$)
$type$.IsInstanceOfType($expr$.GetType())
$type$.GetType()
$type$.IsInstanceOfType($type$)
$type$.IsAssignableFrom($expr$.GetType())
typeof($T$).IsAssignableFrom($expr$.GetType())
typeof($T$).IsInstanceOfType($expr$)
$type$.Equals($type2$)
Equals($type$,$type2$)
$seq$.Count() > 0
$seq$.Count() >= 1
$seq$.Count() == 0
$seq$.Count() <= 0
$seq$.Count() < 1
$seq$.Where($x$ => $expr$).Any()
$seq$.Where($x$ => $expr$).Count()
$seq$.Where($x$ => $expr$).First()
$seq$.Where($x$ => $expr$).FirstOrDefault()
$seq$.Where($x$ => $expr$).Last()
$seq$.Where($x$ => $expr$).LastOrDefault()
$seq$.Where($x$ => $expr$).Single()
$seq$.Where($x$ => $expr$).SingleOrDefault()
!$seq$.Any($args$) ? $expr$ : $expr2$
$seq$.SelectNotNull($x$ => $x$ as $T$)
$seq$.Where($x$ => $x$ is $T$).Select($y$ => $y$ as $T$)
$seq$.Where($x$ => $x$ is $T$).Select($y$ => ($T$)$y$)
$seq$.Select($x$ => $x$ as $T$).Where($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).Any($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).Any($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).Count($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).Count($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).LongCount($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).First($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).First($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).FirstOrDefault($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).FirstOrDefault($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).Last($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).Last($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).LastOrDefault($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).LastOrDefault($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).Single($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).Single($y$ => $y$ != null && $expr$)
$seq$.Select($x$ => $x$ as $T$).SingleOrDefault($y$ => $y$ != null)
$seq$.Select($x$ => $x$ as $T$).SingleOrDefault($y$ => $y$ != null && $expr$)
$seq$.Any($args$) ? $seq$.First($args$) : null
$expr$ && $seq$.Any($args$) ? $seq$.First($args$) : null
$seq$.Any($args$) ? $seq$.First($args$) : default($T$)
$expr$ && $seq$.Any($args$) ? $seq$.First($args$) : default($T$)
$seq$.Any($args$) ? $seq$.Last($args$) : null
$expr$ && $seq$.Any($args$) ? $seq$.Last($args$) : null
$seq$.Any($args$) ? $seq$.Last($args$) : default($T$)
$expr$ && $seq$.Any($args$) ? $seq$.Last($args$) : default($T$)
$seq$.Any($args$) ? $seq$.Single($args$) : null
$expr$ && $seq$.Any($args$) ? $seq$.Single($args$) : null
$seq$.Any($args$) ? $seq$.Single($args$) : default($T$)
$expr$ && $seq$.Any($args$) ? $seq$.Single($args$) : default($T$)
new List<$T$>($seq$).ToArray()
$seq$.ToList().ToArray()
$seq$.ToList().Count($x$ => $expr$)
$s1$.CompareTo($s2$)
$s$.IndexOf($sarg$)
$s$.IndexOf($sarg$, $iarg1$)
$s$.IndexOf($sarg$, $iarg1$, $iarg2$)
$s$.StartsWith($sarg$)
$s$.EndsWith($sarg$)
$s$.Compare($s1$, $s2$)
$string$.Compare($s1$, $s2$, false)
$string$.Compare($s1$, $s2$, true)
$s$.Compare($s1$, $i1$, $s2$, $i2$)
$s$.Compare($s1$, $i1$, $s2$, $i2$, false)
$s$.Compare($s1$, $i1$, $s2$, $i2$, true)
$s$.LastIndexOf($sarg$)
$s$.LastIndexOf($sarg$, $iarg1$)
$s$.LastIndexOf($sarg$, $iarg1$, $iarg2$)
(object)$x$ == null
$x$ as $type$ == null
$x$ as $type$ != null
Dim $x$ = False
If($bool1$) Then $x$ = True
Dim $x$ = True
If($bool1$) Then $x$ = False
Array.CreateInstance(GetType($T$), $long$)
Array.CreateInstance(GetType($T$), $long$, $long2$)
$type$.IsInstanceOfType($expr$.GetType())
$type$.GetType()
$type$.IsInstanceOfType($type$)
$type$.IsAssignableFrom($expr$.GetType())
GetType($T$).IsAssignableFrom($expr$.GetType())
GetType($T$).IsInstanceOfType($expr$)
$type$.Equals($type2$)
Equals($type$,$type2$)
$seq$.Count() > 0
$seq$.Count() >= 1
$seq$.Count() = 0
$seq$.Count() <= 0
$seq$.Count() < 1
$seq$.Where(Function ($x$) $expr$).Any()
$seq$.Where(Function ($x$) $expr$).Count()
$seq$.Where(Function ($x$) $expr$).First()
$seq$.Where(Function ($x$) $expr$).FirstOrDefault()
$seq$.Where(Function ($x$) $expr$).Last()
$seq$.Where(Function ($x$) $expr$).LastOrDefault()
$seq$.Where(Function ($x$) $expr$).Single()
$seq$.Where(Function ($x$) $expr$).SingleOrDefault()
!$seq$.Any(Function ($x$) Not $expr$)
!$seq$.All(Function ($x$) Not $expr$)
!$seq$.Any(Function ($x$) $expr$ IsNot $expr2$)
!$seq$.Any(Function ($x$) $expr$ <> $expr2$)
!$seq$.All(Function ($x$) $expr$ IsNot $expr2$)
!$seq$.All(Function ($x$) $expr$ <> $expr2$)
!$seq$.Any(Function ($x$) $expr$ Is $expr2$)
!$seq$.Any(Function ($x$) $expr$ = $expr2$)
!$seq$.All(Function ($x$) $expr$ Is $expr2$)
!$seq$.All(Function ($x$) $expr$ = $expr2$)
$seq$.Where(Function ($x$) TypeOf $x$ Is $T$).Select(Function ($y$) TryCast($y$, $T$))
$seq$.Where(Function ($x$) TypeOf $x$ Is $T$).Select(Function ($y$) DirectCast($y$, $T$))
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Where(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Any(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Any(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Count(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Count(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).First(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).First(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).FirstOrDefault(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).FirstOrDefault(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Last(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Last(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).LastOrDefault(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).LastOrDefault(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Single(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).Single(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).SingleOrDefault(Function ($y$) $y$ IsNot Nothing)
$seq$.Select(Function ($x$) TryCast($x$, $T$)).SingleOrDefault(Function ($y$) $y$ IsNot Nothing AndAlso $expr$)
If ($seq$.Any($args$), $seq$.First($args$), Nothing)
If ($seq$.Any($args$), $seq$.Last($args$), Nothing)
If ($seq$.Any($args$), $seq$.Single($args$), Nothing)
$seq$.ToList().ToArray()
$seq$.ToList().Count
$enumerable$.FirstOrDefault().$method$(...)
$s1$.CompareTo($s2$)
$s$.IndexOf($sarg$)
$s$.IndexOf($sarg$, $iarg1$)
$s$.IndexOf($sarg$, $iarg1$, $iarg2$)
$s$.StartsWith($sarg$)
$s$.EndsWith($sarg$)
$s$.Compare($s1$, $s2$)
$string$.Compare($s1$, $s2$, false)
$string$.Compare($s1$, $s2$, true)
$s$.Compare($s1$, $i1$, $s2$, $i2$)
$s$.Compare($s1$, $i1$, $s2$, $i2$, false)
$s$.Compare($s1$, $i1$, $s2$, $i2$, true)
$s$.LastIndexOf($sarg$)
$s$.LastIndexOf($sarg$, $iarg1$)
$s$.LastIndexOf($sarg$, $iarg1$, $iarg2$)
<([)img(]) $attrs$>
<([)center(]) $attrs$>$content$</center>
<([)html(]) $attr1$></html>
<([)html(]) $attr1$><head $attr2$>$cont$</head></html>
<([)html(]) $attr1$><body $attr2$>$cont$</body></html>
<([)head(]) $attr1$>$cont$</head>
<title ...></title>
<([)script(]) $a1$>$c1$</script>
<([)script(]) type="$v1$" $a1$>$c1$</script>
<([)script(]) $a1$>$c1$
<([)script(]) $a1$>$c1$
<([)script(]) src="..." ...>$content$</script>
<([)script(]) $a1$>$c1$</script>$c2$<script src="$v1$" $a2$></script>
<ul $attr$>$cont1$([)$cont2$(])$cont3$</ul>
<ol $attr$>$cont1$([)$cont2$(])$cont3$</ol>
<dl $attr$>$cont1$([)$cont2$(])$cont3$</dl>
<$tag$ ([)clear=all(]) $a1$>
<$tag$ ([)clear="$val$"(]) $a1$>
[$test$] private void $name$($args$) { $stmt$ }
[$test$] public void $name$($args$) { $stmt$ }
[$test$] public $type$ $name$($args$) { $stmt$ }
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction
Conversion obsolete construction