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)

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
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 vous permettant d'arrondir des 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 précises est plus efficace, en particulier dans des contextes comme les calculs de devises.

Scénarios courants d'arrondi

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

Basics of Rounding in C#

C# offre un système robuste pour l'arrondissement 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}");
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, 4.5 est équidistant de 4 et 5. Étant donné que 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}");
$vbLabelText   $csharpLabel

La méthode arrondit la valeur initiale 7.34567 à 7.35 car nous avons spécifié de l'arrondir à deux décimales.

Modes d'arrondi des milieux

Lors du traitement des valeurs intermédiaires (celles équidistantes 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 intermédiaires 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
$vbLabelText   $csharpLabel

Spécification d'un mode MidpointRounding

Pour fournir plus de contrôle sur l'opération d'arrondissement pour les valeurs intermédiaires, 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}");
$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}");
$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'exécuter des opérations d'arrondissement spécifiques non couvertes par la méthode Math.Round standard. Écrire des fonctions d'arrondi personnalisées vous donne un contrôle total sur le processus.

Arrondir vers le haut

Pour toujours arrondir vers le haut à l'entier 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}");
$vbLabelText   $csharpLabel

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

Arrondir vers le bas

Inversement, pour arrondir vers le bas à la valeur intégrale la plus proche, on utilise 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}");
$vbLabelText   $csharpLabel

Le nombre décimal 4.7 s'arrondit vers le bas à 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}");
$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}");
$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

  • Double précision : Le type double peut ne pas toujours représenter exactement les nombres décimaux, entraînant des résultats d'arrondissement 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 besoins 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

C# Round (Comment cela 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.");
    }
}
$vbLabelText   $csharpLabel

IronXL

C# Round (Comment cela 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

C# Round (Comment cela 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

C# Round (Comment cela 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 decimal) vous permettra de manipuler 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](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 un 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](Iron Suite) 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.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me