Use a public static class. Then you never need to create an instance of it.

public static class DbManager

That would mean that you would not need to instantiate the class (though you
could if you needed to for other requirements) in order to use its static
methods:
http://www.google.co.uk/search?sourceid=navclient&hl=en-GB&ie=UTF-8&rlz=1T4GZEZ_
en-GBGB252GB252&q=%22C%23%22+%22public+static+class%22

public abstract class DbManager

That would mean that you would not be able to instantiate the class, though
it could be inherited
http://www.google.co.uk/search?hl=en&rlz=1T4GZEZ_en-GBGB252GB252&q=%22C%23%22+%2
2public+abstract+class%22&meta=

public sealed class DbManager

That would mean that the class could not be inherited i.e. it couldn't be
used as a base class...

I tend to use a combination of the above... E.g. suppose you had a User
class which is used to manage users of your application. You might have a
Create() method, an Update() method and a Fetch() method, all of which you
would probably want to create an instance of the class to give you a User
object whose properties would be populated etc...

However, you might also have a Delete() method whose sole purpose is to
delete a user given a unique identifier. At this point, instantiating a User
object won't really be of much use to you because you don't actually need to
know anything about the user per se at that point - all you want to do is to
delete it. Therefore, the Delete() method could be static, and accept a user
identifier as an argument, returning a boolean to indicate whether the
deletion was successful or not.

E.g.

public class User
{
   private int mintUserID;
   public int intUserID { get { return mintUserID; } set { mintUserID =
value; } }

   private string mstrFirstName;
   public string strFirstName { get { return mstrFirstName; } set {
mstrFirstName = value; } }

   private string mstrLastName;
   public string strLastName { get { return mstrLastName; } set {
mstrLastName = value; } }

   public int Create()
   {
       // create the user and return the ID of the newly created user
   }

   public bool Update()
   {
       // create the user and return success or failure
   }

   public bool Fetch()
   {
       // fetch the user details, populate the class properties and return
success or failure
   }

   public static void Delete(int pintUserID)
   {
       // delete the user with the given UserID and return success or
failure
       // no need to instantiate the User class to do this...
   }
}

My Suggestion:

Singleton of DbManager

public class DbManager {
   private static DbManager _instance;

   private DbManager() {
       // constructor
   }

   public DbManager Instance {
       get {
           if (_instance == null)
               _instance = new DbManager();
           return _instance;
       }
   }
}

next create a DbManager Factory in your HttpApplication tied with your
Global.asax or in a BasePage implementation from which you have to derive
all of your pages:

public class BasePage : System.Web.UI.Page {
   protected DbManager DbManager {
       get { return DbManager.Instance; }
   }
}

and for your pages, (eg: default.aspx):

public class _default : BasePage {
   protected void Page_Load(object sender, EventArgs e) {
       DbManager dbManager = this.DbManager;
       dbManager.dostuff();
   }
}

HTH

your code structure is correct (except for not using locks). either you have
code clearing the instance, or you are getting recycles.

-- bruce (sqlwork.com)