C# Arrondir à 2 décimales (Comment ça marche pour les développeurs)

Arrondir les chiffres en programmation est une tâche courante, en particulier lorsque vous travaillez avec des données financières ou des mesures pour lesquelles une précision jusqu'à un certain nombre de décimales est requise. En C#, il existe plusieurs façons d'arrondir un nombre décimal ou un nombre double à deux décimales. Ce tutoriel expliquera clairement les concepts et vous fournira des connaissances complètes sur la manière d'atteindre cette précision en utilisant C#. Nous examinerons lesCapacités de la bibliothèque IronPDF et diverses méthodes et fonctions fournies par le langage C# pour manipuler des nombres décimaux avec une précision spécifiée.

Comprendre les types de valeurs décimales et doubles dans C# ;

Avant d'aborder les techniques d'arrondi des nombres, il est important de comprendre les types de nombres auxquels nous aurons affaire. En C#, decimal et double sont deux types différents utilisés pour les valeurs numériques. Une variable décimale est généralement utilisée lorsque le niveau de précision le plus élevé est nécessaire, par exemple dans les calculs financiers. En revanche, un résultat double est utilisé lorsque les calculs en virgule flottante sont suffisants et que la performance est un facteur plus critique que la précision exacte. Ces deux types peuvent être arrondis à l'aide de méthodes spécifiques de la bibliothèque C#.

Utilisation de Math.Round pour arrondir à deux décimales

La méthode Math.Round est l'approche la plus simple pour arrondir des valeurs décimales ou des valeurs doubles à un nombre spécifié de décimales. Vous pouvez également utiliser cette fonction mathématique pour arrondir les valeurs doubles à l'entier le plus proche. Cette méthode Math.Round value est polyvalente car elle vous permet de spécifier le nombre de chiffres que vous souhaitez conserver après la virgule, et elle vous permet également de choisir la stratégie d'arrondi si le nombre est exactement à mi-chemin entre deux intervalles.

Arrondir une valeur décimale à la décimale près

Pour arrondir un nombre décimal à deux décimales, vous pouvez utiliser la méthode Math.Round qui prend deux paramètres : le nombre à arrondir et le nombre de décimales. Voici un exemple simple :

decimal d = 3.14519M; // decimal number
decimal roundedValue = Math.Round(d, 2);
Console.WriteLine(roundedValue);  // Outputs: 3.15

decimal d = 3.14519M; // decimal number
decimal roundedValue = Math.Round(d, 2);
Console.WriteLine(roundedValue);  // Outputs: 3.15

Dim d As Decimal = 3.14519D ' decimal number
Dim roundedValue As Decimal = Math.Round(d, 2)
Console.WriteLine(roundedValue) ' Outputs: 3.15

Dans cet exemple, la valeur décimale 3.14519 est arrondie à 3.15. La méthode Math.Round prend la décimale d et l'arrondit à deux décimales.

Arrondir une valeur double

L'arrondi d'une valeur double fonctionne de la même manière que l'arrondi d'une valeur décimale. Voici le code permettant d'arrondir un nombre double à deux décimales à l'aide d'une fonction mathématique :

double num = 3.14519;
double result = Math.Round(num, 2); // round to 2 digits
Console.WriteLine(result);  // Output: 3.15

double num = 3.14519;
double result = Math.Round(num, 2); // round to 2 digits
Console.WriteLine(result);  // Output: 3.15

Dim num As Double = 3.14519
Dim result As Double = Math.Round(num, 2) ' round to 2 digits
Console.WriteLine(result) ' Output: 3.15

Cet extrait de code arrondit le nombre double 3.14519 à l'entier le plus proche, 3.15, en utilisant la valeur math.round. Le deuxième argument de Math.Round spécifie que l'arrondi doit être effectué à deux décimales.

Gestion de l'arrondi au point médian

Un aspect important de l'arrondi est la manière de traiter les cas où le nombre se situe exactement au point médian entre deux valeurs arrondies possibles. C# offre la possibilité de spécifier le comportement d'arrondi par le biais de l'enum MidpointRounding. Cela permet de contrôler la direction de l'arrondi dans de tels cas.

double midpointNumber = 2.345; // double value format
double midpointResult = Math.Round(midpointNumber, 2, MidpointRounding.AwayFromZero);
Console.WriteLine(midpointResult);  // Outputs answer: 2.35

double midpointNumber = 2.345; // double value format
double midpointResult = Math.Round(midpointNumber, 2, MidpointRounding.AwayFromZero);
Console.WriteLine(midpointResult);  // Outputs answer: 2.35

Dim midpointNumber As Double = 2.345 ' double value format
Dim midpointResult As Double = Math.Round(midpointNumber, 2, MidpointRounding.AwayFromZero)
Console.WriteLine(midpointResult) ' Outputs answer: 2.35

Dans l'exemple ci-dessus, MidpointRounding.AwayFromZero indique à la méthode d'arrondir le nombre du point médian 2,345 au nombre le plus proche de zéro, ce qui donne 2,35. Ceci est particulièrement utile dans les calculs financiers où l'arrondi est couramment utilisé.

Utilisation d'IronPDF avec C# ; pour arrondir des nombres et générer des PDFs

IronPDF est une bibliothèque complète de génération de PDF spécialement conçue pour la plate-forme .NET et écrite en C#. Il est réputé pour sa capacité à créer despDF de haute qualité grâce au rendu de HTML, CSS et JavaScriptla traduction doit également comprendre des mots et des images. Cette capacité permet aux développeurs de tirer parti de leurs compétences en matière de développement web pour générer des PDF. IronPDF utilise un moteur de rendu Chrome pour produire des documents PDF parfaits au pixel près, reflétant la mise en page observée dans les navigateurs web.

La principale caractéristique d'IronPDF est saCapacités de conversion de HTML en PDFen veillant à ce que vos mises en page et vos styles soient préservés. Il convertit le contenu web en PDF, ce qui convient pour les rapports, les factures et la documentation. Vous pouvez facilement convertir des fichiers HTML, des URL et des chaînes HTML en PDF.

using IronPdf;

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

        // 1. 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");

        // 2. 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");

        // 3. 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();

        // 1. 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");

        // 2. 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");

        // 3. 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()

		' 1. 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")

		' 2. 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")

		' 3. 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

IronPDF peut être intégré de manière transparente à C# pour traiter des tâches précises, telles que l'arrondissement des décimales à deux décimales avant de les intégrer dans un PDF. Cette fonction est particulièrement utile dans les rapports financiers ou les factures où la précision numérique est importante.

Exemple : Générer un PDF avec des valeurs décimales arrondies

Dans cet exemple, nous allons créer une application C# simple qui utilise IronPDF pour générer un document PDF contenant une liste de nombres arrondis à deux décimales. Cela montre comment vous pouvez intégrer des calculs numériques à la génération de PDF dans un scénario réel.

Tout d'abord, vous devez installer IronPDF. Vous pouvez le faire via NuGet :

Install-Package IronPdf

Une fois IronPDF installé, voici comment créer un PDF à partir d'un contenu HTML, y compris des nombres arrondis à deux décimales :

using IronPdf;
using System;
class Program
{
    static void Main()
    {
        License.LicenseKey = "License-Key";
        // Create a PDF document
        var Renderer = new ChromePdfRenderer();
        // Sample data that might come from a database or computation
        double initialValue = 2.345678;
        double roundedValue = Math.Round(initialValue, 2);
        // HTML content including the rounded value
        var htmlContent = $@"
            <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>Financial Report</h1>
                <p>Value after rounding: {roundedValue}</p>
            </body>
            </html>";
        // Convert HTML to PDF
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs("Report.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;
class Program
{
    static void Main()
    {
        License.LicenseKey = "License-Key";
        // Create a PDF document
        var Renderer = new ChromePdfRenderer();
        // Sample data that might come from a database or computation
        double initialValue = 2.345678;
        double roundedValue = Math.Round(initialValue, 2);
        // HTML content including the rounded value
        var htmlContent = $@"
            <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>Financial Report</h1>
                <p>Value after rounding: {roundedValue}</p>
            </body>
            </html>";
        // Convert HTML to PDF
        var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent);
        pdfDocument.SaveAs("Report.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main()
		License.LicenseKey = "License-Key"
		' Create a PDF document
		Dim Renderer = New ChromePdfRenderer()
		' Sample data that might come from a database or computation
		Dim initialValue As Double = 2.345678
		Dim roundedValue As Double = Math.Round(initialValue, 2)
		' HTML content including the rounded value
		Dim htmlContent = $"
            <html>
            <head>
                <title>PDF Report</title>
            </head>
            <body>
                <h1>Financial Report</h1>
                <p>Value after rounding: {roundedValue}</p>
            </body>
            </html>"
		' Convert HTML to PDF
		Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent)
		pdfDocument.SaveAs("Report.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

Cet exemple montre comment vous pouvez combiner la précision des opérations mathématiques C# avec les capacités de génération de documents d'IronPDF pour créer des rapports PDF détaillés et précis. Qu'il s'agisse d'un résumé financier, d'un rapport technique ou de tout autre document pour lequel la précision numérique est importante, cette méthode permet de s'assurer que les données sont présentées clairement et correctement.

Conclusion

L'arrondi des nombres à un nombre spécifié de décimales est un aspect fondamental du traitement des valeurs décimales et doubles en C#. Dans ce tutoriel, nous avons exploré comment arrondir à deux décimales en utilisant la fonction Math.Round. Nous avons également discuté de la manière de traiter les situations où le nombre se situe juste au milieu de deux nombres qui pourraient être arrondis. IronPDF offre un service deessai gratuit sur leur page de licence pour que les développeurs puissent explorer ses fonctionnalités avant de l'acheter. Si vous décidez qu'il s'agit de l'outil adapté à vos besoins, la licence pour un usage commercial commence à 749 $.