## Test in a live environment

Test in production without watermarks.

Works wherever you need it to.

.NET HELP

Updated March 6, 2024

In the realm of C# programming, the Math.Round value method plays a pivotal role in rounding numerical values, especially when dealing with double-value and decimal-value data types. This method allows developers to round a given numeric value to the nearest integral value or a specified number of fewer fractional digits, providing flexibility and precision in mathematical operations. Several rounding types are available, like Midpoint Rounding. In this article, we will delve into the intricacies of Math.Round in C#, exploring its various aspects and usage scenarios. In the subsequent sections of this article, we'll explore the utilization of the IronPDF library by Iron Software for handling PDFs.

The Math.Round method in C# is a powerful tool for rounding fractional digits using specified rounding convention. It is part of the System namespace and provides several overloads to accommodate different rounding operations.

```
/* methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) // int32 specifies number of fractional digits
Math.Round(Double, Int32, MidpointRounding) // int32 specifies number of fractional digits, MidpointRounding type of rounding method
Math.Round(Double, MidpointRounding) // MidpointRounding type of rounding method
Math.Round(Decimal)
Math.Round(Decimal, Int32) // int32 specifies number of fractional digits
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)
*/
```

```
/* methods overloaded by Math.Round
Math.Round(Double)
Math.Round(Double, Int32) // int32 specifies number of fractional digits
Math.Round(Double, Int32, MidpointRounding) // int32 specifies number of fractional digits, MidpointRounding type of rounding method
Math.Round(Double, MidpointRounding) // MidpointRounding type of rounding method
Math.Round(Decimal)
Math.Round(Decimal, Int32) // int32 specifies number of fractional digits
Math.Round(Decimal, Int32, MidpointRounding)
Math.Round(Decimal, MidpointRounding)
*/
```

```
' methods overloaded by Math.Round
'Math.Round(Double)
'Math.Round(Double, Int32) // int32 specifies number of fractional digits
'Math.Round(Double, Int32, MidpointRounding) // int32 specifies number of fractional digits, MidpointRounding type of rounding method
'Math.Round(Double, MidpointRounding) // MidpointRounding type of rounding method
'Math.Round(Decimal)
'Math.Round(Decimal, Int32) // int32 specifies number of fractional digits
'Math.Round(Decimal, Int32, MidpointRounding)
'Math.Round(Decimal, MidpointRounding)
'
```

VB C#

When dealing with double values, Math.Round is commonly used to round a number to the nearest integer. For instance:

```
double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
// Output: 4
```

```
double originalValue = 3.75;
double roundedValue = Math.Round(originalValue);
// Output: 4
```

```
Dim originalValue As Double = 3.75
Dim roundedValue As Double = Math.Round(originalValue)
' Output: 4
```

VB C#

In this example, the Math.Round method rounded the original double value 3.75 to the nearest integral value, which is 4.

Similarly, the Math.Round method applies to decimal values. Consider the following example:

```
decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
// Output: 8.63
```

```
decimal originalValue = 8.625m;
decimal roundedValue = Math.Round(originalValue, 2);
// Output: 8.63
```

```
Dim originalValue As Decimal = 8.625D
Dim roundedValue As Decimal = Math.Round(originalValue, 2)
' Output: 8.63
```

VB C#

Here, the Math.Round method is used to round the decimal number 8.625 to two decimal places, resulting in the rounded value 8.63.

The primary purpose of Math.Round is to round a given numeric value to the nearest integer. If the fractional part is exactly halfway between two integers, the method follows a specified rounding operations convention. The MidpointRounding enumeration can be used as an argument in the Math.Round method, determines whether to round towards the nearest even or odd number.

Several types of rounding operation types are possible, as shown in the above image. The names itself are self-explanatory.

Let's explore how the MidpointRounding mode can be employed:

```
double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 5
```

```
double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 5
```

```
Dim originalValue As Double = 5.5
Dim roundedValueEven As Double = Math.Round(originalValue, MidpointRounding.ToEven)
Dim roundedValueOdd As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: roundedValueEven = 6, roundedValueOdd = 5
```

VB C#

In this example, when rounding the value to 5.5, MidpointRounding.ToEven rounds towards the nearest even number (resulting in 6), while MidpointRounding.AwayFromZero rounds away from zero, yielding 5.

To round a number to a specified number of decimal places, the Math.Round method allows the inclusion of an additional parameter representing the number of int digits:

```
decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); // round values
// Output: 9.123
```

```
decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); // round values
// Output: 9.123
```

```
Dim originalValue As Decimal = 9.123456D
Dim roundedValue As Decimal = Math.Round(originalValue, 3) ' round values
' Output: 9.123
```

VB C#

Here, the decimal number 9.123456 is rounded to three decimal places, resulting in the rounded value 9.123.

A midpoint value arises when the value after the least significant digit in the result is exactly halfway between two numbers. For example, 2.56500 is a midpoint value when rounded to two decimal places 2.57, and 3.500 is a midpoint value when rounded to an integer 4. The challenge lies in identifying the nearest value in the round-to-nearest strategy for midpoint values without a defined rounding convention.

The Round method in C# supports two rounding conventions for handling midpoint values:

Rounding Away From Zero: Midpoint values undergo rounding to the succeeding number away from zero. For example, 3.75 is rounded up to 3.8, 3.85 is rounded up to 3.9, -3.75 is rounded down to -3.8, and -3.85 is rounded down to -3.9. This method is represented by the MidpointRounding.AwayFromZero enumeration member.

Rounding to Nearest Even (Banker's Rounding): Midpoint values are rounded to the closest even number. Instances include both 3.75 and 3.85 rounding to 3.8, and both -3.75 and -3.85 rounding to -3.8. This rounding approach is indicated by the MidpointRounding.ToEven enumeration member.

```
decimal [] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
// Calculate true mean values.
foreach (var value in decimalSampleValues)
{
sum += value;
}
// print
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding away from zero.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
}
// print
Console.WriteLine("AwayFromZero: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding to nearest.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.ToEven);
}
// print
Console.WriteLine("ToEven: {0:N2}", sum / decimalSampleValues.Length);
```

```
decimal [] decimalSampleValues = { 1.15m, 1.25m, 1.35m, 1.45m, 1.55m, 1.65m };
decimal sum = 0;
// Calculate true mean values.
foreach (var value in decimalSampleValues)
{
sum += value;
}
// print
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding away from zero.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero);
}
// print
Console.WriteLine("AwayFromZero: {0:N2}", sum / decimalSampleValues.Length);
// Calculate mean values with rounding to nearest.
sum = 0;
foreach (var value in decimalSampleValues)
{
sum += Math.Round(value, 1, MidpointRounding.ToEven);
}
// print
Console.WriteLine("ToEven: {0:N2}", sum / decimalSampleValues.Length);
```

```
Dim decimalSampleValues() As Decimal = { 1.15D, 1.25D, 1.35D, 1.45D, 1.55D, 1.65D }
Dim sum As Decimal = 0
' Calculate true mean values.
For Each value In decimalSampleValues
sum += value
Next value
' print
Console.WriteLine("True mean values: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding away from zero.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.AwayFromZero)
Next value
' print
Console.WriteLine("AwayFromZero: {0:N2}", sum / decimalSampleValues.Length)
' Calculate mean values with rounding to nearest.
sum = 0
For Each value In decimalSampleValues
sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next value
' print
Console.WriteLine("ToEven: {0:N2}", sum / decimalSampleValues.Length)
```

VB C#

The AwayFromZero rounding strategy rounds to the nearest number, when a number is halfway between two others.

This strategy is characterized by directed rounding towards zero. The result is the closest to and no greater in magnitude than the infinitely precise result.

This strategy involves rounding to the nearest number, and when a number is halfway between two others, it is rounded towards the nearest even number.

This strategy entails rounding in a downward direction, with the result being the closest to and no greater than the infinitely precise result.

This strategy involves rounding in an upward direction, with the result being the closest to and no less than the infinitely precise result.

When working with double-precision floating-point numbers, it is essential to understand the potential imprecision due to the nature of floating-point representation. The Math.Round method helps mitigate precision issues by rounding values to the nearest integer or a specified number of decimal places.

Developers can leverage the Math.Round method to achieve the desired precision in their calculations:

```
double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
// Output: 123.4568, rounded value
```

```
double originalValue = 123.456789;
double result = Math.Round(originalValue, 4);
// Output: 123.4568, rounded value
```

```
Dim originalValue As Double = 123.456789
Dim result As Double = Math.Round(originalValue, 4)
' Output: 123.4568, rounded value
```

VB C#

In this example, the double value 123.456789 is rounded to four decimal places, resulting in the more precise value 123.4568.

The midpoint rounding strategy becomes crucial when a fractional value is exactly halfway between two integers. The Math.Round method employs the specified MidpointRounding strategy to resolve such cases.

Consider the following example where midpoint rounding is utilized:

```
double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: 8
```

```
double originalValue = 7.5;
double roundedValue = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: 8
```

```
Dim originalValue As Double = 7.5
Dim roundedValue As Double = Math.Round(originalValue, MidpointRounding.AwayFromZero)
' Output: 8
```

VB C#

Here, the value 7.5 is rounded away from zero, resulting in the rounded value 8.

Here are a few examples of its application in various contexts:

In financial applications, precise rounding is crucial. For example, when calculating interest rates, converting currencies, or dealing with tax calculations, the Math.Round method can be employed to ensure that the results are rounded to the appropriate number of decimal places, adhering to financial standards.

```
double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); // Round to 4 decimal places
```

```
double interestRate = 0.04567;
double roundedInterest = Math.Round(interestRate, 4); // Round to 4 decimal places
```

```
Dim interestRate As Double = 0.04567
Dim roundedInterest As Double = Math.Round(interestRate, 4) ' Round to 4 decimal places
```

VB C#

When presenting numerical values in a user interface, it's common to round numbers for better readability. For instance, in a dashboard displaying temperature readings or financial data, rounding using Math.Round can enhance the clarity of the presented information.

```
double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); // Round to 1 decimal place
```

```
double temperature = 23.678;
double roundedTemperature = Math.Round(temperature, 1); // Round to 1 decimal place
```

```
Dim temperature As Double = 23.678
Dim roundedTemperature As Double = Math.Round(temperature, 1) ' Round to 1 decimal place
```

VB C#

In statistical analysis, precise rounding is essential to avoid introducing biases or inaccuracies. Whether calculating mean, median, or other statistical measures, the Math.Round method can help in presenting results with the desired level of precision.

```
double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); // Round mean value to 2 decimal places
```

```
double meanValue = CalculateMean(data);
double roundedMean = Math.Round(meanValue, 2); // Round mean value to 2 decimal places
```

```
Dim meanValue As Double = CalculateMean(data)
Dim roundedMean As Double = Math.Round(meanValue, 2) ' Round mean value to 2 decimal places
```

VB C#

In scientific applications, precision is crucial. When dealing with experimental data or scientific computations, rounding using Math.Round ensures that the results are presented in a meaningful and accurate manner.

```
double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); // Round to 5 decimal places
```

```
double experimentalResult = 9.87654321;
double roundedResult = Math.Round(experimentalResult, 5); // Round to 5 decimal places
```

```
Dim experimentalResult As Double = 9.87654321
Dim roundedResult As Double = Math.Round(experimentalResult, 5) ' Round to 5 decimal places
```

VB C#

When implementing mathematical models or simulations, rounding can be necessary to simplify complex calculations. The Math.Round method can be applied to control the precision of intermediate results in the modeling process.

```
double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); // Round to 3 decimal places
```

```
double modelResult = SimulatePhysicalSystem(parameters);
double roundedModelResult = Math.Round(modelResult, 3); // Round to 3 decimal places
```

```
Dim modelResult As Double = SimulatePhysicalSystem(parameters)
Dim roundedModelResult As Double = Math.Round(modelResult, 3) ' Round to 3 decimal places
```

VB C#

In game development, numerical precision is crucial for physics calculations, positioning, and other mathematical operations. The Math.Round method can be used to ensure that game-related values are rounded to an appropriate precision level.

```
double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); // Round to 2 decimal places
```

```
double playerPosition = CalculatePlayerPosition();
double roundedPosition = Math.Round(playerPosition, 2); // Round to 2 decimal places
```

```
Dim playerPosition As Double = CalculatePlayerPosition()
Dim roundedPosition As Double = Math.Round(playerPosition, 2) ' Round to 2 decimal places
```

VB C#

In each of these scenarios, the Math.Round method allows developers to control the precision of numerical values, promoting accuracy and readability in their applications.

Now let's see how we can generate PDF documents using **IronPDF** C# PDF library from **Iron Software****.**

You have the option to install IronPDF either through the NuGet Package Manager console or the Visual Studio package manager.

`dotnet add package IronPdf`

`dotnet add package IronPdf`

```
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf
```

VB C#

Install IronPDF using NuGet Package Manager by searching "ironpdf" in the search bar.

```
Console.WriteLine("Params Example");
List<string> cart = new List<string>();
void AddItems(params string [] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items [i]);
}
}
Console.WriteLine("Enter the cart items as comma separated ");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItems(items);
}
AddItems("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
```

```
Console.WriteLine("Params Example");
List<string> cart = new List<string>();
void AddItems(params string [] items)
{
for (int i = 0; i < items.Length; i++)
{
cart.Add(items [i]);
}
}
Console.WriteLine("Enter the cart items as comma separated ");
var itemsString = Console.ReadLine();
if (itemsString != null)
{
var items = itemsString.Split(",").ToArray();
AddItems(items);
}
AddItems("Sample1", "Sample2");
Console.WriteLine("-------------------------------------------------------");
Console.WriteLine("Display Cart");
string name = "Sam";
var count = cart.Count;
string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" +
string.Join("\n", cart.Select(x => $"<p>{x}</p>"))
+ @"
</body>
</html>";
// Create a new PDF document
var pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
```

```
Imports Microsoft.VisualBasic
Console.WriteLine("Params Example")
Dim cart As New List(Of String)()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'void AddItems(params string [] items)
'{
' for (int i = 0; i < items.Length; i++)
' {
' cart.Add(items [i]);
' }
'}
Console.WriteLine("Enter the cart items as comma separated ")
Dim itemsString = Console.ReadLine()
If itemsString IsNot Nothing Then
Dim items = itemsString.Split(",").ToArray()
AddItems(items)
End If
AddItems("Sample1", "Sample2")
Console.WriteLine("-------------------------------------------------------")
Console.WriteLine("Display Cart")
Dim name As String = "Sam"
Dim count = cart.Count
Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {name}!</h1>
<p>You have {count} items in the cart.</p>
" & String.Join(vbLf, cart.Select(Function(x) $"<p>{x}</p>")) & "
</body>
</html>"
' Create a new PDF document
Dim pdfDocument = New ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
```

VB C#

In the above code, we are generating HTML document for cart items and then saving it as a PDF document using IronPDF.

To enable the functionality of the provided code, it is necessary to acquire a license key. You can obtain a trial key from this location **here**, and it must be inserted into the appsettings.json file.

`"IronPdf.LicenseKey": "your license key"`

`"IronPdf.LicenseKey": "your license key"`

```
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"
```

VB C#

Provide your email ID to get a trial license delivered.

In conclusion, the Math.Round method in C# is a versatile tool for rounding double and decimal values, offering developers the flexibility to round to the nearest integer or a specified number of decimal places. Understanding the intricacies of Math.Round, including its treatment of midpoint values and the use of MidpointRounding strategies, is essential for accurate and reliable mathematical operations in C# programming. Whether dealing with financial calculations, user interface displays, or other scenarios requiring precise numeric representation, the Math.Round method proves to be an indispensable asset in a programmer's toolkit. Also, we saw how IronPDF is a versatile library to generate PDF documents.

< PREVIOUS

C# Timer (How It Works For Developers)

C# Timer (How It Works For Developers)

NEXT >

C# ArrayList (How It Works For Developers)

C# ArrayList (How It Works For Developers)

15 1000 1

15 1000 1

15 1000 1

15 1000 1

15 1000 1

15 1000 1

15 1000 1

9 .NET API products **for your office documents**

- - Create, read, and edit PDFs. HTML to PDF for NET.
- - Edit DOCX Word Files. No Office Interop required.
- - Edit Excel & CSV files. No Office Interop required.
- - OCR (extract text from images) in 127 languages.
- - Read and write QR & Barcodes.
- - Read and write QR codes.
- - Zip and unzip archives.
- - Print documents in .NET applications.
- - Scrape structured data from websites.