.NET HILFE

C# Logging (Funktionsweise für Entwickler)

Aktualisiert:Juli 28, 2025

Logging is a crucial part of software development, particularly in languages like C#. It helps developers track events that occur during the execution of a program, making it easier to understand its behavior and diagnose problems. This guide will cover all aspects of C# logging and IronPDF for Advanced PDF Manipulation Features, from basic concepts to advanced logging configurations and tools. It provides a comprehensive understanding and control over logging configuration in your applications.

Understanding Logging in C#

At its core, logging in C# involves recording information about the software as it runs. These records, or log messages, are stored in log files or other mediums and can include data like error messages, information about the software's state, or debug messages. The purpose of logging is to provide a way to capture information about the application's operation in a persistent format. This information is invaluable for debugging issues, monitoring software performance, and ensuring that the application behaves as expected. This includes config file, logging API, logging configuration, structured logs, and log exceptions.

Writing Log Messages

To start logging in C#, developers need to write log messages within their application. This is done by using a logging framework or API. In C#, one popular choice is Microsoft’s ILogger interface available in the Microsoft.Extensions.Logging namespace. This interface provides a simple way to log data at various levels of importance, which are known as log levels. These levels, including Information, Debug, and Error, help categorize and filter log output based on the severity of the messages being recorded.

using Microsoft.Extensions.Logging;

public class Program
{
    static void Main(string[] args)
    {
        // Create a logger instance with console output
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole(); // Add console as a logging target
        }).CreateLogger<Program>();

        // Log messages with different levels of severity
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

using Microsoft.Extensions.Logging;

public class Program
{
    static void Main(string[] args)
    {
        // Create a logger instance with console output
        ILogger logger = LoggerFactory.Create(builder => 
        {
            builder.AddConsole(); // Add console as a logging target
        }).CreateLogger<Program>();

        // Log messages with different levels of severity
        logger.LogInformation("This is an information log message");
        logger.LogError("This is an error log message");
    }
}

Imports Microsoft.Extensions.Logging

Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a logger instance with console output
		Dim logger As ILogger = LoggerFactory.Create(Sub(builder)
			builder.AddConsole() ' Add console as a logging target
		End Sub).CreateLogger<Program>()

		' Log messages with different levels of severity
		logger.LogInformation("This is an information log message")
		logger.LogError("This is an error log message")
	End Sub
End Class

$vbLabelText $csharpLabel

In the above example, the ILogger object named logger is configured to output log messages to the console. This setup is simple but fundamental in helping you understand how log messages are generated and displayed.

C# Logging (How It Works For Developers): Figure 1 - Example console output with log messages

Log Files and Providers

In a real-world application, you often need to store log messages in a file or another storage system for later review. This is where logging providers come into play. Providers are components of the logging framework that handle the output of log data to various destinations such as files, databases, or external services.

For example, to configure a logger to write messages to a file, you might use a file-based provider like FileLoggerProvider. This requires modifying the application's configuration file (often appsettings.json in .NET applications) to specify details such as the log file path and the minimum log level.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information", // Log levels for the application
      "Microsoft": "Warning"   // Log levels for Microsoft libraries
    },
    "File": {
      "Path": "logs/myapp.log" // File path for the log file
    }
  }
}

The configuration specifies that all default logging should be at the 'Information' level, but Microsoft’s libraries should only log warnings and above. It also directs the logging output to a log file named myapp.log in a logs directory.

Advanced Logging Techniques

Beyond basic log messages, C# supports structured logging, which allows including structured data in your logs instead of just plain text. Structured logging makes it easier to search and analyze log data, as each piece of contextual information is stored as a separate field.

// Log message with structured data
logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

// Log message with structured data
logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow);

' Log message with structured data
logger.LogDebug("Processing order {OrderId} at {Timestamp}", orderId, DateTime.UtcNow)

$vbLabelText $csharpLabel

In this structured log example, OrderId and Timestamp are placeholders within the message template that will be filled with the values of orderId and DateTime.UtcNow respectively. This is more powerful than traditional logging as it allows for easier querying and manipulation of log data based on specific fields within each log entry.

Integrating with External Systems

C# logging can be extended to integrate with external systems like SQL Server or Windows Event Log, enhancing how log data is managed and analyzed. By using specialized logging providers, log messages can be directed to these systems, providing more robust capabilities for error monitoring and response.

// Direct log output to the Windows Event Log under a specific source name
builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

// Direct log output to the Windows Event Log under a specific source name
builder.AddEventLog(new EventLogSettings
{
    SourceName = "MyApplication"
});

' Direct log output to the Windows Event Log under a specific source name
builder.AddEventLog(New EventLogSettings With {.SourceName = "MyApplication"})

$vbLabelText $csharpLabel

This configuration snippet directs log output to the Windows Event Log under the source name "MyApplication". This is particularly useful for applications running on Windows servers where the Event Log is a centralized tool for monitoring software and system messages.

Integrating IronPDF with C# Logging

C# Logging (How It Works For Developers): Figure 2 - IronPDF homepage

Learn More About IronPDF for HTML to PDF Conversion is a .NET PDF library that enables developers to create, manipulate, and render PDFs. It converts HTML to PDF, which is a common requirement for generating reports, invoices, and other document types from web content. IronPDF provides a comprehensive set of features that cater to various PDF-related tasks, including editing text and images, securing documents, and even extracting content.

Combining IronPDF with C# logging can enhance error handling and debugging when working with PDF files. By integrating logging, you can track the process of PDF generation and capture any issues or exceptions that arise. This integration is particularly useful in scenarios where PDF generation is a critical part of the application's functionality, such as dynamic report generation based on user data.

Code Example

To use IronPDF alongside C# logging, you'll need to incorporate logging calls within your PDF operations. Here’s an example of how you might integrate these two technologies in a .NET application. This example assumes you are using the ILogger interface from Microsoft.Extensions.Logging.

using IronPdf;
using Microsoft.Extensions.Logging;
using System;

public class PdfGenerator
{
    private readonly ILogger _logger;

    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }

    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            // Initialize PDF renderer
            var renderer = new ChromePdfRenderer();

            // Convert HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Save the generated PDF to a file
            pdf.SaveAs(outputPath);

            // Log the success of PDF creation
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            // Log any errors encountered during PDF creation
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}

// Usage example
public class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF, if applicable
        License.LicenseKey = "License-Key";

        // Create a logger factory to manage logging configurations
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Enable logging to the console
        });

        // Create a logger for the PdfGenerator class
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>();

        // Instantiate the PDF generator
        PdfGenerator pdfGenerator = new PdfGenerator(logger);

        // Example HTML content and output path
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";

        // Create a PDF from the provided HTML content
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

using IronPdf;
using Microsoft.Extensions.Logging;
using System;

public class PdfGenerator
{
    private readonly ILogger _logger;

    public PdfGenerator(ILogger<PdfGenerator> logger)
    {
        _logger = logger;
    }

    public void CreatePdfFromHtml(string htmlContent, string outputPath)
    {
        try
        {
            // Initialize PDF renderer
            var renderer = new ChromePdfRenderer();

            // Convert HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(htmlContent);

            // Save the generated PDF to a file
            pdf.SaveAs(outputPath);

            // Log the success of PDF creation
            _logger.LogInformation("PDF created successfully at {OutputPath}", outputPath);
        }
        catch (Exception ex)
        {
            // Log any errors encountered during PDF creation
            _logger.LogError(ex, "Error creating PDF from HTML");
        }
    }
}

// Usage example
public class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF, if applicable
        License.LicenseKey = "License-Key";

        // Create a logger factory to manage logging configurations
        ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole(); // Enable logging to the console
        });

        // Create a logger for the PdfGenerator class
        ILogger<PdfGenerator> logger = loggerFactory.CreateLogger<PdfGenerator>();

        // Instantiate the PDF generator
        PdfGenerator pdfGenerator = new PdfGenerator(logger);

        // Example HTML content and output path
        string htmlContent = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>";
        string outputPath = "output.pdf";

        // Create a PDF from the provided HTML content
        pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath);
    }
}

Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System

Public Class PdfGenerator
	Private ReadOnly _logger As ILogger

	Public Sub New(ByVal logger As ILogger(Of PdfGenerator))
		_logger = logger
	End Sub

	Public Sub CreatePdfFromHtml(ByVal htmlContent As String, ByVal outputPath As String)
		Try
			' Initialize PDF renderer
			Dim renderer = New ChromePdfRenderer()

			' Convert HTML content to PDF
			Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

			' Save the generated PDF to a file
			pdf.SaveAs(outputPath)

			' Log the success of PDF creation
			_logger.LogInformation("PDF created successfully at {OutputPath}", outputPath)
		Catch ex As Exception
			' Log any errors encountered during PDF creation
			_logger.LogError(ex, "Error creating PDF from HTML")
		End Try
	End Sub
End Class

' Usage example
Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF, if applicable
		License.LicenseKey = "License-Key"

		' Create a logger factory to manage logging configurations
		Dim loggerFactory As ILoggerFactory = LoggerFactory.Create(Sub(builder)
			builder.AddConsole() ' Enable logging to the console
		End Sub)

		' Create a logger for the PdfGenerator class
		Dim logger As ILogger(Of PdfGenerator) = loggerFactory.CreateLogger(Of PdfGenerator)()

		' Instantiate the PDF generator
		Dim pdfGenerator As New PdfGenerator(logger)

		' Example HTML content and output path
		Dim htmlContent As String = "<h1>Hello, PDF!</h1><p>This is a simple PDF generated from HTML.</p>"
		Dim outputPath As String = "output.pdf"

		' Create a PDF from the provided HTML content
		pdfGenerator.CreatePdfFromHtml(htmlContent, outputPath)
	End Sub
End Class

$vbLabelText $csharpLabel

C# Logging (How It Works For Developers): Figure 3 - Console output showcasing info-level logging messages after integrating with IronPDF

This setup not only facilitates the generation of PDFs from HTML but also ensures that the operation is well-documented through logs, aiding in maintenance and troubleshooting. Integrating logging with IronPDF can significantly improve the reliability and traceability of your application’s PDF handling capabilities.

Conclusion

C# Logging (How It Works For Developers): Figure 4 - IronPDF licensing page

Logging in C# is a flexible and powerful way to capture detailed information about your application's operation. By using different logging levels, configuring various providers, and implementing structured logging, developers can create a comprehensive logging system that improves the maintainability and debuggability of their applications.

Try IronPDF with a Free Trial starting at $799.

Häufig gestellte Fragen

Was ist Logging in C#?

Logging in C# beinhaltet die Aufzeichnung von Informationen über die Vorgänge der Software während ihrer Ausführung. Lognachrichten werden in Protokolldateien oder anderen Medien gespeichert und enthalten Daten wie Fehlermeldungen und Debugnachrichten, die helfen, das Verhalten der Anwendung zu verstehen und Probleme zu diagnostizieren.

Warum ist Logging wichtig für Entwickler?

Logging ist entscheidend, weil es eine anhaltende Möglichkeit bietet, Informationen über den Betrieb einer Anwendung festzuhalten. Diese Informationen sind unverzichtbar für die Fehlerbehebung, Überwachung der Softwareleistung und Sicherstellung des erwarteten Verhaltens der Anwendung.

Wie kann man Lognachrichten in eine Datei in C# schreiben?

Um Lognachrichten in eine Datei in C# zu schreiben, können Sie einen dateibasierten Anbieter wie FileLoggerProvider verwenden. Dies erfordert die Anpassung der Konfigurationsdatei der Anwendung, wie z.B. appsettings.json, um Details zur Logdatei und minimale Loglevels anzugeben.

Was ist strukturiertes Logging in C#?

Strukturiertes Logging in C# erlaubt das Einbinden strukturierter Daten in Logs anstelle von einfachem Text. Dies erleichtert das Durchsuchen und Analysieren von Logdaten, da jedes Stück kontextueller Information als separates Feld gespeichert wird, was einfacheres Abfragen und Verarbeiten ermöglicht.

Wie kann C# Logging mit externen Systemen integriert werden?

C# Logging kann mit externen Systemen wie SQL Server oder dem Windows-Ereignisprotokoll integriert werden, indem spezialisierte Logging-Anbieter verwendet werden. Dies ermöglicht es, Lognachrichten an diese Systeme zu senden und verbessert die Fehlerüberwachung und Reaktionsfähigkeit.

Wie kann eine PDF-Bibliothek in C# Anwendungen verwendet werden?

Eine PDF-Bibliothek kann in C# Anwendungen verwendet werden, um PDFs zu erstellen, zu bearbeiten und darzustellen. Sie kann mit C# Logging integriert werden, um die Fehlerbehandlung und das Debugging während PDF-Operationen zu verbessern, wie das Nachverfolgen von PDF-Generierungsprozessen und das Erfassen von Problemen oder Ausnahmen.

Wie integriert man eine PDF-Bibliothek mit C# Logging?

Um eine PDF-Bibliothek mit C# Logging zu integrieren, fügen Sie Logging-Aufrufe in Ihre PDF-Operationen ein. Durch die Nutzung der ILogger Schnittstelle können Sie den Erfolg oder Misserfolg von PDF-Erstellungsprozessen protokollieren, was bei der Wartung und Fehlersuche hilft.

Was sind Loglevels beim C# Logging?

Loglevels beim C# Logging sind Kategorien, die die Bedeutung oder den Schweregrad von Lognachrichten angeben. Häufige Loglevels sind Information, Debug und Error, die helfen, Logdaten nach dem Kontext der Logs zu filtern und zu verwalten.

Kann C# Logging zur Überwachung der Softwareleistung verwendet werden?

Ja, C# Logging kann zur Überwachung der Softwareleistung verwendet werden, indem detaillierte Informationen über den Betrieb einer Anwendung erfasst werden. Diese Daten helfen, Leistungsprobleme zu identifizieren und eine optimale Anwendungsleistung sicherzustellen.

Wie kann man mehrere Logging-Anbieter in C# konfigurieren?

Sie können mehrere Logging-Anbieter in C# konfigurieren, indem Sie das ILoggerFactory einrichten, um verschiedene Anbieter einzuschließen, wie Konsole, Datei und Drittanbieter-Dienste. Diese Konfiguration ermöglicht es, Lognachrichten an mehrere Ziele zu senden, um eine umfassende Überwachung zu ermöglichen.

Welche fortgeschrittenen Techniken gibt es für C# Logging?

Fortgeschrittene Techniken für C# Logging umfassen strukturiertes Logging, das die Analyse von Logdaten verbessert, und die Verwendung von Drittanbieter-Anbietern, um Logs an externe Systeme wie Cloud-Dienste zu senden. Diese Techniken verbessern die Verwaltung und die Einblicke in Logdaten.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...