getting db connection through singleton class

In .NET C# you can wrtie your singleton like this

    public class Singleton{
public static readonly Singleton Instance= new Singleton();
private Singleton(){}

or for multi threaded environment:

using System;

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

The connection itself is not satisfying the Singleton criteria because you can create multiple instances of a database connection object. A singleton by definition can only be instantiated once.

You can make the SqlConnection a part of the Singleton, by changing your example to this:

public sealed class SingletonDB
{
    private static readonly SingletonDB instance = new SingletonDB();
    private readonly SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["mydb"].ConnectionString);

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static SingletonDB()
    {
    }

    private SingletonDB()
    {
    }

    public static SingletonDB Instance
    {
        get
        {
            return instance;
        }
    }

    public SqlConnection GetDBConnection()
    {
        return con;
    }
}

This way the SqlConnection used by your SingletonDB class would have one and only one SqlConnection, thus follow the Singleton pattern.

Singleton means that the class that you have made can be instantiated only once. So if you want that to happen, do two things:

1. Make the constructor private.(This is to prevent other classes from accessing it.)

2. instantiate the class as:

   get
   {
    if(instance == null) //important coz, the class will be instantiated only on the first call
    {
      instance = new singletonDb;
    }
    return instance;
   }
   

If there's no other way to get a connection to the DB, and if this attribute cannot be overwritten, I would say yes. If that's what you're doing, you're probably taking this singleton thing too far. What if the the DB goes down temporarily and your app loses its connection? Then you'll have to restart your app in order for it to be able to use the DB again.

I can't answer that question without seeing some code, I think. If you are saying that you will have only one DB connection instance in your application, that might work if you can guarantee that your application will run on only one thread (or at least that all operations using the DB connection does), since you can't (as far as I know anyway) run several operations in parallell on the same connection.

Also, if it means that your application will keep the connection open in between uses, I would advise against it. DB connections are limited resources on the DB server, so you should keep them open only when they are needed, and then close them.

You don't have to discard the idea of a singleton just because it will need an IDbConnection. You can solve the problem similarly to how efcore does with its IDbContextFactory.

Rather than using IDbConnection directly, you use a wrapper class around a function that will create an IDbConnection on the fly instead.

public class DbConnectionFactory
{
    private readonly Func<IDbConnection> _connectionCreator;

    public DbConnectionFactory(Func<IDbConnection> connectionCreator)
    {
        _connectionCreator = connectionCreator;
    }

    public IDbConnection CreateConnection()
    {
        return _connectionCreator();
    }
}

You can create an extension method to add it to services, if you'd like.

    public static IServiceCollection AddDbConnectionFactory(
        this IServiceCollection collection,
        Func<IDbConnection> connectionCreator
    )
    {
        return collection.AddSingleton(new DbConnectionFactory(connectionCreator));
    }

Then in your Startup.cs, add it to your services.

//services.AddTransient<IDbConnection>(db => new Microsoft.Data.SqlClient.SqlConnection(connectionString));
services.AddDbConnectionFactory(() => new Microsoft.Data.SqlClient.SqlConnection(connectionString));

Let's say you want a singleton that's supposed to ReadData on command.

services.AddSingleton<MySingleton>();

If your class looks something like this...

public class MySingleton(){

  private readonly IDbConnection _connection;

  public MySingleton(IDbConnection connection){
    _connection = connection;
  }

  public void ReadData(){
    var command = _connection.CreateCommand();
    //...
  }

}

change it to this...

public class MySingleton(){

  private readonly DbConnectionFactory _connectionFactory;

  public MySingleton(DbConnectionFactory connectionFactory){
    _connectionFactory = connectionFactory;
  }

  public void ReadData(){
    using var connection = _connectionFactory.CreateConnection();
    var command = connection.CreateCommand();
    //...
  }
}

Now you are opening and disposing a connection every time you call ReadData(), rather than using a connection that tries and fails to stay open.