Low level issues

//Example For Issue Occurrence:

public abstract class Book
{
public Book()
{
}
}

//CODE FIX:

public abstract class Book
{
protected Book()
{
}
}

//To fix a violation of this rule, either make the constructor protected or do not declare the type as abstract.

//C# allows elements to be defined without an access modifier. Depending upon the type of element, C# will automatically
//assign an access level to the element in this case. This rule requires an access modifier to be explicitly defined for
//every element.This removes the need for the reader to make assumptions about the code, improving the readability of the code.

public void DoThis()
{
var source = new int[] { 100, 102, 104 };
Enumerable.Any(source, x => x > 100);
}

//CODE FIX:

public void DoThis()
{
var source = new int[] { 100, 102, 104 };
source.Any(x => x > 100);
}

var minutes = 24 * 60;

//CODE FIX:

var minutes = 1440;

//If the expression is made up of literal values an additional computation cycle is introduced to calculate the final value hence it is better to use the //final value directly thereby reducing the computational cost of the given expression.

//Example For Issue Occurrence:

var test = new[] { 1, 2, 3, 4};

//To fix a violation of this rule, remove any whitespace between the new keyword and the opening array bracket.

private System.DateTime d = new System.DateTime(1);

//CODE FIX:

private readonly System.DateTime d = new System.DateTime(1);

//To fix a violation of this rule, add the capital letter I to the front of the interface name.

//Example For Issue Occurrence:
public async Task DoThis(int x, int y)
{
throw new ArgumentException(“message”, “c”);
}

//CODE FIX:
public async Task DoThis(int x, int y)
{
throw new ArgumentException(“message”, “x”);
}

void Class1(string example)
{
var test = “example”;
}

//CODE FIX:

void Class1(string example)
{
var test = nameof(example);
}

//To fix an instance of this violation, specify an access modifier for the partial element.

//To make the code easier to read and more consistent, standardizing the ordering of these keywords is helpful, so that a
//protected internal element will always be described as such, and never as internal protected. This can help to reduce
//confusion about whether these access levels are indeed the same.

var test = a.Where(item => filter(item));

//CODE FIX:

var test = a.Where(filter);

//In the above example the method can be directly passed as the condition and thereby an unnecessary layer of introducing the simple lambda expression //can be avoided. This in turn will reduce the computational cost of the entire expression.

//Example For Issue Occurrence:

if (true)
{
//some statement (not a comment)
}
else
{
}

//CODE FIX:

if (true)
{
//some statement (not a comment)
}

//Example For Issue Occurrence:

var a = new int[10];
var f = a.Where(item => item > 10).First();

//CODE FIX:

var a = new int[10];
var f = a.First(item => item > 10)

//Example For Issue Occurrence:

private bool CheckAll()
{
if ( ….)
{
return true;
}
return false;
}

//CODE FIX:

private bool CheckAll()
{
return (your_condition);
}

List M()
{
throw new NotImplementedException();
}

//CODE FIX:

ICollection M()
{
throw new NotImplementedException();
}

void Test()
{
var t = new MemoryStream();
//other statements
}

//CODE FIX:

void Test()
{
using (var t = new MemoryStream())
{
//other statements
}
}

bool foo= true;
if(foo!=true)
{
//
}

//CODE FIX:

bool foo= true;
if(!foo)
{
//
}

public static async Task Foo()
{
return await Task.FromResult(false);
}

//CODE FIX:

public static async Task FooAsync()
{
return await Task.FromResult(false);
}

//Example For Issue Occurrence:

var t = new Test() { X = 1 };

//CODE FIX:

var t = new Test { X = 1 };

string x = s.ToString();

//CODE FIX:

string x = s;

//Example For Issue Occurrence:

public class MyClass
{
private int field;

public MyClass() { }

private void MyMethod()
{
field = 1;
}
}

//CODE FIX:

public class MyClass
{
private int field;

public MyClass() { }
}

//Example For Issue Occurrence:

public static void Method1(string name)
{
}

//CODE FIX:

public static void Method1()
{
}

public override string ToString()
{
return this.Name;
}

//CODE FIX:

public override string ToString() => this.Name;

//Example For Issue Occurrence:

int[] ints = new int[100000];
int j;
for (int i = 0; i < 100000; i++) { j = ints[i]; } //CODE FIX: int[] ints = new int[100000]; int j; foreach(int i in ints) { j = i; }

var x = items.Select(delegate (object f)
{
return f.ToString();
});

//CODE FIX:

var x = items.Select((object f) =>
{
return f.ToString();
});

Code c;
c = new Code();
c.Language = “CSharp”;
c.Loc = 1105;

//CODE FIX:

Code c;
c = new Code()
{
Language = “CSharp”,
Loc = 1105
};

public void Method(string value)
{
if (null == value)
{
//some code
}
}

//CODE FIX:

public void Method(string value)
{
if (value == null)
{
//some code
}
}

//Example For Issue Occurrence:

string s = “”;

//CODE FIX:

string s = string.Empty;

decimal pricePerOunce = 17.36m;
string s = string.Format(“The current price is {0} per ounce.”,
pricePerOunce);

//CODE FIX:

decimal pricePerOunce = 17.36m;
string s = $”The current price is {pricePerOunce} per ounce.”;

//Example For Issue Occurrence:

var result = true;
if (result)
return 1;
else
return 2;

//CODE FIX:

var result = true;
return result? 1 : 2;

//Example For Issue Occurrence:

var str = “c:TestFolder”;

//CODE FIX:

var str = @”c:TestFolder”;