C# Rounding 2 decimals: Truncate vs Round

I would like to know which are the advantages and disadvantages using Truncate or Round when rounding a float to 2 decimals:

``float number = 3.4567070Math.Round(number, 2)Math.Truncate(100 * number) / 100``

Which is the best and eficent one? When to use round and when truncate?

Truncate is marginally more efficient, but these are very different functions.

• `Math.Round` computes the nearest number to the input to a specified degree of accuracy.

Rounds a value to the nearest integer or to the specified number of fractional digits.

• `Math.Truncate` effectively discards the any digits after the decimal point. It will always round to the nearest integer toward zero.

Calculates the integral part of a number

Which function you should use is entirely dependent on the logic you're trying to implement.

Here's a quick sample output of each function:

``````Input | Round | Truncate
------+-------+---------
-1.6 |    -2 |       -1
-1.5 |    -2 |       -1
-1.4 |    -1 |       -1
-0.5 |     0 |        0
0.5 |     0 |        0
1.4 |     1 |        1
1.5 |     2 |        1
1.6 |     2 |        1
``````

That depends on your purpose. I don't think one is more effecient than the other. It's like saying "Should I use a nail or a screw?" They do different things.

If you are trying to round to 2 decimals, I highly recommend using `Round()` instead of `Truncate()`, if for no other reason than readability & maintainability. Your example is a bit confusing at first glance, and it takes some analysis to understand that it is effectively using some fancy footwork to get the `Truncate()` method to perform a rounding operation.

In general, when writing code, you should use the "correct" method first, and if benchmarking shows a performance issue, only then should you attempt optimizations such as your "tricky" code example.