**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.