create and write application log in c#

When it comes to generating file logs for a Windows console application in C#, there are several approaches you can take. One common and effective way is to use a logging framework like log4net or NLog. These frameworks provide a robust and flexible solution for logging in C# applications.

To get started, you'll need to install the logging framework of your choice using NuGet. For example, to install log4net, you can use the following command in the NuGet Package Manager Console:

Install-Package log4net

Once you have the logging framework installed, you can configure it in your application. This typically involves creating a configuration file (e.g., log4net.config) where you define the loggers, appenders, and log levels.

Here's a simple example of how you can configure log4net in your Windows console application:

using log4net;
using log4net.Config;

class Program
{
    private static readonly ILog log = LogManager.GetLogger(typeof(Program));

    static void Main(string[] args)
    {
        XmlConfigurator.Configure(new FileInfo("log4net.config"));

        log.Info("Application started");

        // Your application code here

        log.Info("Application finished");
    }
}

In this example, we configure log4net using an XML configuration file named "log4net.config". We then use the ILog interface to obtain a logger instance and log messages at different levels (e.g., Info).

By using a logging framework like log4net or NLog, you can easily generate file logs for your Windows console application. These frameworks offer various features such as log rotation, log filtering, and log formatting, making it easier to manage and analyze your application logs.

Check Below Code 

using System;
using System.IO;

public class Logger
{
    private readonly string logFilePath;

    public Logger(string logFilePath)
    {
        this.logFilePath = logFilePath;
    }

    public void Log(string message)
    {
        try
        {
            using (StreamWriter writer = new StreamWriter(logFilePath, true))
            {
                string logEntry = $"{DateTime.Now} - {message}";
                writer.WriteLine(logEntry);
            }
        }
        catch (Exception ex)
        {
            // Handle or log any exceptions related to writing the log
            Console.WriteLine($"Error writing to log: {ex.Message}");
        }
    }
}

The following is a simple way to write and manage a log without any library.

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Define the path to your log file
        string logFilePath = "log.txt";

        // Sample log messages
        LogToFile(logFilePath, "This is an information message.", LogLevel.Information);
        
        try
        {
            // Simulate an error
            int result = 10 / 0;
        }
        catch (Exception ex)
        {
            // Log the error
            LogToFile(logFilePath, "An error occurred: " + ex.ToString(), LogLevel.Error);
        }

        // Make sure to close and flush the log file when your application exits
        File.Close();
    }

    static void LogToFile(string filePath, string message, LogLevel level)
    {
        try
        {
            // Open the log file in append mode
            using (StreamWriter sw = File.AppendText(filePath))
            {
                // Write the log message along with a timestamp and level indicator
                sw.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} - [{level}] {message}");
            }
        }
        catch (Exception logEx)
        {
            // Handle any exceptions that may occur while writing to the log file
            Console.WriteLine("Error writing to the log file: " + logEx.Message);
        }
    }
}

// Enum to represent log levels
enum LogLevel
{
    Information,
    Error
}

Map the logging class as below 

Log.Information("Processing data...");
Log.Warning("An issue occurred while processing data.");
Log.Error(exception, "An error occurred: {ErrorMessage}", exception.Message);

There are also other way to do this. 

There are several logging libraries available for C# that make logging easier and more organized. Some popular options are:

• Serilog
• NLog
• Log4net

Install the chosen logging library using NuGet Package Manager in Visual Studio. Then, configure the logging settings in your application. This typically involves specifying the log format, log file location, and log levels.

Example using Serilog:
 

Log.Logger = new LoggerConfiguration()
    .WriteTo.File("logfile.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

 Use Logging in Your Application: Throughout your application code, use the logging library to capture events, errors, and information that you want to log.
 

Log.Information("This is an informational message.");
Log.Error(exception, "An error occurred: {ErrorMessage}", errorMessage);

Add Logging in the Main Method: In your console application's Main method, configure logging at the beginning and dispose of the logger at the end of the application.

Example:

 

class Program
{
    static void Main(string[] args)
    {
        // Configure logging
        Log.Logger = new LoggerConfiguration()
            .WriteTo.File("logfile.txt", rollingInterval: RollingInterval.Day)
            .CreateLogger();

        try
        {
            // Your application logic

            Log.Information("Application completed successfully.");
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Application encountered an error.");
        }
        finally
        {
            // Dispose of the logger
            Log.CloseAndFlush();
        }
    }
}

using Serilog;
using Serilog.Sinks.Console;
using Serilog.Sinks.File;

class Program
{
    static void Main(string[] args)
    {
        Log.Logger = new LoggerConfiguration()
            .WriteTo.Console()
            .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day) // Specify log file name and rolling interval
            .CreateLogger();

        // Your application logic here

        Log.Information("Application started");
        
        // Run your application logic
        
        Log.Information("Application ended");

        Log.CloseAndFlush(); // Important to flush and close the logger
    }
}

Step 1:
Create a logger class same as given below

using System;
using System.Diagnostics;
using System.IO;

public class Logger
{
    private static readonly string LogFilePath = "log.txt";

    private static void LogToFile(string message)
    {
        using (StreamWriter writer = File.AppendText(LogFilePath))
        {
            writer.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} - {message}");
        }
    }

       public static void LogInfo(string message)
    {
        Console.WriteLine(message);
        LogToFile($"INFO: {message}");
    }

   
    public static void LogError(string message)
    {
        Console.WriteLine($"ERROR: {message}");
        LogToFile($"ERROR: {message}");
    }

    public static void LogException(Exception ex)
    {
        Console.WriteLine($"EXCEPTION: {ex}");
        LogToFile($"EXCEPTION: {ex}");
    }
}

Step 2:

To use this logger class in your application:

a. Create an instance of the Logger class or directly call its static methods.

b. Call the appropriate method ( LogInfo, LogError, LogException) to log messages or exceptions

eg; i have created sample service class and created instance of logger class

public class MyService
{
    private Logger logger; // Creating an instance of the Logger class

    public MyService()
    {
        logger = new Logger(); // Instantiate the logger in the constructor
    }

    public void PerformTask()
    {
        logger.LogInfo("Performing a task.");
        logger.LogError("Task failed with an error.");

        try
        {
            // Simulate an exception
            int result = 10 / 0;
        }
        catch (Exception ex)
        {
            logger.LogException(ex);
        }
    }
}

STep 3:
Use logger class in main method

class Program
{
    static void Main(string[] args)
    {
        MyService myService = new MyService();
        myService.PerformTask();
    }
}

If you found the provided information and code helpful, consider giving it a thumbs up or marking it as useful.