Classe de base abstraite pour forcer chaque classe dérivée à être singleton

Voici une façon (laide) de faire cela. Il pourrait probablement être simplifié et amélioré, mais c'est mon premier aller à cela.

L'idée est d'abord de faire de la classe de base une classe abstraite générique (comme mentionné dans les commentaires ci-dessus), mais le paramètre Type est contraint de dériver de la classe de base elle-même. Cela permet à la classe de base de gérer l'instance singleton du type dérivé. Remarque Toutes les classes dérivées doivent être scellées, comme avec n'importe quelle classe Singleton. P>

Suivant, un constructeur protégé est autorisé, mais est nécessaire pour accepter une instance d'une classe spéciale, SingletonKey, qui est un singleton modifié. Les classes dérivées ont accès à la définition de classe SingletonKey, mais la classe de base conserve un contrôle privé sur la seule instance autorisée et donc sur la construction de tous les objets dérivés. P>

Troisième, la classe de base devra être capable de Appelez le constructeur de la classe dérivée, mais cela est légèrement délicat. Le compilateur se plaint si vous essayez d'appeler le constructeur à clé dérivé, car il n'est pas garanti d'exister. La solution consiste à ajouter un délégué statique selon lequel la classe dérivée doit initialiser. Toutes les classes dérivées devront donc fournir une méthode d'initialisation simple. Cette méthode d'initialisation doit être appelée explicitement avant de tenter d'accéder à l'instance pour la première fois dans le code ou une erreur d'exécution résultera. P>

public abstract class Singleton<T> where T : Singleton<T>
{
    protected Singleton(SingletonKey key) { }
    private static SingletonKey _key;
    private static SingletonKey Key
    {
        get
        {
            if (_key == null) SingletonKey.Initialize();
            return _key;
        }
    }
    protected class SingletonKey
    {
        private SingletonKey()
        {
        }
        public static void Initialize()
        {
            if (_key == null)
            {
                _key = new SingletonKey();
            }
        }
    }

    protected static Func<SingletonKey, T> Creator;
    private static T instance;
    public static T Instance
    {
        get
        {
            if (instance == null) instance = Creator(Key);
            return instance;
        }
    }
}

public class MySingleton : Singleton<MySingleton>
{
    public string Name { get; set; }
    public static void Initialize()
    {
        Creator = (key) => new MySingleton(key);
    }
    protected MySingleton(SingletonKey key) : base(key)
    {
    }
}

Je crois que j'ai essayé d'atteindre quelque chose de similaire I.e. Appliquer une interface commune et le modèle singleton sur un groupe de classes. C'était ma solution: xxx

Voici un test simple: xxx

Veuillez noter que vous pouvez facilement supprimer l'interface commune du générique. Classe de Singleton abstrait si vous avez juste besoin du "modèle" de base.

Ici, ma mise en œuvre de Singleton Héritage:

using System;
using System.Reflection;

namespace Mik.Singleton
{
    class Program
    {
        static void Main()
        {
            //You can not create an instance of class directly
            //Singleton1 singleton1 = new Singleton1();

            Singleton1 singleton1 = Singleton1.Instance;
            Singleton2 singleton2 = Singleton2.Instance;

            Console.WriteLine(singleton1.Singleton1Text);
            Console.WriteLine(singleton2.Singleton2Text);

            Console.ReadLine();
        }
    }

    public class SingletonBase<T> where T : class
    {
        #region Singleton implementation

        private static readonly object lockObj = new object();
        private static T _instance;

        protected SingletonBase() { }

        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (lockObj)
                    {
                        if (_instance == null)
                            _instance = CreateInstance();
                    }
                }
                return _instance;
            }
        }

        private static T CreateInstance()
        {
            ConstructorInfo constructor = typeof(T).GetConstructor(
                            BindingFlags.Instance | BindingFlags.NonPublic,
                            null, new Type[0],
                            new ParameterModifier[0]);

            if (constructor == null)
                throw new Exception(
                    $"Target type is missing private or protected no-args constructor: {typeof(T).FullName}");
            try
            {
                T instance = constructor.Invoke(new object[0]) as T;

                return instance;
            }
            catch (Exception e)
            {
                throw new Exception(
                    "Failed to create target: type=" + typeof(T).FullName, e);
            }
        }

        #endregion Singleton implementation
    }

    public class Singleton1 : SingletonBase<Singleton1>
    {
        private Singleton1() { }

        public string Singleton1Text { get; } = "Singleton1Text value";
    }

    public class Singleton2 : SingletonBase<Singleton2>
    {
        private Singleton2() { }

        public string Singleton2Text { get; } = "Singleton2Text value";
    }
}