singleton

If a singleton implements IDisposable, what is the right way of disposing and re-creating an instance? One way would be to keep _disposed flag and check for it in the Instance property, but I'm not sure it is the right way to do this. A simple example: public sealed class Singleton: IDisposable { private static Singleton _instance; private object _lock; private UnmanagedResource _unmanaged; private bool _disposed; private Singleton() { _unmanaged = new UnmanagedResource(); _disposed = false; _lock = new object(); } public UnmanagedResource Unmanaged { get { return _unmanaged; } } public static

I have a main class with the singleton function instance() and the associated variable $instance . Now I create several subclasses and let the main class inherit. I do not re-define the singleton function and variable, because of the useful inheritance. Unfortunately, each instance points to the 1st subclass. Only when in the subclasses the $instance variable is initialized to null it works, but why? With the keywords static and not self , the scope should remain in the subclass. Here is the source code for a better understanding of what I mean: // PHP Version 7.0 // Don't work as expected:

I am trying to implement the following singleton pattern: SingletonClass.getInstance(context).callMethod() While there are a variety of tutorials that explain how to make singletons in Kotlin, none of them address the fact that holding a context in a static field will cause memory leaks in Android. How do I create the above pattern without creating a memory leak? Update: Here is my implementation of CommonsWare's solution #2. I used Koin. Singleton class: class NetworkUtils(val context: Context) { } Application Class: class MyApplication : Application() { val appModule = module { single {

Say you have an enum singleton: public enum Elvis { INSTANCE; private int age; private Elvis() { age = 42; } public int getAge() { return age; } public void leaveTheBuilding() { System.out.println("I'm outta here."); } } Question: how do you then use it? Is it like this: int a = Elvis.INSTANCE.getAge(); Elvis.INSTANCE.leaveTheBuilding(); // and so on, using Elvis.INSTANCE or is it preferable to instantiate it "explicitly" and then use that instance, like so: Elvis elvis = Elvis.INSTANCE; int a = elvis.getAge(); elvis.leaveTheBuilding(); // and so on, using elvis I'm tempted to use the latter

I hate to beat a dead horse, that said, I've gone over so many conflicting articles over the past few days in regards to the use of the singleton pattern. This question isn't be about which is the better choice in general, rather what makes sense for my use case. The pet project I'm working on is a game. Some of the code that I'm currently working on, I'm leaning towards using a singleton pattern. The use cases are as follows: a globally accessible logger. an OpenGL rendering manager. file system access. network access. etc. Now for clarification, more than a couple of the above require shared

I am confused on how a singleton model vs a static model works for database connections. My friend created a "static" class and showed me it but it did not make any sense on how it was static. I kind of understand the singleton method of how to create a database connection, but i'm not sure it meets my goal. The main thing I want to do is cut down on the number of connections opened to MYSQL. I have a class with a function that calls the database quiet frequently, and there is no reason for it to make a new connection each time someone requests something that requires the database. Could