The meziantou.analyzer's discuss from meziantou

Suggest replacing extension methods by existing methods for `List<T>`

Enumerable.FirstOrDefault => Find
Enumerable.IndexOf => FindIndexOf
Enumerable.LastIndexOf => FindLastIndexOf

Replace Enum.Value.ToString with nameof(Enum.Value)

New rule: Method overrides should not change parameter defaults

public class Foo
{
  public virtual void Write(int i = 42)
  {
    Console.WriteLine(i);
  }
}

public class Bar : Foo
{
  public override void Write(int i = 5) // Noncompliant
  {
    Console.WriteLine(i);
  }
}

New rule: "params" should be used on overrides

class Base
{
  public virtual void Method(params int[] numbers) => { };
}

class Derived : Base
{
  public override void Method(int[] numbers) // Error "params" is missing
  {
  }
}

New Rule: Call Where before OrderBy

enumerable.Where(...).OrderBy(...) // compliant
enumerable.OrderBy(...).Where(...) // non-compliant

Suggest replacing string.GetHashCode with StringComparer.Ordinal.GetHashCode

New rule: Attribute, EventArgs, and Exception type names should end with the type being extended

class SampleAttr : Attribute  // Noncompliant
{
}

class Foo : Exception // Noncompliant
{
}

New rule: Exceptions should not be thrown in finally blocks

Type that contains IDisposable members should implement IDisposable

MA0001 should detect more methods

Enumerable.Contains<string>
Enumerable.Distinct<string>
Enumerable.Except<string>
Enumerable.GroupBy<string>
Enumerable.GroupJoin<string>
Enumerable.Intersect<string>
Enumerable.Join<string>
Enumerable.OrderBy<string>
Enumerable.OrderByDescending<string>
Enumerable.SequenceEqual<string>
Enumerable.ToDictionary<string>
Enumerable.ToLookup<string>
Enumerable.Union<string>

Make class static fix produces invalid code

partial class A {}
partial static class A {} // Invalid because partial must be just before class

New Rule: Override equals and operator equals on value types

For performance reasons, you should override Equals and GetHashCode on value types (struct).

https://blog.martindoms.com/2011/01/03/c-tip-override-equals-on-value-types-for-better-performance

MA0032 should not report when there is no overload with a CancellationToken

class Test
{
    public static void A()
    {
        Sample(""); // reported here
    }

    public static void Sample(string a) { }
    public static void Sample(string a, string b) { }
}

New rule: StringBuilder.AppendJoin

sb.Append(string.Join(',', new [] { "a", "b" }));

Should be:

sb.AppendJoin(',', new [] { "a", "b" });

Please fix typo in title

pratices > practices

New rule: Obsolete attributes should include explanations

EqualityComparer<string>.Default => StringComparer.Ordinal

MA0046 should not report when the delegate match the event signature

public delegate void DataReceivedEventHandler(object sender, System.Diagnostics.DataReceivedEventArgs e);
public event System.Diagnostics.DataReceivedEventHandler ErrorDataReceived { add { } remove { } }

New rule: "Equals" and the comparison operators should be overridden when implementing "IComparable"

Generate a page that list all rules

It should include a table with the following columns:

Rule id
Rule name
Severity
Category
Has code fix

sealed internal class if possible

Suggest to seal internal class when possible (add an option to seal public class)

New rule: The length returned from Stream.Read should be used

public void DoSomething(string fileName)
{
  using (var stream = File.Open(fileName, FileMode.Open))
  {
    var result = new byte[stream.Length];
    stream.Read(result, 0, (int)stream.Length); // Noncompliant, should be readLength = stream.Read(...) and readLength should be used
  }
}

New rule: finally/else block should not be empty

Analyzer 'Meziantou.Analyzer.Rules.ReturnTaskFromResultInsteadOfReturningNullAnalyzer' threw an exception of type 'System.NullReferenceException'

SyntaxNode: ref coll.FindAsync(filter) [LocalFunctionStatementSyntax]@[6688..6714) (172,12)-(172,38)

System.NullReferenceException: Object reference not set to an instance of an object.
   at Meziantou.Analyzer.Rules.ReturnTaskFromResultInsteadOfReturningNullAnalyzer.IsTaskType(Compilation compilation, ITypeSymbol typeSyntax)
   at Meziantou.Analyzer.Rules.ReturnTaskFromResultInsteadOfReturningNullAnalyzer.AnalyzeLocalFunction(SyntaxNodeAnalysisContext context)
   at Microsoft.CodeAnalysis.Diagnostics.AnalyzerExecutor.<>c__44`1.<ExecuteSyntaxNodeAction>b__44_0(ValueTuple`2 data)
   at Microsoft.CodeAnalysis.Diagnostics.AnalyzerExecutor.ExecuteAndCatchIfThrows_NoLock[TArg](DiagnosticAnalyzer analyzer, Action`1 analyze, TArg argument, Nullable`1 info)

New rule: Parameters with "[DefaultParameterValue]" attributes should also be marked "[Optional]"

New rule: Local variables should not shadow class fields

It avoid problems such as

public class Sample
{
    private string field;
    public Sample(string field)
    {
        field = field; // Assign parameter instead of field
    }
}

BTW, it should also detect assignment of the same variable

var a = 10;
a = a; // Error

Detect usage of System.Net.Http.HttpClientHandler.ServerCertificateCustomValidationCallback

New rule: destructor should not be used

Destructors allow to release native resources. You use wrap all native handles in SafeHandle. Thus, you don't need to use a destructor.

New rule: "NaN" should not be used in comparisons

if (a == double.NaN) // always return false, should be double.IsNaN(a)

New rule: Remove useless binary comparisons with bool

bool condition;
if (condition == true) // should be if (condition)
if (condition == false) // should be if (!condition)

New rule: Non-flags enums should not be marked with "FlagsAttribute"

    [FlagsAttribute] // Noncompliant, Orange is neither a power of two, nor a combination of any of the defined values
    public enum Color
    {
        None    = 0,
        Red     = 1,
        Orange  = 3, 
        Yellow  = 4,
    }

New rule: Destructors should not throw exceptions

New rule: Replace new Guid() by Guid.Empty

New rule: Constructors should only call non-overridable methods

Calling an overridable method from a constructor could result in failures or strange behaviors when instantiating a subclass which overrides the method.

public class Foo
{
  public Foo()
  {
    VirtualMethod();  // Noncompliant
  }

  public virtual void VirtualMethod()
  {
    ...
  }
}

Skip the validation if the class is sealed

New rule: Replace Select(o => (Sample)o) by Cast<Sample>()

details.Select(o => (Sample)o);
details.Cast<Sample>();

New rule: Events should have proper arguments

The sender must not be null if it's an instance event
The sender must be null if it's a static event
Args must not be null (use EventArgs.Empty)

New rule: Replace string.StartsWith("a") with string.StartsWith('a')

StartsWith and EndsWith, Contains
The overload with char is not available in .NET Framework

New rule: Use task result instead of task itself

interface Repository 
{
    Task FindProduct(string name);
}

public async Task<int> GetId(string name)
{
    await Task.Yield(); //Some stuff

    var product = _repository.FindProduct(name);

    return product.Id;
}

Should be

public async Task<int> GetId(string name)
{
    await Task.Yield(); //Some stuff

    var product = await _repository.FindProduct(name);

    return product.Id; // Or product.Result.Id
}

This one is hard to see/debug 😖😭😆

`new System.EventArgs()` => `EventArgs.Empty`

Suggest using StringComparison in JObject.Property

MA0016 should not report for override or interface implementation

New rule: Avoid locking on publicly accessible instance

public void Foo()
{
    lock (this) // Error
    {
    }
}

public void Foo()
{
    lock (typeof(Bar)) // Error
    {
    }
}

class Bar
{
    public object public_field;

    public void Foo()
    {
        lock (public_field) // Error
        {
        }
    }
}

New rule: Non-constant static fields should not be visible

Ensure the inner exception is set when throwing an exception in a catch block

This may be an improvement for the current rule: DoNotRemoveOriginalExceptionFromThrowStatement

try
{
}
catch(Exception ex)
{
    throw new Exception(); // Should be throw new Exception("", ex);
}

New rule: ToString should not return null

Analyzer 'Meziantou.Analyzer.Rules.DoNotCallVirtualMethodInConstructorAnalyzer' threw an exception of type 'System.InvalidOperationException' with message 'Sequence contains more than one element'.

Analyzer 'Meziantou.Analyzer.Rules.DoNotCallVirtualMethodInConstructorAnalyzer' threw the following exception:'
Exception occurred with following context:
Compilation: xxx
SyntaxTree: D:\xxx\QueryResultSchema.cs
SyntaxNode: public QueryResultSchema(string ... [ConstructorDeclarationSyntax]@[480..866) (19,8)-(29,9)
System.InvalidOperationException: Sequence contains more than one element
   at System.Linq.Enumerable.SingleOrDefault[TSource](IEnumerable`1 source)
   at Meziantou.Analyzer.Rules.DoNotCallVirtualMethodInConstructorAnalyzer.AnalyzeConstructorSyntax(SyntaxNodeAnalysisContext context)
   at Microsoft.CodeAnalysis.Diagnostics.AnalyzerExecutor.<>c__44`1.<ExecuteSyntaxNodeAction>b__44_0(ValueTuple`2 data)
   at Microsoft.CodeAnalysis.Diagnostics.AnalyzerExecutor.ExecuteAndCatchIfThrows_NoLock[TArg](DiagnosticAnalyzer analyzer, Action`1 analyze, TArg argument, Nullable`1 info)-----'.
--

New rule: Anonymous delegates should not be used to unsubscribe from Events

sample.SampleEvent -= (obj, args) => { }; // error

New rule: `ConstructorArgument` parameters should exist in constructors

using System;

namespace myLibrary
{
  public class MyExtension : MarkupExtension
  {
    public MyExtension() { }

    public MyExtension(object value1)
    {
      Value1 = value1;
    }

    [ConstructorArgument("value2")] // Error, value2 is not a parameter of the constructor
    public object Value1 { get; set; }
  }
}

meziantou / meziantou.analyzer Goto Github PK

meziantou.analyzer's Issues

Recommend Projects

Recommend Topics

Recommend Org