LightLogger 4.1.0

LightLogger

LightLogger is a lightweight logging library designed for simplicity and easy integration into .NET applications. It provides first-class support for dependency injection and allows developers to log messages either to the console or to a file with minimal configuration.

Features

• Dependency injection–friendly (ILightLogger)
• Multiple logging modes: Console and SaveToFile
• Simple configuration via a shared configuration class
• Minimal setup and zero boilerplate
• Suitable for console, desktop, and service applications
• Supports colorized output when logging to the console.

Installation

Add the LightLogger package to your project (for example, via NuGet):

dotnet add package LightLogger

Basic Usage

1. Register services and configure the logger

Register the logger and its configuration with the dependency injection container:

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();


services.AddOptions<LightLoggerConfiguration>();
services.AddSingleton(typeof(ILightLogger<>), typeof(LightLogger<>));
services.Configure<LightLoggerConfiguration>(options =>
{
    options.LogDirectory = "C:\\Logs";
    options.LogFileName = "LightLogger.log";
    options.Mode = LoggingMode.SaveToFile;
    options.EnableFileRotation = true;
    options.MaxFileSizeBytes = 10 * FileSize.MB;
});

var provider = services.BuildServiceProvider();

Configure using appsettings.json

{
  "LightLogger": {
    "LogDirectory": "C:\\Logs",
    "LogFileName": "LightLogger.log",
    "Mode": "SaveToFile",
    "EnableFileRotation": true,
    "MaxFileSizeBytes": 10485760
  }
}

In your Startup class

services
    .AddOptions<LightLoggerConfiguration>()
    .Bind(configuration.GetSection("LightLogger"))
    .ValidateOnStart();

services.AddSingleton(typeof(ILightLogger<>), typeof(LightLogger<>));

By default, logs are written to the console if no configuration is specified.

2. Inject and use the logger

Inject ILightLogger into your classes and start logging:

public class MyService
{
    private readonly ILightLogger<MyService> _logger;

    public MyService(ILightLogger<MyService> logger)
    {
        _logger = logger;
    }

    public void MyMethod()
    {
        logger.LogInformation("Service started");
    }
}

Logging Modes

LightLogger supports two logging modes:

Console

Logs are written to standard output.

config.Mode = LoggingMode.Console;

SaveToFile

Logs are persisted to a file using the configured file name and path.

config.Mode = LoggingMode.SaveToFile;

Best Practices

• Register the logger and configuration as singletons
• Configure the logger once at application startup
• Inject ILightLogger into consumers instead of resolving it manually
• Avoid logging configuration logic inside business classes

Example: Console Application

using LightLogger;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            var services = new ServiceCollection();

            // Configure LightLogger using IOptions
            services.AddOptions<LightLoggerConfiguration>()
                .Configure(options =>
                {
                    options.Mode = LoggingMode.SaveToFile;
                    options.LogDirectory = @"C:\tempSecond"; // required only when file-based logging is enabled
                    options.LogFileName = "NewTestFile.log"; // required only when file-based logging is enabled                    

                    // Optional file rotation settings
                    options.EnableFileRotation = true;
                    options.MaxFileSizeBytes = 5 * FileSize.MB;
                })
                .ValidateOnStart();

            // Register open-generic logger
            services.AddSingleton(typeof(ILightLogger<>), typeof(LightLogger<>));

            // Build provider
            using var provider = services.BuildServiceProvider();

            // Resolve logger
            var logger = provider.GetRequiredService<ILightLogger<Program>>();

            Console.WriteLine("Hello, World!");

            logger.LogInformation("-----------------------------------------------");
            logger.LogInError("         Example of error logging");
            logger.LogInWarning("       Example of warning logging");
            logger.LogDebug("           Example of Debug logging");
            logger.LogInformation("     Example of Info logging");
            logger.LogInformation("-----------------------------------------------");
        }
        catch (Exception ex)
        {            
           Console.WriteLine(ex);   
        }
    }
}

Example: Console Application (No Configuration Required)

using LightLogger;
using Microsoft.Extensions.DependencyInjection;

namespace Aspirex.Tester
{
    class Program
    {
        static void Main(string[] args)
        {
            var services = new ServiceCollection();

            // Register the Logger
            services.AddLightLogger();

            IServiceProvider provider = services.BuildServiceProvider();

            var logger = provider.GetRequiredService<ILightLogger<Program>>();

            logger.LogInformation("-----------------------------------------------");
            logger.LogInError("         Example of error logging");
            logger.LogInWarning("       Example of warning logging");
            logger.LogDebug("           Example of Debug logging");
            logger.LogInformation("     Example of Info logging");
            logger.LogInformation("-----------------------------------------------");
        }
    }
}