Truncate decimals instead of Rounding from a double value In C#

Introduction

Many times while working on applications, we often land into a situation where we want to truncate the decimal places from a number instead of round like suppose we have 5.329 and I want to truncate the third digit then my required output will be 5.32. Here, I will walk through the different ways which I know in which we can achieve the same.

Approaches

I have created the approaches as making the C# method.

1. Truncate the decimals through the string operations.

Below method only usable if you want to truncate the decimal places to two.

   1: #region Round

   2: /// <summary>

   3: /// Truncate the last digit after two digit floating points.

   4: /// </summary>

   5: /// <param name="value">A double-precision floating-point number to be rounded.</param>

   6: /// <returns>Double value contains two digit floating points.</returns>

   7: public static double Round (double value)

   8: {

   9:   double returnValue = 0;

  10:  

  11:   try

  12:   {

  13:     //Convert the value into the string for round.

  14:     string input = Convert.ToString(value);

  15:  

  16:     //Check if the input contains decimal places

  17:     if (input.Contains("."))

  18:     {

  19:       //Check if there are 3 or more digits after the decimal point.

  20:       if (input.Length - input.IndexOf(".", StringComparison.Ordinal) >= 4)

  21:       {

  22:         //Replace the input value with the required value. Added 3 to get only 2 digits after the decimal point.

  23:         input = input.Substring(0, input.IndexOf(".", StringComparison.Ordinal) + 3); 

  24:       }

  25:     }

  26:         //Converts the string representation of a number to its System.Double equivalent.

  27:     returnValue = Convert.ToDouble(input);

  28:   }

  29:   catch { } //Suppress exception no need to handle.

  30:  

  31:   return returnValue;

  32: }

  33: #endregion

2. Truncate the decimals through the mathematical operations.

Through this method you can truncate any number of decimal places.

   1: #region Round

   2: /// <summary>

   3: /// Rounds a decimal value to a specified number of fractional digits.

   4: /// </summary>

   5: /// <param name="value">A decimal number to be rounded.</param>

   6: /// <param name="decimals">The number of decimal places in the return value.</param>

   7: /// <returns>The number nearest to value that contains a number of fractional digits equal to decimals.</returns>

   8: public static double Round(double value, byte decimals)

   9: {

  10:   double returnValue = 0;

  11:  

  12:   try

  13:   {

  14:     if (value != 0)

  15:     {

  16:       //Gets the power of 10 base on passed decimal parameter value (10^decimals).

  17:       double powValue = Math.Pow(10, decimals);

  18:  

  19:       //Gets the truncated value.

  20:       returnValue = Math.Truncate(CDCommon.ToDouble(value * powValue)) / powValue;

  21:     }

  22:   }

  23:   catch

  24:   { throw; }

  25:  

  26:   return returnValue;

  27: }

  28: #endregion

Conclusion

From both the ways, as per my opinion prefer the second approach in implementation because it’s very light compared to the first in terms of calculations.