C#:
1. Naming Conventions:
a) Pascal Case: Use this style when naming a class, record, or structs. The interface also uses this convention with the prefix of ‘I’. Public members such as fields, properties, events, methods, and local functions also use pascal case.
b) Camel Case: Use this style for method parameters and when naming private or internal fields prefix with ‘_’. If the private or internal field is static us the prefix ‘s_’ instead. If the private or internal field is static thread us the prefix ‘t_’ instead.
2) Layout Convention:
The layout convention is meant to have the code structure in a specific way. Follow these guidelines:
• 4 spaces or a tab is used for indentations
• 1 statement per line
• 1 declaration per line
• Continuation lines require indentations
• 1 empty line between method definitions and property definitions
• Use parentheses to make clauses in an expression apparent
• Region can be used to group separate sections
• Break multiple conditions in an if-statement into several lines instead of one long line
Tip: If you have to scroll in either direction and you remain in the same function or method, it needs to be refactored and broken into smaller parts.
3) Commenting Convention:
Adding comments to the code should provide insights into parts that are not self-explanatory or has a very specific intention not obvious to the reader. Some guidelines to follow for creating comments:
• Comment on a separate line, not in-line
• Begin with a capital letter
• End with a period (.)
• Have a space between the // and the comment
• Don’t created blocks around the comment
All public members require the necessary XML comments and headers, it is also suggested for the rest of the members.
4) Language Guidelines:
String
Use the appropriate string concatenation functions, don’t use ‘+’:
var firstname = $"My name is {user.FirstName}";
Use the StringBuilder class when you need to append strings in a loop or working with large amounts of string.
Var (Implicitly typed)
Use the ‘var’ for local variables when the right-hand side assignment is clear and obvious, or when implicit typing in a loop is used (for-loop).
Don’t use ‘var’ when:
• The assignment is not clear
• The assignment relies on a function
• You can use dynamic for run-time inference
• In a foreach-loop
• You can use the ‘let’ keyword for scope limiting
Note: The keyword ‘var’ needs to be taken up with the programmer on their usage and understanding thereof. Consistency is more important.
5) Array:
This section will provide some notes around the initialization of an array object. When working with arrays, use the concise syntax:
string[] vowels = {"a", "e", "i", "o", "u"};
If you need to specify the array size, or you need to instantiate it, user ‘var’:
var vowels1 = new string[] {"a", "e", "i", "o", "u"};
var vowels2 = new string[5];
6) Delegates:
Use Func<> or Action<> instead of delegate types. Keep to the concise syntax where possible:
public static Action<string> ActionExample1 = x => Console.WriteLine($"x is: {x}");
public static Func<int, int, int> FuncExample2 = (x,y) => x + y;
class DelClass{
public delegate void Del(string message);
public static void DelMethod(string str){
Console.WriteLine("DelMethod argument: {0}", str);
}
}
7) Try-Catch and Using:
The try-catch is used for most of the exception handling. Use the using-statement instead of a try-finally. The using statement can also be used in a shorth-hand version:
using Font font3 = new Font("Arial", 10.0f);
byte charset3 = font3.GdiCharSet;
8) && and ||:
Use the double ampersand (&&) or double pipe character (||) instead of the singles.
9) New:
var instance1 = new ExampleClass();
ExampleClass instance2 = new();
Use the initializers of a class before using the properties:
var instance3 = new ExampleClass { Name = "Desktop", ID = 37414, Location = "Redmomd", Age = 2.3 };
10) Event Handling:
Use the lambda expression when defining an event handler that is permanent:
public Form2()
{
this.Click += (s,e) =>
{
MessageBox.Show(
((MouseEventArgs)e).Location.ToString());
};
}
Else, use the full notation:
public Form1()
{
this.Click += new EventHandler(Form1_Click);
}
void Form1_Click(object? sender, EventArgs e)
{
MessageBox.Show((MouseEventArgs)e).Location.ToString());
}
11) Static Members
Call all the static members by using the class name dot member (ClassName.StaticMethod). Don’t use a derived class name.
12) LINQ
Follow the guidelines on LINQ expressions:
• Use descriptive names for the variables
• Use Pascal casing
• Rename any ambiguous properties that are returned
• Use implicit typing in the declaration
• Use the where-clause before other clauses
• Use multiple from-clauses instead of a join
13) Other Notes
Here are some guidelines on programming in general.
Rule of thumb:
• A function has maximum 50 lines of code
• A class has maximum of 700 lines of code
• Add a space between operators
• Opening and closing parenthesis are present with keywords
• Function and method names should be meaningful
• A function or method has a single responsibility
• Do not hardcode string or number (use a separate file)
• String comparisons are in upper- or lower case
• Use enums instead of strings or numbers where applicable
• Use constants for the logger
• Log messages should be of value
• Maximum number of parameters is 5
• Use a class or structure for more parameters
• Collections should be empty, not null
• Use Any() instead of Count()
• Use foreach instead of for-loop
• Use interfaces instead of concrete classes for collections
• Files and connections should be closed in a finally-statement
• Catch specific exceptions only, not generic ones
• Be careful of swallowing exceptions
