Math.Round C# (Wie es für Entwickler funktioniert)

In der C#-Programmierung spielt die Math.Round-Methode eine zentrale Rolle beim Runden von numerischen Werten, insbesondere beim Umgang mit doppelwertigen und dezimalwertigen Datentypen. Mit dieser Methode können Entwickler einen gegebenen numerischen Wert auf den nächsten ganzzahligen Wert oder eine bestimmte Anzahl von weniger Nachkommastellen runden und so Flexibilität und Präzision bei mathematischen Operationen erreichen. Es stehen mehrere Rundungsarten zur Verfügung, z. B. die Mittelwertrundung. In diesem Artikel werden wir uns mit den Feinheiten von Math.Round in C# befassen und die verschiedenen Aspekte und Einsatzszenarien untersuchen. In den folgenden Abschnitten dieses Artikels werden wir uns mit der Verwendung der IronPDF bibliothek von Iron Software für den Umgang mit PDFs.

Grundlagen von Math.Round in C##

Die Methode Math.Round

Die Methode Math.Round in C# ist ein leistungsfähiges Werkzeug zum Runden von Nachkommastellen unter Verwendung einer bestimmten Rundungskonvention. Sie ist Teil des System-Namensraums und bietet mehrere Überladungen, um verschiedene Rundungsoperationen zu ermöglichen.

/* 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)
'

Abrunden von Doppelwerten

Beim Umgang mit Double-Werten wird Math.Round üblicherweise verwendet, um eine Zahl auf die nächste Ganzzahl zu runden. Zum Beispiel:

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

In diesem Beispiel rundet die Methode Math.Round den ursprünglichen Double-Wert 3,75 auf den nächsten ganzzahligen Wert, also 4.

Rundung des Dezimalwerts

Ähnlich verhält es sich mit der Methode Math.Round für Dezimalwerte. Betrachten Sie das folgende Beispiel:

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

Hier wird die Methode Math.Round verwendet, um die Dezimalzahl 8,625 auf zwei Dezimalstellen zu runden, was den gerundeten Wert 8,63 ergibt.

Nächstgelegener Integer-Wert

Der Hauptzweck von Math.Round besteht darin, einen gegebenen numerischen Wert auf die nächstliegende Ganzzahl zu runden. Wenn der Bruchteil genau in der Mitte zwischen zwei ganzen Zahlen liegt, folgt die Methode einer bestimmten Rundungskonvention. Die Aufzählung MidpointRounding kann als Argument in der Methode Math.Round verwendet werden und bestimmt, ob auf die nächste gerade oder ungerade Zahl gerundet werden soll.

Es sind mehrere Arten von Rundungsoperationen möglich, wie in der obigen Abbildung dargestellt. Die Namen selbst sind selbsterklärend.

Spezifizierte Rundungskonvention

Sehen wir uns an, wie der MidpointRounding-Modus eingesetzt werden kann:

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

In diesem Beispiel rundet MidpointRounding.ToEven beim Runden des Wertes auf 5,5 auf die nächste gerade Zahl (was zu 6), während MidpointRounding.AwayFromZero von Null weg rundet und 5 ergibt.

Rundung auf die angegebene Anzahl von Dezimalstellen

Um eine Zahl auf eine bestimmte Anzahl von Nachkommastellen zu runden, erlaubt die Methode Math.Round die Angabe eines zusätzlichen Parameters, der die Anzahl der Nachkommastellen angibt:

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

Hier wird die Dezimalzahl 9,123456 auf drei Dezimalstellen gerundet, was den gerundeten Wert 9,123 ergibt.

Midpoint-Werte und Rundungskonventionen in C#

Ein Mittelpunktswert entsteht, wenn der Wert nach der niedrigstwertigen Stelle des Ergebnisses genau in der Mitte zwischen zwei Zahlen liegt. So ist beispielsweise 2,56500 ein Mittelwert, wenn auf zwei Dezimalstellen gerundet wird, 2,57, und 3,500 ist ein Mittelwert, wenn auf eine ganze Zahl 4 gerundet wird. Die Herausforderung besteht darin, den nächstgelegenen Wert in der Rundungsstrategie für Mittelwerte ohne eine definierte Rundungskonvention zu ermitteln.

Die Round-Methode in C# unterstützt zwei Rundungskonventionen für den Umgang mit Mittelwerten:

Rundung von Null weg: Die Mittelwerte werden auf die nächsthöhere Zahl von Null weg gerundet. Beispielsweise wird 3,75 auf 3,8 aufgerundet, 3,85 auf 3,9 aufgerundet, -3,75 auf -3,8 abgerundet und -3,85 auf -3,9 abgerundet. Diese Methode wird durch das Aufzählungselement MidpointRounding.AwayFromZero dargestellt.

Aufrunden auf die nächste gerade Zahl (Banker's Rounding): Die Mittelwerte werden auf die nächstliegende gerade Zahl gerundet. Zu den Beispielen gehören 3,75 und 3,85, die auf 3,8 gerundet werden, sowie -3,75 und -3,85, die auf -3,8 gerundet werden. Dieser Rundungsansatz wird durch das Aufzählungselement MidpointRounding.ToEven angezeigt.

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)

Ausgabe

MidpointRounding Modi

AwayFromZero: 1

Die AwayFromZero-Rundungsstrategie rundet auf die nächstliegende Zahl, wenn eine Zahl in der Mitte zwischen zwei anderen liegt.

ToZero: 2

Diese Strategie zeichnet sich durch gezieltes Runden gegen Null aus. Das Ergebnis kommt dem unendlich genauen Ergebnis am nächsten und ist nicht größer als dieses.

ToEven: 0

Bei dieser Strategie wird auf die nächste Zahl gerundet, und wenn eine Zahl in der Mitte zwischen zwei anderen liegt, wird sie auf die nächste gerade Zahl gerundet.

ToNegativeInfinity: 3

Bei dieser Strategie wird nach unten gerundet, wobei das Ergebnis dem unendlich genauen Ergebnis am nächsten kommt und nicht größer ist als dieses.

ToPositiveInfinity: 4

Bei dieser Strategie wird nach oben aufgerundet, wobei das Ergebnis dem unendlich genauen Ergebnis am nächsten kommt, aber nicht kleiner ist als dieses.

Präzision und doppelte Präzision Fließkomma

Präzision und doppelte Werte

Bei der Arbeit mit doppelpräzisen Fließkommazahlen ist es wichtig, die potenzielle Ungenauigkeit zu verstehen, die durch die Art der Fließkommadarstellung bedingt ist. Die Math.Round-Methode hilft dabei, Präzisionsprobleme zu mildern, indem sie Werte auf die nächste Ganzzahl oder eine bestimmte Anzahl von Dezimalstellen rundet.

Angegebene Genauigkeit mit Math.Round

Entwickler können die Math.Round-Methode nutzen, um die gewünschte Genauigkeit bei ihren Berechnungen zu erreichen:

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

In diesem Beispiel wird der Double-Wert 123,456789 auf vier Dezimalstellen gerundet, so dass sich der genauere Wert 123,4568 ergibt.

Midpoint-Rundungsstrategie

Handhabung von Mittelwerten

Die Strategie der Mittelpunktsrundung wird entscheidend, wenn ein Bruchwert genau in der Mitte zwischen zwei ganzen Zahlen liegt. Die Math.Round-Methode wendet die angegebene MidpointRounding-Strategie an, um solche Fälle zu lösen.

Beispiel für Mittelwertrundung

Betrachten Sie das folgende Beispiel, in dem die Mittelwertrundung verwendet wird:

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

Hier wird der Wert 7,5 von Null abgerundet, was den gerundeten Wert 8 ergibt.

Anwendung in realen Szenarien

Im Folgenden finden Sie einige Beispiele für die Anwendung in verschiedenen Kontexten:

Finanzielle Berechnungen

Bei Finanzanwendungen ist eine präzise Rundung von entscheidender Bedeutung. Bei der Berechnung von Zinssätzen, der Umrechnung von Währungen oder bei Steuerberechnungen kann die Methode Math.Round verwendet werden, um sicherzustellen, dass die Ergebnisse auf die entsprechende Anzahl von Dezimalstellen gerundet werden, um die Finanzstandards einzuhalten.

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

Benutzeroberfläche Display

Bei der Darstellung von Zahlenwerten in einer Benutzeroberfläche ist es üblich, die Zahlen zur besseren Lesbarkeit zu runden. In einem Dashboard, das beispielsweise Temperaturwerte oder Finanzdaten anzeigt, kann die Rundung mit Math.Round die Klarheit der dargestellten Informationen verbessern.

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

Statistische Analyse

Bei statistischen Analysen ist eine präzise Rundung unerlässlich, um Verzerrungen oder Ungenauigkeiten zu vermeiden. Ob bei der Berechnung von Mittelwert, Median oder anderen statistischen Maßen, die Math.Round-Methode kann dabei helfen, die Ergebnisse mit der gewünschten Präzision darzustellen.

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

Wissenschaftliche Berechnungen

Bei wissenschaftlichen Anwendungen ist die Präzision entscheidend. Beim Umgang mit experimentellen Daten oder wissenschaftlichen Berechnungen stellt das Runden mit Math.Round sicher, dass die Ergebnisse aussagekräftig und genau dargestellt werden.

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

Mathematische Modellierung

Bei der Umsetzung mathematischer Modelle oder Simulationen kann das Runden notwendig sein, um komplexe Berechnungen zu vereinfachen. Die Math.Round-Methode kann angewendet werden, um die Genauigkeit der Zwischenergebnisse im Modellierungsprozess zu kontrollieren.

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

Entwicklung von Spielen

Bei der Entwicklung von Spielen ist die numerische Präzision für physikalische Berechnungen, Positionierung und andere mathematische Operationen entscheidend. Die Methode Math.Round kann verwendet werden, um sicherzustellen, dass spielbezogene Werte auf ein angemessenes Präzisionsniveau gerundet werden.

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

In jedem dieser Szenarien ermöglicht die Math.Round-Methode den Entwicklern, die Genauigkeit numerischer Werte zu kontrollieren und so die Genauigkeit und Lesbarkeit ihrer Anwendungen zu verbessern.

Einführung in IronPDF

Das Hauptmerkmal von IronPDF ist seine HTML zu PDF funktion, wobei Layouts und Stile beibehalten werden. Es wandelt Webinhalte in PDF-Dateien um, die sich hervorragend für Berichte, Rechnungen und Dokumentationen eignen. Sie können HTML-Dateien, URLs und HTML-Strings problemlos in PDFs umwandeln.

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

Jetzt wollen wir sehen, wie wir PDF-Dokumente mit IronPDF C# PDF-Bibliothek von Iron Software.

Einrichtung

Sie können IronPDF entweder über die NuGet-Paketmanager-Konsole oder den Visual Studio-Paketmanager installieren.

dotnet add package IronPdf

dotnet add package IronPdf

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

Installieren Sie IronPDF mit dem NuGet Package Manager, indem Sie in der Suchleiste nach "ironpdf" suchen.

IronPDF zum Erzeugen einer PDF-Datei verwenden

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")

Im obigen Code generieren wir ein HTML-Dokument für die Artikel im Warenkorb und speichern es dann mit IronPDF als PDF-Dokument.

Ausgabe

Lizenzierung (kostenlose Testversion verfügbar)

Um die Funktionalität des bereitgestellten Codes freizuschalten, ist es notwendig, einen Lizenzschlüssel zu erwerben. Sie können einen Testschlüssel von folgender Adresse erhalten *hierund sie muss in die Datei appsettings.json eingefügt werden.

"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"

Geben Sie Ihre E-Mail-ID an, um eine Testlizenz zu erhalten.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Math.Round-Methode in C# ein vielseitiges Werkzeug zum Runden von Doppel- und Dezimalwerten ist, das Entwicklern die Flexibilität bietet, auf die nächste Ganzzahl oder eine bestimmte Anzahl von Dezimalstellen zu runden. Das Verständnis der Feinheiten von Math.Round, einschließlich der Behandlung von Mittelpunktswerten und der Verwendung von MidpointRounding-Strategien, ist für genaue und zuverlässige mathematische Operationen in der C#-Programmierung unerlässlich. Egal, ob es sich um Finanzberechnungen, die Anzeige von Benutzeroberflächen oder andere Szenarien handelt, die eine präzise numerische Darstellung erfordern, die Math.Round-Methode erweist sich als unverzichtbarer Bestandteil des Werkzeugkastens eines Programmierers. Außerdem haben wir gesehen, dass IronPDF eine vielseitige Bibliothek zur Erstellung von PDF-Dokumenten ist.