Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Math.Round C#
.NET AIDE

Math.Round C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Dans le domaine de la programmation C#, la méthode Math.Round joue un rôle clé dans l'arrondi des valeurs numériques, en particulier lorsqu'il s'agit de types de données à double valeur et à valeur décimale. Cette méthode permet aux développeurs d'arrondir une valeur numérique donnée à la valeur entière la plus proche ou à un nombre spécifié de chiffres fractionnaires moins élevés, offrant flexibilité et précision dans les opérations mathématiques. Plusieurs types d'arrondi sont disponibles, comme l'arrondi à mi-chemin. Dans cet article, nous allons explorer les subtilités de Math.Round en C#, en examinant ses divers aspects et scénarios d'utilisation. In the subsequent sections of this article, we'll explore the utilization of the IronPDF library by Iron Software for handling PDFs.

Notions de base de Math.Round en C#

La méthode Math.Round

La méthode Math.Round en C# est un outil puissant pour arrondir les chiffres fractionnaires en utilisant une convention d'arrondi spécifiée. Elle fait partie du namespace System et propose plusieurs surcharges pour s'adapter à différentes opérations d'arrondi.

// 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 is the type of rounding method
Math.Round(Double, MidpointRounding)  // MidpointRounding is the 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 is the type of rounding method
Math.Round(Double, MidpointRounding)  // MidpointRounding is the 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
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Math.Round(Double) Math.Round(Double, Int32) Math.Round(Double, Int32, MidpointRounding) Math.Round(Double, MidpointRounding) Math.Round(Decimal) Math.Round(Decimal, Int32) Math.Round(Decimal, Int32, MidpointRounding) Math.Round(Decimal, MidpointRounding)
$vbLabelText   $csharpLabel

Arrondi de valeur double

Lorsqu'il s'agit de valeurs doubles, Math.Round est couramment utilisé pour arrondir un nombre à l'entier le plus proche. L'extraction de données, comme l'extraction d'images, de tableaux et de texte des documents PDF, est fournie par la bibliothèque pdf2Data.

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
$vbLabelText   $csharpLabel

Dans cet exemple, la méthode Math.Round arrondit la valeur double originale 3,75 à la valeur entière la plus proche, qui est 4.

Arrondi de valeur décimale

De même, la méthode Math.Round s'applique aux valeurs décimales. Considérez l'exemple suivant :

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
$vbLabelText   $csharpLabel

Ici, la méthode Math.Round est utilisée pour arrondir le nombre décimal 8,625 à deux décimales, ce qui donne la valeur arrondie 8,63.

Valeur entière la plus proche

Le principal objectif de Math.Round est d'arrondir une valeur numérique donnée à l'entier le plus proche. Lorsque la partie fractionnaire est exactement à mi-chemin entre deux entiers, la méthode suit une convention d'arrondi spécifiée. L'énumération MidpointRounding peut être utilisée comme argument dans la méthode Math.Round et détermine s'il faut arrondir vers le nombre pair le plus proche ou s'éloigner de zéro.

Convention d'arrondi spécifiée

Explorons comment le mode MidpointRounding peut être employé:

double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 6
double originalValue = 5.5;
double roundedValueEven = Math.Round(originalValue, MidpointRounding.ToEven);
double roundedValueOdd = Math.Round(originalValue, MidpointRounding.AwayFromZero);
// Output: roundedValueEven = 6, roundedValueOdd = 6
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 = 6
$vbLabelText   $csharpLabel

Dans cet exemple, lors de l'arrondi de la valeur 5,5, MidpointRounding.ToEven arrondit vers le nombre pair le plus proche (résultant en 6), et MidpointRounding.AwayFromZero s'éloigne de zéro, donnant 6.

Arrondi à un nombre spécifié de décimales

Pour arrondir un nombre à un nombre spécifié de décimales, la méthode Math.Round permet l'inclusion d'un paramètre supplémentaire représentant le nombre de chiffres fractionnaires:

decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); 
// Output: 9.123
decimal originalValue = 9.123456m;
decimal roundedValue = Math.Round(originalValue, 3); 
// Output: 9.123
Dim originalValue As Decimal = 9.123456D
Dim roundedValue As Decimal = Math.Round(originalValue, 3)
' Output: 9.123
$vbLabelText   $csharpLabel

Ici, le nombre décimal 9,123456 est arrondi à trois décimales, ce qui donne la valeur arrondie 9,123.

Valeurs à mi-parcours et conventions d'arrondi en C#

Une valeur à mi-parcours apparaît lorsque la valeur après le chiffre significatif le moins important dans le résultat est exactement à mi-chemin entre deux nombres. Par exemple, 2,56500 est une valeur à mi-parcours lorsqu'elle est arrondie à deux décimales à 2,57, et 3,500 est une valeur à mi-parcours lorsqu'elle est arrondie à un entier 4. Le défi réside dans l'identification de la valeur la plus proche dans la stratégie d'arrondi à la valeur la plus proche pour les valeurs à mi-parcours sans convention d'arrondi définie.

La méthode Round en C# prend en charge deux conventions d'arrondi pour gérer les valeurs à mi-parcours :

  • Arrondi en s'éloignant de zéro : les valeurs à mi-parcours subissent un arrondi vers le nombre suivant en s'éloignant de zéro. Cette méthode est représentée par le membre d'énumération MidpointRounding.AwayFromZero.

  • Arrondi vers le nombre pair le plus proche (Arrondi bancaire) : les valeurs à mi-parcours sont arrondies vers le nombre pair le plus proche. Cette approche d'arrondi est indiquée par le membre d'énumération MidpointRounding.ToEven.
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; 
}
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); 
}
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length);

// Calculate mean values with rounding to the nearest even.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.ToEven); 
}
Console.WriteLine("ToEven mean: {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; 
}
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); 
}
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length);

// Calculate mean values with rounding to the nearest even.
sum = 0;
foreach (var value in decimalSampleValues)
{ 
    sum += Math.Round(value, 1, MidpointRounding.ToEven); 
}
Console.WriteLine("ToEven mean: {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
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
Console.WriteLine("AwayFromZero mean: {0:N2}", sum / decimalSampleValues.Length)

' Calculate mean values with rounding to the nearest even.
sum = 0
For Each value In decimalSampleValues
	sum += Math.Round(value, 1, MidpointRounding.ToEven)
Next value
Console.WriteLine("ToEven mean: {0:N2}", sum / decimalSampleValues.Length)
$vbLabelText   $csharpLabel

Sortie

Math.Round C# (Comment ça fonctionne pour les développeurs) : Figure 1 - Sortie en virgule flottante à double précision

Modes MidpointRounding

Math.Round C# (Comment ça fonctionne pour les développeurs) : Figure 2 - Arrondi à mi-parcours

S'éloigner de zéro : 1

La stratégie d'arrondi S'éloigner de zéro arrondit vers le nombre le plus proche, arrondissant un nombre à mi-chemin entre deux autres en s'éloignant de zéro.

Vers zéro : 2

Cette stratégie est caractérisée par un arrondi dirigé vers zéro. Le résultat est le plus proche et n'est pas plus grand en magnitude que le résultat infiniment précis.

Vers Pair : 0

Cette stratégie implique un arrondi vers le nombre le plus proche, et lorsqu'un nombre est à mi-chemin entre deux autres, il est arrondi vers le nombre pair le plus proche.

Vers l'infini négatif : 3

Cette stratégie implique un arrondi vers le bas, le résultat étant le plus proche et pas plus grand que le résultat infiniment précis.

Vers l'infini positif : 4

Cette stratégie implique un arrondi vers le haut, le résultat étant le plus proche et pas moins que le résultat infiniment précis.

Précision et virgule flottante à double précision

Précision et valeurs doubles

Lorsqu'on travaille avec des nombres en virgule flottante à double précision, il est essentiel de comprendre l'imprécision potentielle en raison de la nature de la représentation en virgule flottante. La méthode Math.Round aide à atténuer les problèmes de précision en arrondissant les valeurs à l'entier le plus proche ou à un nombre spécifié de décimales.

Précision spécifiée avec Math.Round

Les développeurs peuvent tirer parti de la méthode Math.Round pour atteindre la précision souhaitée dans leurs calculs :

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
$vbLabelText   $csharpLabel

Dans cet exemple, la valeur double 123,456789 est arrondie à quatre décimales, ce qui donne la valeur plus précise 123,4568.

Stratégie d'arrondi à mi-parcours

Gestion des valeurs à mi-parcours

La stratégie d'arrondi à mi-parcours devient cruciale lorsqu'une valeur fractionnaire est exactement à mi-chemin entre deux entiers. La méthode Math.Round utilise la stratégie MidpointRounding spécifiée pour résoudre de tels cas.

Exemple d'arrondi à mi-parcours

Considérons l'exemple suivant où l'arrondi à mi-parcours est utilisé :

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
$vbLabelText   $csharpLabel

Ici, la valeur 7,5 est arrondie en s'éloignant de zéro, ce qui donne la valeur arrondie 8.

Application dans des scénarios du monde réel

Voici quelques exemples de son application dans divers contextes :

Calculs financiers

Dans les applications financières, un arrondi précis est crucial. Par exemple, lors du calcul des taux d'intérêt, de la conversion des devises ou du traitement des calculs d'impôts, la méthode Math.Round peut être utilisée pour s'assurer que les résultats sont arrondis au nombre approprié de décimales, en respectant les normes financières.

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
$vbLabelText   $csharpLabel

Affichage de l'interface utilisateur

Lors de la présentation de valeurs numériques dans une interface utilisateur, il est courant d'arrondir les nombres pour une meilleure lisibilité. L'arrondi en utilisant Math.Round peut améliorer la clarté des informations présentées.

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
$vbLabelText   $csharpLabel

Analyse statistique

Dans l'analyse statistique, un arrondi précis est essentiel pour éviter d'introduire des biais ou des imprécisions. La méthode Math.Round peut aider à présenter des résultats avec le niveau de précision désiré.

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
$vbLabelText   $csharpLabel

Calculs scientifiques

Dans les applications scientifiques, la précision est cruciale. Lorsqu'il s'agit de données expérimentales ou de calculs scientifiques, l'arrondi en utilisant Math.Round garantit que les résultats sont présentés de manière significative et précise.

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
$vbLabelText   $csharpLabel

Modélisation mathématique

Lors de l'implémentation de modèles mathématiques ou de simulations, l'arrondi peut simplifier les calculs complexes. La méthode Math.Round peut être appliquée pour contrôler la précision des résultats intermédiaires dans le processus de modélisation.

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
$vbLabelText   $csharpLabel

Développement de jeux

Dans le développement de jeux, la précision numérique est cruciale pour les calculs de physique, le positionnement, et d'autres opérations mathématiques. La méthode Math.Round garantit que les valeurs liées aux jeux sont arrondies à un niveau de précision approprié.

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
$vbLabelText   $csharpLabel

Dans chacun de ces scénarios, la méthode Math.Round permet aux développeurs de contrôler la précision des valeurs numériques, favorisant l'exactitude et la lisibilité dans leurs applications.

Présentation d'IronPDF

La fonctionnalité principale de IronPDF est sa fonction HTML en PDF, qui maintient les mises en page et les styles. Il convertit le contenu Web en PDF, ce qui est excellent pour les rapports, les factures et la documentation. Vous pouvez facilement convertir des fichiers HTML, des URLs et des chaînes HTML en PDFs.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

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

Installation

Vous avez la possibilité d'installer IronPDF soit via la console du gestionnaire de packages NuGet, soit via le gestionnaire de packages Visual Studio.

Install-Package IronPdf

Installez IronPDF en utilisant le gestionnaire de packages NuGet en recherchant "ironpdf" dans la barre de recherche.

Utilisation de IronPDF pour générer un PDF

using IronPdf;

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 values:");
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>";

var pdfRenderer = new ChromePdfRenderer();
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
using IronPdf;

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 values:");
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>";

var pdfRenderer = new ChromePdfRenderer();
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf");
Imports Microsoft.VisualBasic
Imports IronPdf

Private cart As New List(Of String)()

Private Sub AddItems(ParamArray ByVal items() As String)
	For i As Integer = 0 To items.Length - 1
		cart.Add(items(i))
	Next i
End Sub

Console.WriteLine("Enter the cart items as comma-separated values:")
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>"

Dim pdfRenderer = New ChromePdfRenderer()
pdfRenderer.RenderHtmlAsPdf(content).SaveAs("cart.pdf")
$vbLabelText   $csharpLabel

Dans le code ci-dessus, nous générons un document HTML pour les articles du panier et nous l'enregistrons ensuite comme document PDF à l'aide de IronPDF.

Sortie

Math.Round C# (Comment ça fonctionne pour les développeurs) : Figure 3 - Sortie à partir du code ci-dessus

Licence (essai gratuit disponible)

Pour activer la fonctionnalité du code fourni, il est nécessaire d'obtenir une clé de licence. Vous pouvez obtenir une clé d'essai à partir de cet emplacement ici, et elle doit être insérée dans le fichier appsettings.json.

"IronPdf.LicenseKey": "your license key"

Fournissez votre adresse e-mail pour obtenir une licence d'essai livrée.

Conclusion

En conclusion, la méthode Math.Round en C# est un outil polyvalent pour arrondir les valeurs double et décimales, offrant aux développeurs la flexibilité d'arrondir à l'entier le plus proche ou à un nombre spécifié de décimales. Comprendre les subtilités de Math.Round, y compris son traitement des valeurs à mi-parcours et l'utilisation des stratégies MidpointRounding, est essentiel pour des opérations mathématiques précises et fiables dans la programmation C#. Que ce soit pour effectuer des calculs financiers, afficher des interfaces utilisateur ou d'autres scénarios nécessitant une représentation numérique précise, la méthode Math.Round s'avère être un atout indispensable dans la boîte à outils du programmeur. De plus, nous avons vu comment IronPDF est une bibliothèque polyvalente pour générer des documents PDF.

Questions Fréquemment Posées

Comment Math.Round peut-il être utilisé dans les calculs financiers en C# ?

Math.Round est souvent utilisé dans les calculs financiers pour garantir la précision, notamment pour des opérations comme les calculs de taux d'intérêt, les conversions de devises et les calculs d'impôt. En arrondissant à un nombre spécifié de décimales, il aide à maintenir l'intégrité numérique.

Qu'est-ce que MidpointRounding en C# et comment cela affecte-t-il l'arrondissement ?

MidpointRounding est une énumération en C# qui influence la manière dont l'arrondissement est effectué lorsqu'une valeur est exactement à mi-chemin entre deux nombres. Il propose des stratégies comme MidpointRounding.AwayFromZero, qui arrondit à l'écart du zéro, et MidpointRounding.ToEven, qui arrondit au nombre pair le plus proche pour minimiser les erreurs cumulatives d'arrondissement.

Comment Math.Round est-il utilisé dans la conception d'interfaces utilisateur ?

Dans la conception d'interfaces utilisateur, Math.Round est utilisé pour améliorer l'affichage des valeurs numériques en les arrondissant à un nombre spécifié de décimales, garantissant que l'information est présentée de manière claire et précise pour l'utilisateur final.

Comment la méthode Math.Round gère-t-elle les types de données double et decimal en C# ?

La méthode Math.Round peut gérer à la fois les types de données double et decimal en les arrondissant à la valeur entière la plus proche ou à un nombre spécifié de décimales. Cette flexibilité est cruciale pour la précision dans les calculs mathématiques.

Math.Round peut-il être appliqué dans les calculs scientifiques ?

Oui, Math.Round est utilisé dans les calculs scientifiques pour arrondir les résultats numériques à la précision souhaitée, garantissant une exactitude dans les calculs approfondis et l'analyse des données.

Quels sont les avantages de l'utilisation d'IronPDF dans les applications C# ?

IronPDF est une bibliothèque C# qui permet aux développeurs de convertir le contenu HTML en PDF. Elle est bénéfique pour générer des rapports, des factures et des documentations, ce qui en fait un outil essentiel pour gérer les opérations PDF dans les applications C#.

Comment fonctionne MidpointRounding.ToEven en C# ?

MidpointRounding.ToEven, également connu sous le nom d'arrondissement bancaire, arrondit les valeurs intermédiaires au nombre pair le plus proche. Cette méthode réduit les erreurs cumulatives d'arrondissement, particulièrement dans les calculs répétés, ce qui la rend utile dans les applications financières et statistiques.

Math.Round est-il adapté au développement de jeux en C# ?

Oui, Math.Round est adapté au développement de jeux car il aide à la précision des calculs de physique, de positionnement et d'autres opérations mathématiques critiques pour une expérience de jeu fluide.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit