Formato de intervalo de tempo em C# (Como funciona para desenvolvedores)

O que é TimeSpan em C#?

A estrutura TimeSpan em C# representa um intervalo de tempo e pode ser usada para medir durações ou a diferença entre dois valores de data e hora. Trata-se de uma estrutura versátil, que permite aos desenvolvedores realizar diversos cálculos relacionados ao tempo, tais como:

• Calcular a duração das tarefas.
• Medir as diferenças de tempo entre eventos.
• Criação de cronômetros para medição de desempenho.

A importância do TimeSpan reside na sua capacidade de simplificar e padronizar a gestão de intervalos de tempo em diversas aplicações, facilitando o tratamento de várias tarefas relacionadas ao tempo.

Métodos básicos para criar e usar TimeSpan

Criar um objeto TimeSpan é simples, com vários métodos disponíveis, tais como:

• TimeSpan.FromHours(double hours): Cria um TimeSpan representando o número de horas especificado.
• TimeSpan.FromMinutes(double minutes): Cria um TimeSpan representando o número de minutos especificado.
• TimeSpan.FromSeconds(double seconds): Cria um TimeSpan representando o número de segundos especificado.

Aqui está um exemplo que ilustra como criar instâncias de TimeSpan e usá-las em cálculos:

// Creating TimeSpan instances
TimeSpan taskDuration = TimeSpan.FromHours(2.5); // 2 hours and 30 minutes
TimeSpan breakDuration = TimeSpan.FromMinutes(15); // 15 minutes
// Calculating total time spent
TimeSpan totalTime = taskDuration + breakDuration;
Console.WriteLine($"Total time spent: {totalTime}"); // Outputs: 02:45:00

// Creating TimeSpan instances
TimeSpan taskDuration = TimeSpan.FromHours(2.5); // 2 hours and 30 minutes
TimeSpan breakDuration = TimeSpan.FromMinutes(15); // 15 minutes
// Calculating total time spent
TimeSpan totalTime = taskDuration + breakDuration;
Console.WriteLine($"Total time spent: {totalTime}"); // Outputs: 02:45:00

' Creating TimeSpan instances
Dim taskDuration As TimeSpan = TimeSpan.FromHours(2.5) ' 2 hours and 30 minutes
Dim breakDuration As TimeSpan = TimeSpan.FromMinutes(15) ' 15 minutes
' Calculating total time spent
Dim totalTime As TimeSpan = taskDuration.Add(breakDuration)
Console.WriteLine($"Total time spent: {totalTime}") ' Outputs: 02:45:00

Isso exibe a seguinte saída:

Formatação do intervalo de tempo para exibição

Quando se trata de exibir valores TimeSpan, o C# oferece diversas opções de formatação. Os especificadores de saída são usados ​​para controlar como os valores de TimeSpan são exibidos ao convertê-los em strings. Esses especificadores definem o formato de saída dos objetos TimeSpan, ajudando a personalizar sua representação no relatório PDF final. Os especificadores de formato mais comumente usados ​​incluem:

• "c": O formato invariante (ex.: 1.02:30:45 para 1 dia, 2 horas, 30 minutos e 45 segundos).
• "g": O especificador de formato padrão, que exclui a parte dos dias se for zero (ex.: 02:30:45).
• Formatos personalizados: Você pode definir formatos personalizados para atender a necessidades específicas, como exibir apenas horas e minutos ou dias com horas.

Aqui estão exemplos de formatação do TimeSpan para saída em relatórios ou registros:

TimeSpan duration = new TimeSpan(1, 2, 30, 45); // 1 day, 2 hours, 30 minutes, 45 seconds
// Default "c" format string produces the output: 1.02:30:45
Console.WriteLine(duration.ToString("c"));
// Custom format "hh:mm:ss" outputs: 26:30:45
Console.WriteLine(duration.ToString(@"hh\:mm\:ss")); 
// Custom format with days, outputs: 1d 02h 30m
Console.WriteLine(duration.ToString(@"d'd 'hh'h 'mm'm '"));

TimeSpan duration = new TimeSpan(1, 2, 30, 45); // 1 day, 2 hours, 30 minutes, 45 seconds
// Default "c" format string produces the output: 1.02:30:45
Console.WriteLine(duration.ToString("c"));
// Custom format "hh:mm:ss" outputs: 26:30:45
Console.WriteLine(duration.ToString(@"hh\:mm\:ss")); 
// Custom format with days, outputs: 1d 02h 30m
Console.WriteLine(duration.ToString(@"d'd 'hh'h 'mm'm '"));

Dim duration As New TimeSpan(1, 2, 30, 45) ' 1 day, 2 hours, 30 minutes, 45 seconds
' Default "c" format string produces the output: 1.02:30:45
Console.WriteLine(duration.ToString("c"))
' Custom format "hh:mm:ss" outputs: 26:30:45
Console.WriteLine(duration.ToString("hh\:mm\:ss"))
' Custom format with days, outputs: 1d 02h 30m
Console.WriteLine(duration.ToString("d'd 'hh'h 'mm'm '"))

Este exemplo exibe a seguinte saída:

Configurando o IronPDF em seu projeto .NET

Install-Package IronPdf

using IronPdf;

using IronPdf;

Imports IronPdf

Gerando relatórios baseados em tempo com o IronPDF

using IronPdf;
public static void Main(string[] args)
{
    TimeSpan duration = new TimeSpan(9, 30, 25);
    var employees = new List<(string name, TimeSpan timeSpan)> {
    ("Jane Doe",  duration),
    ("John Doe", duration)
    };
    GenerateWorkLogReport(employees);
}
public static void GenerateWorkLogReport(List<(string Employee, TimeSpan Duration)> workLogs)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>";
    foreach (var log in workLogs)
    {
        htmlContent += $"<tr><td>{log.Employee}</td><td>{log.Duration.ToString(@"hh\:mm\:ss")}</td></tr>";
    }
    htmlContent += "</table>";
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    pdf.SaveAs("WorkLogReport.pdf");
}

using IronPdf;
public static void Main(string[] args)
{
    TimeSpan duration = new TimeSpan(9, 30, 25);
    var employees = new List<(string name, TimeSpan timeSpan)> {
    ("Jane Doe",  duration),
    ("John Doe", duration)
    };
    GenerateWorkLogReport(employees);
}
public static void GenerateWorkLogReport(List<(string Employee, TimeSpan Duration)> workLogs)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>";
    foreach (var log in workLogs)
    {
        htmlContent += $"<tr><td>{log.Employee}</td><td>{log.Duration.ToString(@"hh\:mm\:ss")}</td></tr>";
    }
    htmlContent += "</table>";
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    pdf.SaveAs("WorkLogReport.pdf");
}

Imports IronPdf
Public Shared Sub Main(ByVal args() As String)
	Dim duration As New TimeSpan(9, 30, 25)
	Dim employees = New List(Of (name As String, timeSpan As TimeSpan)) From {("Jane Doe", duration), ("John Doe", duration)}
	GenerateWorkLogReport(employees)
End Sub
Public Shared Sub GenerateWorkLogReport(ByVal workLogs As List(Of (Employee As String, Duration As TimeSpan)))
	Dim renderer As New ChromePdfRenderer()
	Dim htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>"
	For Each log In workLogs
		htmlContent &= $"<tr><td>{log.Employee}</td><td>{log.Duration.ToString("hh\:mm\:ss")}</td></tr>"
	Next log
	htmlContent &= "</table>"
	Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
	pdf.SaveAs("WorkLogReport.pdf")
End Sub

Personalizando a saída do TimeSpan para diferentes casos de uso

Personalizar a saída do TimeSpan pode melhorar significativamente a legibilidade dos seus relatórios. Por exemplo, se você precisar exibir apenas horas e minutos, poderá formatar seu TimeSpan de acordo. Neste exemplo, usaremos os mesmos dados de funcionários que criamos no exemplo anterior e formataremos o TimeSpan para mostrar apenas as horas e os minutos trabalhados. Os segundos não são necessários para os registros neste cenário e simplesmente ocupam espaço desnecessário, então vamos omiti-los:

using IronPdf;
class Program
{
    public static void Main(string[] args)
    {
        TimeSpan duration = new TimeSpan(9, 30, 25);
        var employees = new List<(string name, TimeSpan timeSpan)> {
        ("Jane Doe",  duration),
        ("John Doe", duration)
        };
        GenerateWorkLogReport(employees);
    }
    public static void GenerateWorkLogReport(List<(string Employee, TimeSpan Duration)> workLogs)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>";
        foreach (var log in workLogs)
        {
            // Custom format string to format the TimeSpan value for display
            string formattedDuration = log.Duration.ToString(@"hh\:mm");
            htmlContent += $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>";
        }
        htmlContent += "</table>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("WorkLogReport.pdf");
    }
}

using IronPdf;
class Program
{
    public static void Main(string[] args)
    {
        TimeSpan duration = new TimeSpan(9, 30, 25);
        var employees = new List<(string name, TimeSpan timeSpan)> {
        ("Jane Doe",  duration),
        ("John Doe", duration)
        };
        GenerateWorkLogReport(employees);
    }
    public static void GenerateWorkLogReport(List<(string Employee, TimeSpan Duration)> workLogs)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>";
        foreach (var log in workLogs)
        {
            // Custom format string to format the TimeSpan value for display
            string formattedDuration = log.Duration.ToString(@"hh\:mm");
            htmlContent += $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>";
        }
        htmlContent += "</table>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("WorkLogReport.pdf");
    }
}

Imports IronPdf
Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		Dim duration As New TimeSpan(9, 30, 25)
		Dim employees = New List(Of (name As String, timeSpan As TimeSpan)) From {("Jane Doe", duration), ("John Doe", duration)}
		GenerateWorkLogReport(employees)
	End Sub
	Public Shared Sub GenerateWorkLogReport(ByVal workLogs As List(Of (Employee As String, Duration As TimeSpan)))
		Dim renderer As New ChromePdfRenderer()
		Dim htmlContent = "<h1>Work Log Report</h1><table border='1'><tr><th>Employee</th><th>Duration</th></tr>"
		For Each log In workLogs
			' Custom format string to format the TimeSpan value for display
			Dim formattedDuration As String = log.Duration.ToString("hh\:mm")
			htmlContent &= $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>"
		Next log
		htmlContent &= "</table>"
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs("WorkLogReport.pdf")
	End Sub
End Class

Neste exemplo, o ToString(@"hh\:mm") formata o TimeSpan como 09:30 (total de horas e minutos) usando strings de formato personalizadas. Dessa forma, você pode garantir que o intervalo de tempo seja exibido da maneira que desejar, mantendo a legibilidade do documento. Isso também pode ser feito ao contrário, analisando uma string e convertendo-a em um TimeSpan. A análise sintática converte strings de entrada que seguem um formato específico (como "hh:mm" ou "d.hh:mm") em um objeto TimeSpan real com o qual o C# pode trabalhar programaticamente.

Lidar com grandes intervalos de tempo e formatar para facilitar a leitura.

Ao lidar com valores TimeSpan maiores, é importante formatá-los para facilitar a leitura. Por exemplo, você pode converter durações longas em um formato mais compreensível, como "3 dias e 5 horas":

class Program
{
    public static void Main(string[] args)
    {
        // Sample data: List of employee names and their work durations (TimeSpan)
        var workLogs = new List<(string Employee, TimeSpan Duration)>
        {
            ("Alice", new TimeSpan(5, 30, 0)), // 5 hours, 30 minutes
            ("Bob", new TimeSpan(3, 15, 0)),   // 3 hours, 15 minutes
            ("Charlie", new TimeSpan(7, 45, 0)) // 7 hours, 45 minutes
        };
        // Create the HTML content for the PDF report
        string htmlContent = @"
            <h1>Work Log Report</h1>
            <table border='1' cellpadding='5' cellspacing='0'>
                <tr>
                    <th>Employee</th>
                    <th>Work Duration (hh:mm)</th>
                </tr>";
        // Loop through the work logs and add rows to the table
        foreach (var log in workLogs)
        {
            string formattedDuration = FormatLargeTimeSpan(log.Duration);  // Custom method to format large TimeSpan values
            htmlContent += $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>";
        }
        // Close the HTML table
        htmlContent += "</table>";
        // Create a new HtmlToPdf renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render the HTML content as a PDF
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdf.SaveAs("WorkLogReport.pdf");
    }
    // Custom method to handle the formatting operation
    static string FormatLargeTimeSpan(TimeSpan timeSpan)
    {
        // Check if there are days in the TimeSpan and format accordingly
        if (timeSpan.TotalDays >= 1)
        {
            return string.Format("{0} days, {1} hours, {2} minutes",
                (int)timeSpan.TotalDays,
                timeSpan.Hours,
                timeSpan.Minutes);
        }
        else
        {
            // If the duration is less than a day, show only hours and minutes
            return string.Format("{0} hours, {1} minutes", timeSpan.Hours, timeSpan.Minutes);
        }
    }
}

class Program
{
    public static void Main(string[] args)
    {
        // Sample data: List of employee names and their work durations (TimeSpan)
        var workLogs = new List<(string Employee, TimeSpan Duration)>
        {
            ("Alice", new TimeSpan(5, 30, 0)), // 5 hours, 30 minutes
            ("Bob", new TimeSpan(3, 15, 0)),   // 3 hours, 15 minutes
            ("Charlie", new TimeSpan(7, 45, 0)) // 7 hours, 45 minutes
        };
        // Create the HTML content for the PDF report
        string htmlContent = @"
            <h1>Work Log Report</h1>
            <table border='1' cellpadding='5' cellspacing='0'>
                <tr>
                    <th>Employee</th>
                    <th>Work Duration (hh:mm)</th>
                </tr>";
        // Loop through the work logs and add rows to the table
        foreach (var log in workLogs)
        {
            string formattedDuration = FormatLargeTimeSpan(log.Duration);  // Custom method to format large TimeSpan values
            htmlContent += $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>";
        }
        // Close the HTML table
        htmlContent += "</table>";
        // Create a new HtmlToPdf renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render the HTML content as a PDF
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF to a file
        pdf.SaveAs("WorkLogReport.pdf");
    }
    // Custom method to handle the formatting operation
    static string FormatLargeTimeSpan(TimeSpan timeSpan)
    {
        // Check if there are days in the TimeSpan and format accordingly
        if (timeSpan.TotalDays >= 1)
        {
            return string.Format("{0} days, {1} hours, {2} minutes",
                (int)timeSpan.TotalDays,
                timeSpan.Hours,
                timeSpan.Minutes);
        }
        else
        {
            // If the duration is less than a day, show only hours and minutes
            return string.Format("{0} hours, {1} minutes", timeSpan.Hours, timeSpan.Minutes);
        }
    }
}

Imports System

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Sample data: List of employee names and their work durations (TimeSpan)
		Dim workLogs = New List(Of (Employee As String, Duration As TimeSpan)) From {("Alice", New TimeSpan(5, 30, 0)), ("Bob", New TimeSpan(3, 15, 0)), ("Charlie", New TimeSpan(7, 45, 0))}
		' Create the HTML content for the PDF report
		Dim htmlContent As String = "
            <h1>Work Log Report</h1>
            <table border='1' cellpadding='5' cellspacing='0'>
                <tr>
                    <th>Employee</th>
                    <th>Work Duration (hh:mm)</th>
                </tr>"
		' Loop through the work logs and add rows to the table
		For Each log In workLogs
			Dim formattedDuration As String = FormatLargeTimeSpan(log.Duration) ' Custom method to format large TimeSpan values
			htmlContent &= $"<tr><td>{log.Employee}</td><td>{formattedDuration}</td></tr>"
		Next log
		' Close the HTML table
		htmlContent &= "</table>"
		' Create a new HtmlToPdf renderer
		Dim renderer As New ChromePdfRenderer()
		' Render the HTML content as a PDF
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF to a file
		pdf.SaveAs("WorkLogReport.pdf")
	End Sub
	' Custom method to handle the formatting operation
	Private Shared Function FormatLargeTimeSpan(ByVal timeSpan As TimeSpan) As String
		' Check if there are days in the TimeSpan and format accordingly
		If timeSpan.TotalDays >= 1 Then
			Return String.Format("{0} days, {1} hours, {2} minutes", CInt(Math.Truncate(timeSpan.TotalDays)), timeSpan.Hours, timeSpan.Minutes)
		Else
			' If the duration is less than a day, show only hours and minutes
			Return String.Format("{0} hours, {1} minutes", timeSpan.Hours, timeSpan.Minutes)
		End If
	End Function
End Class

Neste exemplo, o método personalizado FormatLargeTimeSpan converte valores TimeSpan grandes em formatos facilmente legíveis, como "6 dias, 5 horas e 30 minutos". Ele verifica se o valor TimeSpan inclui dias e formata a saída de acordo, usando métodos que suportam formatação composta.

• Se a duração total exceder 24 horas, os dias são extraídos e exibidos juntamente com as horas e minutos restantes.
• Para intervalos inferiores a um dia, apenas as horas e os minutos são exibidos.

Principais benefícios do IronPDF para aplicações de geração de relatórios

O IronPDF se destaca por seus recursos robustos na geração de PDFs dinâmicos com base em dados de texto, tempo e HTML. Com o IronPDF, suas tarefas relacionadas a PDFs se tornarão muito mais fáceis. Desde a geração básica de PDFs até a criptografia segura de PDFs, o IronPDF oferece tudo o que você precisa. Algumas das principais vantagens incluem:

• Conversão de HTML para PDF: Converta facilmente conteúdo HTML para PDF, mantendo o layout e o design. O IronPDF também pode lidar com a conversão de muitos outros tipos de arquivo para PDF, incluindo DOCX , imagem , URL e ASPX .
• Opções de personalização: Adapte os relatórios para atender às necessidades específicas da sua empresa com modelos e formatação personalizados, dê aos seus arquivos PDF cabeçalhos e rodapés com aparência profissional, um sumário ou até mesmo planos de fundo personalizados.
• PDFs com perfeição de pixels: Gere documentos PDF de alta qualidade e visualmente consistentes com a sua marca, graças ao forte suporte do IronPDF para os padrões da web modernos. Mesmo PDFs gerados a partir de conteúdo da web sempre terão perfeição de pixels.

Integração perfeita com .NET e formatação TimeSpan

O IronPDF integra-se perfeitamente com aplicações .NET , permitindo que os desenvolvedores aproveitem a estrutura TimeSpan de forma eficaz. Com o IronPDF, você pode gerar relatórios profissionais que incluem dados de tempo formatados com o mínimo esforço, tornando seu processo de geração de relatórios eficiente e descomplicado.