using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

using DryIoc;

​

namespace SingletonTest

{

    class Program

    {

        private static RegistrationCache cache = new RegistrationCache();

​

        static void Main(string[] args)

        {

            DryTest();

​

            //Console.ReadKey(true);

        }

​

        private static void WriteResult(string title, bool result)

        {

            Console.Write(title + ": ");

            //var currColor = Console.ForegroundColor;

​

            try

            {

                //Console.ForegroundColor = result ? ConsoleColor.Green : ConsoleColor.Red;

                Console.WriteLine(result);

            }

            finally

            {

                //Console.ForegroundColor = currColor;

            }

        }

​

        private static void DryTest()

        {

            Console.WriteLine();

            Console.WriteLine("Dry Test:");

            Console.WriteLine();

​

            var container = new Container(rules => rules

                .WithDefaultIfAlreadyRegistered(IfAlreadyRegistered.Replace)

                .With(FactoryMethod.ConstructorWithResolvableArguments)

                .WithoutEagerCachingSingletonForFasterAccess());

            RegisterSingleton(container, typeof(Class));

            RegisterMapping(container, typeof(Interface), typeof(Class));

            RegisterMapping(container, typeof(Interface2), typeof(Class));

            RegisterSingleton(container, typeof(Generic<>));

            RegisterMapping(container, typeof(IGeneric<>), typeof(Generic<>));

            RegisterMapping(container, typeof(IGeneric2<>), typeof(Generic<>));

​

            Console.WriteLine("Registrations:");

            foreach (var registration in container.GetServiceRegistrations())

            {

                Console.WriteLine($"{registration.ServiceType?.Name ?? "<null>"} => {registration.ImplementationType?.Name ?? "<null>"} (reuse: {registration.Factory.Reuse?.GetType().Name ?? "<null>"})");

            }

            Console.WriteLine();

​

            Console.WriteLine("Cached registrations:");

            foreach (var kv in cache.Cache)

            {

                Console.WriteLine($"{kv.Key} => {kv.Value}");

            }

            Console.WriteLine();

​

            var instance1 = container.Resolve<Class>();

            var instance2 = container.Resolve<Interface>();

            var instance3 = container.Resolve<Interface2>();

            var ginstance1 = container.Resolve<Generic<int>>();

            var ginstance2 = container.Resolve<IGeneric<int>>();

            var ginstance3 = container.Resolve<IGeneric2<int>>();

​

            WriteResult(

                "Resolves same instance",

                ReferenceEquals(instance1, instance2)

                &&

                ReferenceEquals(instance2, instance3)

                );

​

            WriteResult(

                "[GEN] Resolves same instance",

                ReferenceEquals(ginstance1, ginstance2)

                &&

                ReferenceEquals(ginstance2, ginstance3)

                );

​

            RemoveInstance(container, typeof(Class));

            RemoveInstance(container, typeof(Generic<>));

​

            var instance4 = container.Resolve<Class>();

            var instance5 = container.Resolve<Interface>();

            var instance6 = container.Resolve<Interface2>();

            var ginstance4 = container.Resolve<Generic<int>>();

            var ginstance5 = container.Resolve<IGeneric<int>>();

            var ginstance6 = container.Resolve<IGeneric2<int>>();

​

            WriteResult(

                "Class resolves different instance after remove",

                !ReferenceEquals(instance1, instance4));

​

            WriteResult(

                "[GEN] Class resolves different instance after remove",

                !ReferenceEquals(ginstance1, ginstance4));

​

            WriteResult(

                "Interface resolves different instance after remove",

                !ReferenceEquals(instance2, instance5));

​

            WriteResult(

                "[GEN] Interface resolves different instance after remove",

                !ReferenceEquals(ginstance2, ginstance5));

​

            WriteResult(

                "But the same instance for different mappings again",

                ReferenceEquals(instance4, instance5)

                &&

                ReferenceEquals(instance5, instance6)

                );

​

            WriteResult(

                "[GEN] But the same instance for different mappings again",

                ReferenceEquals(ginstance4, ginstance5)

                &&

                ReferenceEquals(ginstance5, ginstance6)

                );

        }

​

        private static void RemoveInstance(Container container, Type type)

        {

            container.RegisterMany(cache.GetFromReverseCache(type).ToArray(), type, Reuse.Singleton, setup: Setup.With(asResolutionCall: true));

        }

​

        private static void RegisterSingleton(Container container, Type type)

        {

            container.Register(type, Reuse.Singleton, setup: Setup.With(asResolutionCall: true));

            cache.RecordMapping(type, type);

        }

​

        private static void RegisterMapping(Container container, Type from, Type to)

        {

            var newMappings = new HashSet<Type>(cache.GetFromReverseCache(to)) { from };

            container.RegisterMany(newMappings.ToArray(), to, Reuse.Singleton, setup: Setup.With(asResolutionCall: true));

            cache.RecordMapping(from, to);

        }

    }

​

    public interface Interface { }

    public interface Interface2 { }

    public class Class : Interface, Interface2 { }

​

    public interface IGeneric<T> { }

    public interface IGeneric2<T> { }

    public class Generic<T> : IGeneric<T>, IGeneric2<T> { }

​

    public class RegistrationCache

    {

        private readonly ConcurrentDictionary<Type, Type> cache = new ConcurrentDictionary<Type, Type>();

        private readonly ConcurrentDictionary<Type, HashSet<Type>> reverseCache = new ConcurrentDictionary<Type, HashSet<Type>>();

​

        public IReadOnlyDictionary<Type, Type> Cache => this.cache;

​

        public IReadOnlyCollection<Type> GetFromReverseCache(Type key)

        {

            return this.reverseCache[key];

        }

​

        public void RecordMapping(Type from, Type to)

        {

            this.cache[from] = to;

            this.reverseCache.AddOrUpdate(

                to,

                _ => new HashSet<Type> { from },

                (_, list) =>

                {

                    list.Add(from);

                    return list;

                });

        }

    }

}

​