Arredondar um número de ponto flutuante de dupla precisão (double) para um inteiro em C# é uma tarefa fundamental que surge frequentemente na programação, especialmente comum quando os cálculos produzem valores de ponto flutuante de dupla precisão, mas exigem valores inteiros para operações posteriores. O processo envolve a conversão de um valor double, que pode incluir casas decimais, para o número inteiro mais próximo. Isso pode ser feito usando vários métodos, cada um seguindo uma convenção de arredondamento específica.
Ao longo deste guia, exploraremos diferentes estratégias e funções usadas em C# para arredondar valores double para inteiros, ajudando os desenvolvedores a entender as implicações e aplicações de cada método. Também exploraremos os recursos da biblioteca IronPDF .NET PDF , uma ferramenta poderosa para criar documentos PDF em C#.
Em C#, o método Math.Round é a principal ferramenta para arredondar valores do tipo double para o inteiro mais próximo. Esta função arredonda um valor double para o valor inteiro mais próximo, proporcionando um alto grau de controle sobre o processo de arredondamento através de sobrecargas que permitem especificar um número determinado de dígitos fracionários e a estratégia de arredondamento. Por exemplo, quando um valor double está exatamente no meio entre dois inteiros, a convenção de arredondamento determina se o valor será arredondado para cima ou para baixo.
Aqui está um exemplo básico do método Math.Round :
public static void Main()
{
double myDouble = 9.5;
int myInt = (int)Math.Round(myDouble);
Console.WriteLine("The rounded integer value is: " + myInt);
}Imports System
Public Shared Sub Main()
Dim myDouble As Double = 9.5
Dim myInt As Integer = CInt(Math.Truncate(Math.Round(myDouble)))
Console.WriteLine("The rounded integer value is: " & myInt)
End SubNeste código-fonte, Math.Round é usado para arredondar o valor double 9.5 para o inteiro mais próximo. O método retorna 10 , pois arredonda para o número mais próximo. Este é o resultado esperado ao arredondar valores positivos que estão exatamente no meio entre dois valores inteiros.
Outra abordagem comum em C# para converter valores double em valores inteiros é por meio de conversão explícita. A conversão explícita envolve a conversão direta do valor double para int, o que elimina as casas decimais. Isso significa que ele não arredonda para o inteiro mais próximo, mas sim para o inteiro menor mais próximo. Este método é útil quando você precisa apenas remover os dígitos fracionários sem considerar o valor inteiro mais próximo.
Eis como você pode realizar a conversão explícita:
public static void Main()
{
double myDouble = 9.9;
int myInt = (int)myDouble;
Console.WriteLine("The integer value after explicit conversion is: " + myInt);
}Imports System
Public Shared Sub Main()
Dim myDouble As Double = 9.9
Dim myInt As Integer = CInt(Math.Truncate(myDouble))
Console.WriteLine("The integer value after explicit conversion is: " & myInt)
End SubNo exemplo acima, a saída será 9 porque a conversão explícita simplesmente descarta os dígitos fracionários de 9,9 , resultando em um número inteiro menor. Este método é rápido, mas pode não ser apropriado quando é necessário um arredondamento preciso de acordo com convenções de arredondamento específicas.
Além de Math.Round e da conversão explícita, o C# oferece outros métodos para arredondar valores double, que atendem a diferentes necessidades. Por exemplo, Math.Floor e Math.Ceiling oferecem opções para arredondar sempre os valores double para o menor número inteiro ou para o maior número inteiro, respectivamente. Math.Floor é particularmente útil para arredondar sempre para baixo, mesmo com valores negativos, enquanto Math.Ceiling garante o arredondamento para cima.
Vejamos alguns exemplos desses métodos:
public static void Main()
{
double myDouble = 9.2;
int floorInt = (int)Math.Floor(myDouble);
int ceilingInt = (int)Math.Ceiling(myDouble);
Console.WriteLine("Rounded down: " + floorInt);
Console.WriteLine("Rounded up: " + ceilingInt);
}Imports System
Public Shared Sub Main()
Dim myDouble As Double = 9.2
Dim floorInt As Integer = CInt(Math.Truncate(Math.Floor(myDouble)))
Dim ceilingInt As Integer = CInt(Math.Truncate(Math.Ceiling(myDouble)))
Console.WriteLine("Rounded down: " & floorInt)
Console.WriteLine("Rounded up: " & ceilingInt)
End SubNo código acima, Math.Floor retorna 9 a partir de 9,2 , arredondando para o número inteiro mais próximo com menos casas decimais, enquanto Math.Ceiling retorna 10 , aproximando-se do próximo inteiro positivo. Esses métodos são essenciais quando a estratégia de arredondamento deve privilegiar valores inteiros maiores ou menores sem ambiguidade.
Explore os recursos do IronPDF para descobrir como esta biblioteca .NET permite que desenvolvedores C# criem e gerenciem arquivos PDF diretamente do HTML. Ele utiliza um mecanismo de renderização do Chrome para garantir que os PDFs tenham a mesma aparência que em um navegador da web. Isso o torna perfeito para a criação de relatórios baseados na web. O IronPDF consegue lidar com tarefas complexas, como adicionar assinaturas digitais, alterar layouts de documentos e inserir cabeçalhos, rodapés ou marcas d'água personalizados. É fácil de usar porque permite que os desenvolvedores trabalhem com tecnologias web familiares, como HTML, CSS, JavaScript e imagens, para criar ou editar documentos PDF.
Com o IronPDF, a principal funcionalidade é a conversão de HTML para PDF usando o IronPDF , mantendo os layouts e estilos. Ele pode gerar PDFs a partir de diversos conteúdos da web, como relatórios, faturas e documentação, convertendo arquivos HTML, URLs ou strings HTML em arquivos 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 ClassPara integrar o IronPDF com as funcionalidades de arredondamento do C#, os desenvolvedores podem combinar os recursos de geração de PDF do IronPDF com operações matemáticas em C#. Isso é particularmente útil em aplicações financeiras ou de relatórios, onde os dados numéricos precisam ser apresentados de forma clara e precisa. Por exemplo, você pode gerar faturas ou resumos financeiros onde os valores são arredondados para o número inteiro mais próximo para garantir a legibilidade e a conformidade com as normas contábeis.
Aqui está um exemplo de como você pode usar o IronPDF juntamente com o método Math.Round do C# para criar um PDF que inclua dados numéricos arredondados:
using IronPdf;
using System;
public class PDFGenerationWithRounding
{
public static void Main()
{
License.LicenseKey = "License-Key";
// Initialize the HTML to PDF renderer
var renderer = new ChromePdfRenderer();
// Example data
double transactionAmount = 123.456;
int roundedAmount = (int)Math.Round(transactionAmount);
// HTML content including the rounded amount
string htmlContent = $@"
<html>
<head>
<title>Transaction Summary</title>
</head>
<body>
<h1>Transaction Details</h1>
<p>Original Amount: ${transactionAmount}</p>
<p>Rounded Amount: ${roundedAmount}</p>
</body>
</html>";
// Convert the HTML to a PDF document
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("TransactionSummary.pdf");
Console.WriteLine("The PDF document has been generated with rounded figures.");
}
}Imports IronPdf
Imports System
Public Class PDFGenerationWithRounding
Public Shared Sub Main()
License.LicenseKey = "License-Key"
' Initialize the HTML to PDF renderer
Dim renderer = New ChromePdfRenderer()
' Example data
Dim transactionAmount As Double = 123.456
Dim roundedAmount As Integer = CInt(Math.Truncate(Math.Round(transactionAmount)))
' HTML content including the rounded amount
Dim htmlContent As String = $"
<html>
<head>
<title>Transaction Summary</title>
</head>
<body>
<h1>Transaction Details</h1>
<p>Original Amount: ${transactionAmount}</p>
<p>Rounded Amount: ${roundedAmount}</p>
</body>
</html>"
' Convert the HTML to a PDF document
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("TransactionSummary.pdf")
Console.WriteLine("The PDF document has been generated with rounded figures.")
End Sub
End Class
Neste exemplo, o IronPDF renderiza uma string HTML simples em um arquivo PDF, incorporando dados dinâmicos que incluem um valor de transação arredondado para o número inteiro mais próximo. Essa abordagem é altamente adaptável, permitindo que os desenvolvedores criem documentos mais complexos, personalizados para suas necessidades específicas, com precisão e facilidade de uso como prioridades no processo.
Arredondar um número double para int em C# é um processo versátil, influenciado pela natureza do valor double, pelo contexto do arredondamento e pela precisão exigida na aplicação. Seja usando Math.Round para arredondamento de inteiros mais próximos, conversão explícita para truncamento direto ou outros métodos como Math.Floor e Math.Ceiling para direções de arredondamento específicas, o C# fornece métodos para lidar com o arredondamento de valores double de forma eficaz. IronPDF tem uma avaliação gratuita do IronPDF e os preços começam a partir de $999.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
