Class DependencySingleton<T>

Represents an abstract base class for creating thread-safe singleton instances with optional dependency injection support. This pattern can be utilized in both dependency injection (DI) and non-DI scenarios. Example usage:

 //File ISampleSerivce.cs
 public interface ISampleService
 {
     Task StandardDelayAsync(CancellationToken cancellationToken = default);  void StandardDelay();
 }

 //File DSSampleSerivce.cs
 public partial class SampleService : DependencySingleton<SampleService>, ISampleService , IDependencySingleton
 {
     public SampleService(ILogger<SampleService> logger, IConfiguration configuration) : base(logger, configuration) { }
 }

 //File SampleSerivce.cs
 public partial class SampleService : DependencySingleton<SampleService>, ISampleService , IDependencySingleton
 {
     public void StandardDelay() { StandardDelayAsync(CancellationToken.None).GetAwaiter().GetResult(); }
     public async Task StandardDelayAsync(CancellationToken cancellationToken = default)  { await Task.Delay(5000, cancellationToken); }
 }

 //File Program.cs
 static async Task Main(string[] args)
 {
    SampleService.Instance.SetMinimumLogLevel(LogLevel.Trace);
    // The ILogger<SampleService> logger and IConfiguration configuration will be initialized with their own service stacks.
    SampleService.Instance.StandardDelay();

    // Normal DI usage
    var host = Host.CreateDefaultBuilder(args)
        .ConfigureLogging((context, logging) => {  logging.AddConsole(); logging.AddDebug(); })
        .ConfigureServices((context, services) => { services.AddSingleton<ISampleService,SampleService>(); services.AddSingleton<IMyService,MyService>(); });
    await host.Build().RunAsync();
 }

 //Service usage
 public class MyService
 {
     private readonly ISampleService sampleService;

     public MyService(ISampleService sampleService)
     {
         this.sampleService = sampleService;
     }

     public async Task UseSample()
     {
         await sampleService.StandardDelayAsync();
     }
}

Inheritance

object

DependencySingleton<T>

Implements

IDependencySingleton

Inherited Members

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Namespace: Coree.NETStandard.Abstractions.DependencySingleton

Assembly: Coree.NETStandard.dll

Syntax

[Obsolete("DependencySingleton<T> is deprecated and will be removed in future versions. Use ServiceFactoryEx<T> instead.")]
public abstract class DependencySingleton<T> : IDependencySingleton

Type Parameters

Name	Description
T	The type of the singleton instance.

Constructors

DependencySingleton(ILogger<T>, IConfiguration)

Initializes a new instance of the DependencySingleton<T> class with the specified logger and configuration services.

Declaration

protected DependencySingleton(ILogger<T> logger, IConfiguration configuration)

Parameters

Type	Name	Description
ILogger<T>	logger	The logger service.
IConfiguration	configuration	The configuration service.

Fields

configuration

Represents the configuration for the application. This encompasses settings from various configuration sources (e.g., appsettings.json, environment variables) and is used to access DependencySingleton settings such as connection strings, feature toggles, and other configurable aspects of the application.

Declaration

protected readonly IConfiguration configuration

Field Value

Type	Description
IConfiguration

logger

Provides logging capabilities for the singleton instance. By default, the logger's minimum logging level is set to Trace, allowing all log messages to be captured. However, the default filter level applied to log messages is set to Information, meaning that only logs at Information level or higher will be emitted unless otherwise adjusted. The logging level filter can be dynamically changed at runtime using the SetLogLevelFilter(LogLevel) method to control the verbosity of the logging output.

Declaration

protected readonly ILogger<T> logger

Field Value

Type	Description
ILogger<T>

Properties

Instance

Gets the singleton instance of the class, ensuring thread safety.

Declaration

public static T Instance { get; }

Property Value

Type

Description

T

The singleton instance of type T, which is the specific implementation of the DependencySingleton<T>. Type T represents the derived singleton class that includes implementations for required services such as logging and configuration. The instance is initialized with these services upon the first request, adhering to the singleton pattern to ensure only one instance is created and shared throughout the application.

Methods

SetLogLevelFilter(LogLevel)

Sets the minimum log level filter for the application. This level acts as a filter for the logs that are emitted. Logs below this level will not be emitted. Default is Information

Declaration

public void SetLogLevelFilter(LogLevel logLevel = LogLevel.Information)

Parameters

Type	Name	Description
LogLevel	logLevel	The log level to set as the minimum threshold for logging.

Implements

IDependencySingleton