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

C# Arrondir (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

L'arrondi des nombres est un concept mathématique fondamental, souvent appliqué dans des scénarios réels. En C#, la méthode Math.Round facilite cela en permettant d'arrondir les valeurs à la valeur intégrale la plus proche ou à un nombre spécifique de décimales. Ce tutoriel explore les nuances de l'arrondissement en C# et illustre comment vous pouvez exploiter cette méthode puissante.

Introduction à l'arrondi

Arrondir un nombre implique de l'ajuster à la valeur intégrale ou décimale la plus proche pour le simplifier ou se conformer à une exigence particulière. Par exemple, lorsque vous avez le nombre décimal 3.14159, l'arrondir à deux décimales donnerait 3.14.

Pourquoi arrondir les nombres ?

  1. Simplicité : Les nombres arrondis sont souvent plus faciles à lire et à comprendre.
  2. Précision : Dans certains cas, opérer sur des valeurs arrondies plutôt que sur des valeurs exactes est plus efficace, notamment dans des contextes tels que les calculs monétaires.

Scénarios courants d'arrondi

  1. Entier le plus proche : Arrondissez une valeur décimale à son entier le plus proche.
  2. Nombre de décimales spécifié : Arrondissez un nombre à un nombre spécifique de décimales, comme arrondir 15.678 à deux décimales serait 15.68.

Les bases de l'arrondi en C#

C# offre un système robuste pour l'arrondi via la méthode Math.Round. Cette méthode peut accepter divers arguments et paramètres pour personnaliser l'opération d'arrondi.

Arrondir à la valeur intégrale la plus proche

La forme la plus simple de la méthode Math.Round arrondit une valeur double à la valeur intégrale la plus proche. Si le nombre donné est à équidistance de deux entiers, il s'arrondit au nombre pair le plus proche, souvent appelé "arrondi du banquier".

double originalValue = 4.5;
double roundedValue = Math.Round(originalValue);
Console.WriteLine($"Original: {originalValue}, Rounded: {roundedValue}");
double originalValue = 4.5;
double roundedValue = Math.Round(originalValue);
Console.WriteLine($"Original: {originalValue}, Rounded: {roundedValue}");
Dim originalValue As Double = 4.5
Dim roundedValue As Double = Math.Round(originalValue)
Console.WriteLine($"Original: {originalValue}, Rounded: {roundedValue}")
$vbLabelText   $csharpLabel

Dans l’exemple ci-dessus, 4.5 est à équidistance de 4 et 5. Puisque 4 est le nombre pair le plus proche, la méthode renvoie 4.

Arrondir à un nombre spécifique de décimales

Vous pouvez également arrondir un nombre à virgule flottante double à un nombre spécifié de décimales en utilisant un argument supplémentaire :

double value = 7.34567;
double rounded = Math.Round(value, 2); // Rounds to two decimal places
Console.WriteLine($"Original: {value}, Rounded: {rounded}");
double value = 7.34567;
double rounded = Math.Round(value, 2); // Rounds to two decimal places
Console.WriteLine($"Original: {value}, Rounded: {rounded}");
Dim value As Double = 7.34567
Dim rounded As Double = Math.Round(value, 2) ' Rounds to two decimal places
Console.WriteLine($"Original: {value}, Rounded: {rounded}")
$vbLabelText   $csharpLabel

La méthode arrondit la valeur originale 7.34567 à 7.35 puisqu'on a spécifié de l'arrondir à deux décimales.

Modes d'arrondi des milieux

Lorsque vous traitez des valeurs de point milieu (celles à équidistance de deux valeurs potentiellement arrondies), C# offre un mode MidpointRounding pour déterminer comment ces valeurs sont arrondies.

Arrondi par défaut

Par défaut, Math.Round arrondit les valeurs de point milieu au nombre pair le plus proche.

double valueOne = Math.Round(4.5);  // Rounded to 4
double valueTwo = Math.Round(5.5);  // Rounded to 6
double valueOne = Math.Round(4.5);  // Rounded to 4
double valueTwo = Math.Round(5.5);  // Rounded to 6
Dim valueOne As Double = Math.Round(4.5) ' Rounded to 4
Dim valueTwo As Double = Math.Round(5.5) ' Rounded to 6
$vbLabelText   $csharpLabel

Spécification d'un mode MidpointRounding

Pour offrir plus de contrôle sur l'opération d'arrondi pour les valeurs de point milieu, vous pouvez passer un mode MidpointRounding spécifique en tant que paramètre :

double value = 5.5;
double rounded = Math.Round(value, 0, MidpointRounding.AwayFromZero);
Console.WriteLine($"Original: {value}, Rounded: {rounded}");
double value = 5.5;
double rounded = Math.Round(value, 0, MidpointRounding.AwayFromZero);
Console.WriteLine($"Original: {value}, Rounded: {rounded}");
Dim value As Double = 5.5
Dim rounded As Double = Math.Round(value, 0, MidpointRounding.AwayFromZero)
Console.WriteLine($"Original: {value}, Rounded: {rounded}")
$vbLabelText   $csharpLabel

Dans cet exemple, le mode MidpointRounding.AwayFromZero s'assure que le nombre est arrondi à 6.

Utilisation de Math.Round avec des valeurs décimales

Bien que nous ayons discuté de l'arrondi des valeurs doubles, C# prend également en charge l'arrondi des valeurs décimales. Les méthodes sont analogues, mais elles fonctionnent avec le type de données décimal. Voici un exemple :

decimal decimalValue = 5.678m;
decimal roundedDecimal = Math.Round(decimalValue, 1); // Rounds to one decimal place
Console.WriteLine($"Original: {decimalValue}, Rounded: {roundedDecimal}");
decimal decimalValue = 5.678m;
decimal roundedDecimal = Math.Round(decimalValue, 1); // Rounds to one decimal place
Console.WriteLine($"Original: {decimalValue}, Rounded: {roundedDecimal}");
Dim decimalValue As Decimal = 5.678D
Dim roundedDecimal As Decimal = Math.Round(decimalValue, 1) ' Rounds to one decimal place
Console.WriteLine($"Original: {decimalValue}, Rounded: {roundedDecimal}")
$vbLabelText   $csharpLabel

Le nombre décimal 5.678 s'arrondit à 5.7 lorsqu'il est arrondi à une décimale.

Fonctions d'arrondi personnalisées

Parfois, vous pouvez avoir besoin d'effectuer des opérations d'arrondi spécifiques non couvertes par la méthode standard Math.Round. Écrire des fonctions d'arrondi personnalisées vous donne un contrôle total sur le processus.

Arrondir vers le haut

Pour toujours arrondir à l'entier supérieur le plus proche, vous pouvez utiliser la méthode Math.Ceiling :

double value = 4.3;
double roundedUp = Math.Ceiling(value);
Console.WriteLine($"Original: {value}, Rounded Up: {roundedUp}");
double value = 4.3;
double roundedUp = Math.Ceiling(value);
Console.WriteLine($"Original: {value}, Rounded Up: {roundedUp}");
Dim value As Double = 4.3
Dim roundedUp As Double = Math.Ceiling(value)
Console.WriteLine($"Original: {value}, Rounded Up: {roundedUp}")
$vbLabelText   $csharpLabel

Le nombre décimal 4.3 s'arrondit à 5.

Arrondir vers le bas

Inversement, arrondir vers le bas jusqu'à la valeur intégrale la plus proche se fait à l'aide de la méthode Math.Floor :

double value = 4.7;
double roundedDown = Math.Floor(value);
Console.WriteLine($"Original: {value}, Rounded Down: {roundedDown}");
double value = 4.7;
double roundedDown = Math.Floor(value);
Console.WriteLine($"Original: {value}, Rounded Down: {roundedDown}");
Dim value As Double = 4.7
Dim roundedDown As Double = Math.Floor(value)
Console.WriteLine($"Original: {value}, Rounded Down: {roundedDown}")
$vbLabelText   $csharpLabel

Le nombre décimal 4.7 s'arrondit à 4.

Travailler avec une entrée de chaîne de caractères

Dans de nombreuses applications, vous pourriez gérer des valeurs numériques sous forme de chaînes de caractères. L'analyse de la chaîne de caractères en un double ou un décimal, son arrondi, puis sa reconversion peut être effectuée en C#.

Analyse et arrondi

Voici un exemple de comment arrondir une chaîne contenant un nombre décimal :

string originalString = "4.5678";
double parsedValue = double.Parse(originalString);
double rounded = Math.Round(parsedValue, 2); // Rounds to two decimal places
string roundedString = rounded.ToString();
Console.WriteLine($"Original: {originalString}, Rounded: {roundedString}");
string originalString = "4.5678";
double parsedValue = double.Parse(originalString);
double rounded = Math.Round(parsedValue, 2); // Rounds to two decimal places
string roundedString = rounded.ToString();
Console.WriteLine($"Original: {originalString}, Rounded: {roundedString}");
Dim originalString As String = "4.5678"
Dim parsedValue As Double = Double.Parse(originalString)
Dim rounded As Double = Math.Round(parsedValue, 2) ' Rounds to two decimal places
Dim roundedString As String = rounded.ToString()
Console.WriteLine($"Original: {originalString}, Rounded: {roundedString}")
$vbLabelText   $csharpLabel

Original : 4.5678, Arrondi : 4.57

L'arrondi dans les applications financières

Lorsque vous travaillez avec des applications financières, la précision est essentielle. Les erreurs d’arrondi peuvent entraîner des problèmes importants. Dans de tels cas, le type décimal est préféré en raison de sa plus grande précision par rapport au double.

Exemple d'arrondi de devise

L'exemple suivant démontre l'arrondi d'une valeur décimale représentant une devise :

decimal originalValue = 1234.5678m;
decimal roundedValue = Math.Round(originalValue, 2, MidpointRounding.AwayFromZero);
Console.WriteLine($"Original: {originalValue:C}, Rounded: {roundedValue:C}");
decimal originalValue = 1234.5678m;
decimal roundedValue = Math.Round(originalValue, 2, MidpointRounding.AwayFromZero);
Console.WriteLine($"Original: {originalValue:C}, Rounded: {roundedValue:C}");
Dim originalValue As Decimal = 1234.5678D
Dim roundedValue As Decimal = Math.Round(originalValue, 2, MidpointRounding.AwayFromZero)
Console.WriteLine($"Original: {originalValue:C}, Rounded: {roundedValue:C}")
$vbLabelText   $csharpLabel

Le code ci-dessus arrondit la valeur à deux décimales, conformément à la plupart des normes monétaires.

Débogage et résolution des erreurs d'arrondi

Parfois, les opérations d'arrondi peuvent ne pas donner les résultats attendus. Ces divergences pourraient être dues à des problèmes tels que la précision des nombres à virgule flottante avec les valeurs doubles.

Pièges courants

  • Précision Double : Le type double ne représente pas toujours exactement les nombres décimaux, entraînant des résultats d'arrondi inattendus. L'utilisation du type décimal peut atténuer ce problème.
  • Mode MidpointRounding incorrect : Assurez-vous d'utiliser le mode MidpointRounding correct pour vos exigences spécifiques. Utiliser ces modes de manière incorrecte peut entraîner des erreurs d'arrondi.

Comment déboguer

Utilisez des outils comme la journalisation et les points d'arrêt pour suivre la valeur avant et après l'arrondi. L'inspection de la valeur d'origine et des paramètres passés à la méthode d'arrondi peut généralement révéler des incohérences.

Iron Suite

Après avoir maîtrisé les bases de l'arrondi en C#, vous pourriez vous demander comment faire passer vos applications au niveau supérieur, en particulier lors du traitement de formats de données complexes. La Iron Suite peut vous sauver ici. Cette suite comprend des outils puissants comme IronPDF, IronXL, IronOCR et IronBarcode. Plongeons plus profondément dans la façon dont ces outils peuvent s'intégrer à vos opérations d'arrondi et enrichir encore vos applications.

IronPDF

Arrondi en C# (Comment ça fonctionne pour les développeurs) Figure 1

L'IronPDF est une bibliothèque robuste en C# conçue pour la génération de PDF à partir de HTML, l'édition et la gestion. Imaginez un scénario où vous avez besoin de générer un rapport au format PDF après avoir effectué des opérations d'arrondi. IronPDF peut facilement convertir votre code C# en PDF de haute qualité.

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Sample data for invoice
        decimal itemPrice = 49.995m; // Item price before rounding
        decimal taxRate = 0.18m;     // 18% tax rate

        // Round price to 2 decimal places
        decimal roundedPrice = Math.Round(itemPrice, 2);

        // Calculate and round the tax amount
        decimal taxAmount = Math.Round(roundedPrice * taxRate, 2);

        // Calculate the total amount
        decimal totalAmount = Math.Round(roundedPrice + taxAmount, 2);

        // Create simple HTML content for the PDF
        string htmlContent = $@"
            <h1>Invoice</h1>
            <p>Item Price: ${roundedPrice}</p>
            <p>Tax (18%): ${taxAmount}</p>
            <hr>
            <h2>Total Amount: ${totalAmount}</h2>
        ";

        // Generate PDF using IronPDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF file
        pdfDocument.SaveAs("Invoice.pdf");

        Console.WriteLine("PDF invoice generated successfully with rounded values.");
    }
}
using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Sample data for invoice
        decimal itemPrice = 49.995m; // Item price before rounding
        decimal taxRate = 0.18m;     // 18% tax rate

        // Round price to 2 decimal places
        decimal roundedPrice = Math.Round(itemPrice, 2);

        // Calculate and round the tax amount
        decimal taxAmount = Math.Round(roundedPrice * taxRate, 2);

        // Calculate the total amount
        decimal totalAmount = Math.Round(roundedPrice + taxAmount, 2);

        // Create simple HTML content for the PDF
        string htmlContent = $@"
            <h1>Invoice</h1>
            <p>Item Price: ${roundedPrice}</p>
            <p>Tax (18%): ${taxAmount}</p>
            <hr>
            <h2>Total Amount: ${totalAmount}</h2>
        ";

        // Generate PDF using IronPDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF file
        pdfDocument.SaveAs("Invoice.pdf");

        Console.WriteLine("PDF invoice generated successfully with rounded values.");
    }
}
Imports IronPdf
Imports System

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Sample data for invoice
		Dim itemPrice As Decimal = 49.995D ' Item price before rounding
		Dim taxRate As Decimal = 0.18D ' 18% tax rate

		' Round price to 2 decimal places
		Dim roundedPrice As Decimal = Math.Round(itemPrice, 2)

		' Calculate and round the tax amount
		Dim taxAmount As Decimal = Math.Round(roundedPrice * taxRate, 2)

		' Calculate the total amount
		Dim totalAmount As Decimal = Math.Round(roundedPrice + taxAmount, 2)

		' Create simple HTML content for the PDF
		Dim htmlContent As String = $"
            <h1>Invoice</h1>
            <p>Item Price: ${roundedPrice}</p>
            <p>Tax (18%): ${taxAmount}</p>
            <hr>
            <h2>Total Amount: ${totalAmount}</h2>
        "

		' Generate PDF using IronPDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF file
		pdfDocument.SaveAs("Invoice.pdf")

		Console.WriteLine("PDF invoice generated successfully with rounded values.")
	End Sub
End Class
$vbLabelText   $csharpLabel

IronXL

Arrondi en C# (Comment ça fonctionne pour les développeurs) Figure 2

L'IronXL offre des fonctionnalités pour travailler avec des fichiers Excel, permettant aux développeurs C# de lire, écrire et manipuler des feuilles de calcul Excel sans problème. Avec IronXL, vous pouvez récupérer des données décimales ou doubles à partir de feuilles Excel, effectuer des opérations d'arrondi en C#.

IronOCR

Arrondi en C# (Comment ça fonctionne pour les développeurs) Figure 3

L'IronOCR est une bibliothèque avancée de reconnaissance optique de caractères (OCR) pour C# qui peut reconnaître et extraire le texte des images et des PDF. Supposons que vous ayez des documents ou des images numérisés contenant des données numériques. Avec IronOCR, vous pouvez extraire ces données, les traiter ou les arrondir en C#.

IronBarcode

Arrondi en C# (Comment ça fonctionne pour les développeurs) Figure 4

L'IronBarcode est un outil puissant pour générer, lire et classer les codes-barres et les codes QR en .NET. Dans les contextes où les données arrondies doivent être codées dans des codes-barres (par exemple, le prix des produits dans une application de vente au détail), IronBarcode peut être inestimable.

Conclusion

L'arrondi en C# est un sujet multifacette avec des applications dans divers domaines. Comprendre les méthodes intégrées comme Math.Round, Math.Floor et Math.Ceiling, et savoir quand utiliser le type de données approprié (double ou décimal) vous permettra de gérer efficacement les données numériques.

Utiliser l'arrondi en C# aide à rendre les chiffres plus faciles à utiliser. Mais que faire si vous voulez faire encore plus avec ces chiffres ? C'est là que l'Iron Suite entre en jeu. C'est un ensemble d'outils qui peuvent vous aider à travailler avec les fichiers PDF, les fichiers Excel, le texte dans les images et les codes-barres.

Voici la partie excitante : vous pouvez essayer ces outils gratuitement avec une licence d'essai pour voir si vous les aimez. Si vous décidez d'en acheter un, chacun coûte une liteLicense. Mais si vous voulez tous les acheter, vous pouvez obtenir l'ensemble complet pour seulement deux outils. C'est comme obtenir quatre outils mais ne payer que pour deux ! Consultez la page de licence de l'Iron Suite pour plus d'informations.

Questions Fréquemment Posées

Comment puis-je arrondir des nombres en C# pour des applications financières ?

En C#, vous pouvez utiliser la méthode `Math.Round` avec le type de donnée `decimal` pour une précision plus élevée dans les applications financières. Il est recommandé d'utiliser `MidpointRounding.AwayFromZero` pour garantir un arrondi précis pour les transactions financières.

Quel est le mode d'arrondissement par défaut en C# ?

Le mode d'arrondissement par défaut en C# est 'arrondi du banquier', qui arrondit les valeurs à mi-chemin vers le nombre pair le plus proche en utilisant l'option `MidpointRounding.ToEven`.

Comment fonctionne l'arrondissement lors de la conversion de HTML en PDF en C# ?

Lors de la conversion de HTML en PDF à l'aide d'IronPDF, vous pouvez incorporer des opérations d'arrondissement pour les données numériques en traitant les données en C# avant de les rendre dans le document PDF.

Puis-je utiliser les méthodes d'arrondissement C# pour les données dans les fichiers Excel ?

Oui, vous pouvez utiliser IronXL pour manipuler les fichiers Excel en C#, en appliquant les méthodes d'arrondissement aux données numériques dans les cellules à l'aide de `Math.Round` pour une présentation des données précise.

Quelle est l'importance de l'énumération MidpointRounding en C# ?

L'énumération `MidpointRounding` en C# propose des options pour arrondir des valeurs à mi-parcours, telles que `AwayFromZero` et `ToEven`, permettant aux développeurs de contrôler comment l'arrondissement est appliqué aux nombres qui se situent exactement entre deux entiers.

Comment appliquer des fonctions d'arrondissement personnalisées en C# ?

Vous pouvez créer des fonctions d'arrondissement personnalisées en C# en écrivant votre propre logique pour gérer des règles d'arrondissement spécifiques au-delà de la méthode standard `Math.Round`, qui peut être intégrée aux outils d'Iron Software pour un traitement de données amélioré.

Les valeurs d'entrée de chaîne peuvent-elles être arrondies en C# ?

Oui, les entrées sous forme de chaînes peuvent être analysées en types numériques comme `double` ou `decimal` en C#, vous permettant d'appliquer des méthodes d'arrondissement et de les reconvertir en chaînes pour une utilisation ultérieure.

Comment des outils comme IronOCR et IronBarcode peuvent-ils bénéficier des opérations d'arrondissement ?

IronOCR peut utiliser l'arrondissement pour traiter les données numériques extraites de la reconnaissance de texte, tandis qu'IronBarcode peut intégrer des valeurs arrondies dans les données de code-barres pour un encodage précis des informations numériques.

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