Little Coding Tricks

In this article we will learn little tricks in coding that will make our development faster and our code better.

String.Compare

There are instances when we need to check if a particular string is equal to another string and this is what we usually write in our code:

 if (string1==string2)

    {

        //do stuff here

    }

    if (string.Compare(string1.Trim(), string2.Trim(), true))

    // the last parameter decides if you want to compare case or not.

    {

        // do stuff here

    }

Also remember 
to trim your strings before comparison as there are instances where the user 
enters data with a space at the end or beginning and it takes a long to find out 
that the space in the string was the culprit for comparison. Please also look at 
String.Equals() docmentation.

using Statements

How many times 
have we used made that mess at the dining table and left that empty plates to be 
picked up by the maid, only if you could have picked up that plate and kept it 
in the kitchen yourself that would save the maids time to put that in the 
garbage bag outside. Thank goodness we have using statement to help us while 
writing our code, it ensures that the object is disposed upon its use and you do 
not need worry about that any more.
Example : 

using (Font font3 = new Font("Verdana", 7.0f),font4 = new Font("Calibri", 8.0f)){

// Use font3 and font4.}

In the above example we when the code execution crosses the end braces the instance of object font3 and font4 are disposed.

Have you ever thought what will happen in the case below, why don't you try this and figure out yourself? Font font2 = new Font("Verdana", 7.0f);

using (font2) // not recommended, but still let's do it

    { // use font2

    {

float f = font2.GetHeight(); // what will happen here?

 

Case 1 : Or what will happen in the below cases :
using
(Font font3 = new Font("Verdana", 7.0f))
{throw new Exception("This is the exception");}

Case 2 :

using (Font font3 = new Font("Verdana", 7.0f)){

return;}

Is font3 still alive in both the above cases ?
Auto-Properties

If you do not have any additional logic involved in your property declaration you can take advantage of the auto
implementation of the properties.
Example :

class Employee

{

//Auto Properties for get and set    

public double TotalSalary {get; set; }

public string EmpName {get; set; }

public int EmpID {get; set; }

    // Constructor      

    public Employee(double totalSalary, string empName, int empID)

    {

         TotalSalary = totalSalary;

         EmpName = empName; EmpID = empID;    }

    // .. methods, etc. }

}

 

Here we see that there is no need to create a private variable for our property as well as assigning the value, this will
be done automatically by the compiler.
string.IsNullOrEmpty
There are instances in our code where we need to check if the string is null/nothing or its value is blank/empty, what

we usually write is :

if (mystring == null || mystring == String.Empty){
         
// code here}

We can use the above method and have much cleaner code like the one below:

 if (String.IsNullOrEmpty(mystring))

    {

 // code here

    }

 

But if your string contains a white space like this mystring= " " than the String.IsNullOrEmpty method will give you
False, so in this case we should use string.IsNullOrWhiteSpace. Normally we would do this check in our code.

if (String.IsNullOrEmpty(mystring) || mystring.Trim().Length == 0){//code here}

We can be more efficient by writing like this:

if (String.IsNullOrWhiteSpace(mystring)){// code here}

Ternary Operator

This is an operator we use when we need to check for conditions and it returns one of the values depending on the
Boolean expression.

For example if there is a check in your code like the following:

if (mystring == null){mystring="this is new text";}else{Mystring = "exisiting string";} 

You can write the above code using the ? Operator like below:

     mystring = (mystring== null) ? "this is new text" :"existing string";

 

Null Coalescing Operator

The ?? Operator or the Null Coalescing Operator is used to return the left hand operand if it is not null otherwise it
returns the right hand operand.

For example there is a check in your code like the following:

string mystring = null; if (mystring == null){mystring = String.Empty;} 

We can write the above code like the following using the ?? Operator: 

 string mystring = null ?? String.Empty;

 

Stopwatch Class

There are a lot of instances with us that we need to time a particular portion of our code or any external process
running from our code for which the control comes back to us. We usually use the DateTime object and assign to the
start variable, than run our process and then assign it to the end variable when the process is over and than just find
the difference between them and display on the screen. Here we can see that using Stopwatch class is also very
helpful in these tasks:

 

Stopwatch timer = Stopwatch.StartNew();

     // time intense code here

     timer.Stop();

     Console.WriteLine("Method took {0} ms", timer.ElapsedMilliseconds);

 

You can reset the Stopwatch with just Reset() method.

TimeSpan Structure

Sometimes we need to use seconds or milliseconds in our code for some purpose, for example:

 

Thread.Sleep(4000); // this would suspend the current process by 4 seconds

 

But if the number is large than it becomes hard to read as we don't know if we need to convert this to seconds or
minutes. Alternative to this is to use the TimeSpan structure which is precise in its parameters as either hours,
minutes, seconds, milliseconds or days are being passed in the parameter. Following is the revised code for the above
task:

Thread.Sleep(new TimeSpan(0,0,4)); // this would also suspend the current process by 4 seconds, but much readable now.

 

Hope you enjoyed this article and found these little treats useful and that you can make use in your code to make it
more readable and code fast.