Important Tips To Write Clean Code In C#

I remember those days when I started my career in programming. I struggled to write a piece of code and who cared for the coding standards at that time. As time went on, I was getting some command over programming and was able to think of particular scenarios to solve problems. From the start of my career until today, I have found a continity, and that is learning. At that stage, I was learning to manage basic things and now, I am learning to handle the problems. So, in life, learning is a never-ending process. Everyday, we learn something, whether it's from reading articles, watching videos, or by our own mistakes or success in this programming environment.

As per my experience, we should not write our code like a layman. We should follow some coding standard to write clean, reusable, readable, and maintainable code.

I don't know exactly how many people are following coding standards. Even I was not perfectly following the coding standards. However, here are some of the coding guidelines that I used to follow.

To develop reusable, reliable, readable, well-structured, and maintainable application, we must follow the coding standard. There are several coding practices in the software industry. None of them are good or bad but the main thing is that whatever approach we follow, we should make sure that everyone should follow the same standard.

Code Smell

Code Smell is a technical word used to describe the quality of code - how a programmer writes this code.

Code smell is often a word used to describe code that you don't like. In that sense, it is synonymous to ugly, dirty, unclean,repeated, etc. Even though these types of code work perfectly but are hard to handle and maintain.There are a few reasons why our code smells.

1. Duplicated Code
2. Methods too big
3. Classes with too many instance variables
4. Classes with too much code
5. Lazy class / freeloader

Now, let's see how we can write clean code and avoid these smells in the programme. Let's continue our discussion from the basic coding standard, that is, on Naming Convention.

While we are coding, we shall focus on our naming standard. There are 2 main types of naming standards that we are using these days.

• Pascal casing
  A word with the first letter capitalized, and the first letter of each subsequent word-part capitalized.
  Ex - CustomerName, EmployeeDetails, Salary,etc.
  
• Camel casing
  A word with the first letter lowercase, and the first letter of each subsequent word-part capitalized.
  EX-customerName, employeeDetails, salary

Let's see where we will use which type of casing.

Always use class name and method name in Pascel casing.

public class EmployeeDetails  
{  
    .......  
}

Now, this is how we declare methods inside a class.

public class EmployeeDetails  
{  
    public void GetEmployeeSalary()  
    {  
        ---------------           
    }  
}  

Always use variables and parameter names in Camel casing.

public class EmployeeDetails  
{  
    private int totalSalary = 0;  
    public void GetEmployeeSalary( int employeeId)  
    {  
        int amount = 30000;
    }
}

Always use letter "I" as prefix with name of interface. After letter I, use Pascal case.

using System;
namespace cleanacode  
{  
    interface IEmployee  
    {  
        void GetDetails();  
    }  
}

Use meaningful variables and method names while coding. These names should be self descriptive.

For this, I have created two samples of code. Check the first piece of code. Do you think this code will work effectively for maintainance and code review purposes?

public class EmployeeDetails  
{  
    public void GetSalary(int x, int p)  
    {  
        int z = x + p;
    }  
}

When a new developer checks this code, what he will understand? Now, check the same piece of code with a well organized and good coding standard.

public class EmployeeDetails  
{
    public void GetEmployeeSalary( int salary, int bonus)  
    {  
        int totalSalary = salary + bonus;
    }
}

Always rename the variables with a descriptive name. Don't use unnecessary name for any variable so that it will be easy to maintain.

Whenever you are writting any method, always try to write the purpose of the method. Use summary or normal comments to specify the purpose of methods with the short description of parameters.

Here, in this example, we will show how to use this.

So, you can use summary by writing three forward slashes in VS.

public class EmployeeDetails  
{  
    /// <summary>  
    /// To calculate total salary.  
    /// </summary>  
    /// <param name="salary"></param>  
    /// <param name="bonus"></param>  

    public void GetEmployeeSalary( int salary, int bonus)  
    {  
        int totalSalary = salary + bonus;
    }
}  

Don't use long method in the project. If by any chance you are using the long method, please use region to make it easy to understand.

/// <summary>  
/// To calculate total salary.  
/// </summary>  
/// <param name="userId"></param>  
/// <param name="bonus"></param>  
/// <param name="noOfDays"></param>  
/// <param name="tax"></param>  
/// <param name="deduction"></param>  

public void GetEmployeeSalary(string userId,int bonus,int noOfDays,float tax,float deduction)  
{  
    float bsal;  
    float hra;  
    float da;  
    float pf;  
    float extra;  
    float total;  

    #region BasicSalary  
    float monthlySalary = EmployeeDetails.GetSalary("UI54");  
    float basicSalary = monthlySalary + bonus;  
    #endregion  

    #region Calculate PF  
    pf= 15 * basicSalary / 100;  
    #endregion  
    #region Calculate HRA  
    hra= 20 * basicSalary / 100;  
    #endregion  
    #region Extra  
    extra = 2 * basicSalary / 100;  
    #endregion  
    #region Netsalary after deduction  
    total = basicSalary - (pf + hra + extra);  
    #endregion
}  
/// <summary>  
/// getting user salary  
/// </summary>  
/// <param name="userId"></param>  
/// <returns></returns>  
public static int GetSalary(string userId)  
{  
    if (userId=="UI100")  
    {  
        return 60000;  
    }  
    else  
    {  
        return 45000;  
    }
}