structuremap/structuremap

using Shouldly;
using StructureMap.Pipeline;
using System;
using System.Collections.Concurrent;
using System.Linq;
using Xunit;

namespace StructureMap.Testing.Acceptance
{
    /// <summary>
    /// Lifecycle which maintains a singleton instance 
    /// of each requested type A 
    /// for each requesting type B
    /// 
    /// <para/>
    /// See RequesterLifecycleObjectCache for details.
    /// </summary>
    public class RequesterLifecycle : ILifecycle
    {
        public string Description => "Lifecycle which maintains a singleton instance for each requested type A for each requesting type B";

        private readonly IObjectCache _cache = new RequesterLifecycleObjectCache();

        public void EjectAll(ILifecycleContext context)
        {
            FindCache(context).DisposeAndClear();
        }

        public IObjectCache FindCache(ILifecycleContext context)
        {
            return _cache;
        }
    } 

    /// <summary>
    /// IObjectCache which maintains a singleton instance 
    /// of each requested type A 
    /// for each requesting type B
    /// </summary>
    /// 
    /// Example:
    /// 
    ///    class A implements interface IA
    ///    In StructureMap, IA resolves to A with RequesterLifecycle
    /// 
    ///    Later...
    ///     
    ///    an instance of type B requests an IA (key: B:IA) -> build an A
    ///    an instance of type B requests an IA (key: B:IA) -> return same instance of A
    ///    an instance of type C requests an IA (key: C:IA) -> build an A
    public class RequesterLifecycleObjectCache : IObjectCache
    {
        /// <summary>
        /// Maps each unique requester/requested pair to its object instance.
        /// </summary>
        private readonly ConcurrentDictionary<string, object> _objects = new ConcurrentDictionary<string, object>();

        public int Count => _objects.Count;

        public bool Has(Type pluginType, Instance instance)
        {
            return false;
        }

        public void Eject(Type pluginType, Instance instance)
        {
        }

        public object Get(Type pluginType, Instance instance, IBuildSession session)
        {
            var buildSession = session as BuildSession;
            var requester = buildSession.ParentType ?? buildSession.RootType;

            var key = GetKey(requester, pluginType);
            return _objects.GetOrAdd(key, _ => buildWithSession(pluginType, instance, session));
        }

        protected virtual object buildWithSession(Type pluginType, Instance instance, IBuildSession session)
        {
            return session.BuildNewInOriginalContext(pluginType, instance);
        }

        public void DisposeAndClear()
        {
            var keys = _objects.Keys.ToList();

            foreach (var key in keys)
            {
                if (_objects.TryRemove(key, out object toDispose))
                {
                    if (toDispose != null && !(toDispose is Container))
                    {
                        SafeDispose(toDispose);
                    }
                }
            }
        }

        private static void SafeDispose(object target)
        {
            if (!(target is IDisposable disposable)) return;

            try
            {
                disposable.Dispose();
            }
            catch (Exception)
            {
            }
        }

        /// <summary>
        /// Creates a key that is unique for the given requesting and requested type pair.
        /// 
        /// <para/>
        /// e.g. "B:IA" reads as "an instance of type B requests an instance of type IA"
        /// </summary>
        private string GetKey(Type requester, Type requested)
        {
            var requesterName = requester?.AssemblyQualifiedName ?? string.Empty;
            var requestedName = requested?.AssemblyQualifiedName ?? string.Empty;

            return $"{requesterName}:{requestedName}";
        }
    }