C# Math.Round ExamplesUse the Math.Round method to the nearest desired value. Examine the MidpointRounding enum type.

Math.Round. This C# method rounds numbers to the nearest value. It receives the desired number of significant digits. It is part of the System namespace.

Method details. This Math.Round static method provides an accurate way to round double and decimal types. It reduces the risk of bugs.

Simple example. To begin, consider this simple example of calling Math.Round. The fractional part of 1.234 is removed, as it is closer to 1 than 2, and we are left with a result of 1.

C# program that uses Math.Round

using System;
class Program
{
public static void Main()
{
double value = 1.234;
Console.WriteLine("ROUND: {0}", Math.Round(value));
}
}ROUND: 1

Complex example. Math.Round has several overloads and 2 rounding modes defined on the MidpointRounding enum. Here we round an example double and decimal type.

Return We see what Math.Round will return with different arguments. We use 1, 2 and 3 arguments.

using System;
class Program
{
static void Main()
{
//
// Round double type in three ways.
//
double before1 = 123.45;
double after1 = Math.Round(before1, 1,
MidpointRounding.AwayFromZero); // Rounds "up"
double after2 = Math.Round(before1, 1,
MidpointRounding.ToEven); // Rounds to even
double after3 = Math.Round(before1);
Console.WriteLine(before1); // Original
Console.WriteLine(after1);
Console.WriteLine(after2);
Console.WriteLine(after3);
//
// Round decimal type.
//
decimal before2 = 125.101M;
decimal after4 = Math.Round(before2);
decimal after5 = Math.Round(before2, 1);
Console.WriteLine(before2); // Original
Console.WriteLine(after4);
Console.WriteLine(after5);
}
}123.45
123.5 <-- MidpointRounding.AwayFromZero
123.4 <-- MidpointRounding.ToEven
123
125.101
125
125.1

MidpointRounding. What is the difference between MidpointRounding.ToEven and MidpointRounding.AwayFromZero? My testing indicates that the difference is found when rounding the number 0.5.

Info MidpointRounding.ToEven will round 0.5 to 0—this is because zero is even.

And MidpointRounding.AwayFromZero will round 0.5 to 1—this is because one is away from zero.

C# program that demonstrates MidpointRounding

using System;
class Program
{
static void Main()
{
for (double i = 0.1; i < 0.99; i += 0.1)
{
Console.WriteLine("{0}=({1},{2})", i,
Math.Round(i, MidpointRounding.ToEven),
Math.Round(i, MidpointRounding.AwayFromZero));
}
}
}0.1=(0,0)
0.2=(0,0)
0.3=(0,0)
0.4=(0,0)
0.5=(0,1)
0.6=(1,1)
0.7=(1,1)
0.8=(1,1)
0.9=(1,1)

Performance. How does Math.Round affect performance? I benchmarked Math.Round to get a general idea. Sometimes using a local cache can speed up this logic.

Version 1 We call Math.Round with a second argument of 0. The result is tested against in an if-statement.

Version 2 This version of the code calls Math.Round again, but with a second argument of 1.

Result The Math.Round calls are slower than a local variable load, but not slow enough to be a big concern.

Important In .NET 5, calling Math.Round in this program was made several times faster—the results are impressive.

C# program that benchmarks Math.Round

using System;
using System.Diagnostics;
class Program
{
const int _max = 100000000;
static void Main()
{
// Version 1: use Math.Round with argument of 0.
var s1 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
double d = Math.Round(1.3665, 0);
if (d == 1.5)
{
throw new Exception();
}
}
s1.Stop();
// Version 2: use Math.Round with argument of 1.
var s2 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
double d = Math.Round(1.3665, 1);
if (d == 1.5)
{
throw new Exception();
}
}
s2.Stop();
Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
}
}5.52 ns Math.Round, 0
4.91 ns Math.Round, 1

Rounding notes. Certain computations could be optimized by avoiding Math.Round, or by caching its results. An if-statement would evaluate faster.

Note This article had an error in its description of rounding behaviors on scientific data. Thanks to Gus Gustafson for a correction.

A summary. We looked at the Math.Round method. We saw an example of the MidpointRounding enumerated type and how you can round numbers "away from zero" and to the nearest even number.