Click here to Skip to main content
Click here to Skip to main content

Tagged as

.NET Coding Best Practices

, 20 Jan 2010 CPOL
Rate this:
Please Sign up or sign in to vote.
.NET Coding Best Practices - Vinayak's thumb rulesDo not hard code strings/ numerics. Instead of that use constants as shown below.Bad practice int Count; Count = 100; if( Count == 0 ) { // DO something… }Good practice int Count; Count = 100; private...
.NET Coding Best Practices - Vinayak's thumb rules
     
  1. Do not hard code strings/ numerics. Instead of that use constants as shown below.
     
    Bad practice
     
     int Count;
     Count = 100;
     if(  Count  ==  0 )
     {
      // DO something…
     }
    
     
    Good practice
     
     int Count;
     Count = 100;
     private static const int ZERO  =  0;
     if(  Count  ==  ZERO )
      {
        // DO something…
      }
    
     
  2. For string comparison - Use String. Empty instead of “”
     
  3. By default keep the scope of member variables to ‘private’, based on the needs expand the scope either to protected or public or internal.
     

    1. Other advantage of making the scope private by default is that during XMLSerilaization, by default it will serialize all the public members.
     
  4. When we have to manipulate the strings inside a loop, use StringBuilder instead of string as shown below.
     
    Bad practice
     
     String  temp = String.Empty;
     for( int I = 0 ; I<= 100; i++)
     {
       Temp += i.ToString();
     }
    
     
    Good practice
     
      StringBuilder sb = new StringBuilder();
      for ( int I = 0 ; I<= 100; i++)
       {
         sb.Append(i.ToString());
        }
    
     
  5. Prefer Arrays over Collections for simple operations.
     
  6. Prefer Generic Collections over ArrayList
     
  7. Prefer Generic Dictionaries over HashTable *.
     
  8. Prefer StringCollections and StringDictionaries for String manipulations and storage.
     
  9. Use the appropriate data types.
     
    For ex: if you want to check for any status, prefer bool rather than int.
     
    Bad practice
     
      int Check = 0;
      if(Check == 0)
       {
         // DO something
        }
    
     
    Good practice
     
      bool Check = false;
      if(!Check)
        {
          // DO something
        }
    
     
  10. Use ‘as’ operator for type casting and before using that resultant value check for null.
     
    class A
     {
     }
     
    class B : A
     {
     }
     
    B objB = new B();
    A objA1  = (A) objB;
    A objA 2 = objB as A;
     
    if( objA2 != null)
    {
     //Do something
    }
    
     
  11. For WCF proxy creation, use the using statement
     
     using(Cerate the proxy)
      {
        //Do the required operation
       }
    
     
  12. Follow ‘Acquire late, release early’ rule for expensive resources such as Connection, File etc.
     
    For ex : if you want to make use of SqlConnection Object for any data operations, create the instance at the method level rather than at the class level.
     
     class MyData
      {
          public MyData()
            {
            }
          public List<Customer> GetAllCustomer()
            {
            using(SqlConnection objConnection = new SqlConnection(“Connection string”))
              {
    	        //Do the operation and get the required data..
              }
            }   
     }
    
     
    If you want to create the SqlConnection instance at the class level, ensure that you are implementing the IDisposable for the class and doing the cleanup of SqlConnection instance at the Dispose();
     
     class MyData : IDisposable
      {
         SqlConnection objConnection = default(SqlCOnnection);
         public MyData(){
           objConnection = new SqlCOnnection(“Connection string”);
         }
         public List<Customer> GetAllCustomer(){
           // By using objConnection get the required data
         }
         public void Dispose(){
          // Do the cleanup of SqlCOnnection
          if( objConnection != null ){
             if( objConnection.State == ConnectionState.Open){
     	    objConnection.Close();
             }
          }
        }
     }
    
     
  13. If you do not want anybody to extend your class functionalities, make it ‘sealed’ to get the inlining and compile time benefits
     
  14. Avoid declaring the ‘destructor’ for every class. This will increase the life time of the class which un necessarily makes them long lived
     
  15. Prefer using Thread Pool over manual threading.
     
  16. Do not make any calls to a method from the loop.
     
    For ex :
     
    Bad practice
     
    for( int i = 0; i<= 100; i++)
    {
    	Calculate(i);
    }
    
     
    Good practice
     
    for( int i = 0; i<= 100; i++)
    {
      //Inline the body of Calculate.
    }
    
     
  17. Do not handle exceptions inside a loop, rather handle looping logic inside try/catch
     
    For ex:
     
    Bad practice
     
    for(int i = 0 ; i<= 100; i++){
       try{
       }
       catch(Exception ex){
          throw ex;
       }
    }
    
     
    Good practice
     
      try{
        for(int i = 0 ; i<= 100; i++){
        }
      }
      catch(Exception ex){
       throw ex;
      }
    
     
  18. Do not handle application logic by using Exception.
     
    For ex :
     
    Bad practice
     
     try{
       int  x,y,z;
       x = 0;
       y = 10;
       z = y/x;
      }
     catch(DevideByZeroException ex){
       throw ex;
     }
    
     
    Good practice
     
      private static const int ZERO  =  0; 
      try{
        int x,y,z;
        x = 0;
        y = 10;
        if( x != ZERO){
          z = y/x;
        }
       }
      catch(Exception ex){
       }
    
     
  19. Prefer for/while loop over foreach
     
  20. For communication between the layers, prefer Data Transfer objects over DataSet/DataTables.
I hope this will help you all to improve the code quality!!
 
Happy programming
 
Regards,
-Vinayak

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Vinayaka Krishna Shenoy
Architect MindTree Ltd
India India
Motivated achiever who guides organizations in applying technology to business settings, provides added value, and creates project deliverables in a timely manner. An experienced Technical Consultant, have successfully led large project teams of more than 20 people from requirements gathering to implementation and support using C#, .NET ,ADO.NET, ADO.NET Entity Framework,ASP.NET,ASP.NET MVC, WCF and SQL Server.

Comments and Discussions

 
GeneralMy vote of 3 PinmemberChamila Ranasinghe15-Nov-12 18:39 
GeneralSome good ideas... PinmemberS. Töpfer25-Jan-10 23:05 
General[My vote of 2] Comment on the article Pinmemberjstemper21-Jan-10 7:27 
General#1, #2, #9, #15, #17, #18, #19 Pinmembersupercat920-Jan-10 7:05 
GeneralIf these are considered best practices... Pinmemberbhogan22-Dec-09 8:14 
GeneralMost are good tips... PinmemberSilic0re0922-Dec-09 4:44 
I agree with most of your tips, but there are a few that I have some problems with...
 
1. Using constants...
 
Will ZERO ever be anything different than 0? If not, then why use a constant expression rather than just the number? The problem here is that if you use a more generic constant like LOOPMIN, you can't change just one of the loops that uses that, they will all change. I think the better practice is instead of declaring things that loop through arrays as:
int[] myArray = new int[100];
 
for (int i = 0; i < 100; i++)
     myArray[i] = 1;
 
You want to do something like this:
int[] myArray = new int[100];
 
for (int i = myArray.GetLowerBound(); i < myArray.GetUpperBound(); i++)
     myArray[i] = 1;
 
That way you can change the dimensions of the array without changing the iteration logic. Alternatively you can use something like:
 
int[] myArray = new int[100];
 
foreach (int v in myArray)
     v = 1;
 
14. Avoid declaring a destructor
Destructors properly implemented are extremely useful, and you should not rely on the GC to manage your object lifetime 100%. There are a lot of things you can do in a class that will make the GC hold references to your object, even after you are finished using them or they go out of scope. I would venture to say that your class should implement IDisposable and always finalize manually, so you can remove things like event handlers (they are not automatically removed).
 
15. Do not make calls in a method loop
There is a little bit of truth to this, but for complicated calculation routines you should break apart your loop into functions. Its difficult from a maintainability standpoint to have a single loop that has 1000 (as an example, even 100 lines is excessive) lines of logic inside the loop. Loops should be short, and you should easily be able to see what they do. If you have a function that can be inlined manually in short code, by all means do it. But complicated routines should be broken out. I live by the mantra that if your function spans 2 pages of printed text, it should be refactored.
 
17. Do not handle exceptions in a loop
There are times that this is unavoidable. Your example would stop processing further items in the array if it excepted on a single element. Sometimes you want to ignore error elements and continue processing the rest of the collection. The only way to do this is to put the exception logic inside the loop. What you want to do however, is to avoid throwing exceptions as much as possible, handling them isn't as expensive as throwing them.
GeneralRe: Most are good tips... Pinmemberkornman0012-Jan-10 6:20 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.150302.1 | Last Updated 20 Jan 2010
Article Copyright 2009 by Vinayaka Krishna Shenoy
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid