protected override object VisitConstructor(ConstructorCallSite constructorCallSite, ServiceProviderEngineScope scope)
        {
            object[] parameterValues = new object[constructorCallSite.ParameterCallSites.Length];
            for (var index = 0; index < parameterValues.Length; index++)
            {
                parameterValues[index] = VisitCallSite(constructorCallSite.ParameterCallSites[index], scope);
            }

            try
            {
                var obj           = constructorCallSite.ConstructorInfo.Invoke(parameterValues);
                var interceptors  = InterceptorRuntimeCreate.CreatedInterceptors;
                var implementName = constructorCallSite.ImplementationType.FullName;
                if (interceptors != null && interceptors.Count > 0 &&
                    InterceptorRuntimeCreate.CanIntercept(implementName))
                {
                    Castle.DynamicProxy.ProxyGenerator generator = new Castle.DynamicProxy.ProxyGenerator();

                    if (constructorCallSite.ServiceType.IsInterface)
                    {
                        try
                        {
                            obj = generator.CreateInterfaceProxyWithTarget(constructorCallSite.ServiceType,
                                                                           obj,
                                                                           interceptors.ToArray());
                        }
                        catch (Exception)
                        {
                            // ignored
                        }
                    }
                    else if (constructorCallSite.ServiceType.IsClass &&
                             !constructorCallSite.ServiceType.IsAbstract &&
                             !constructorCallSite.ServiceType.IsSealed)
                    {
                        obj = generator.CreateClassProxyWithTarget(constructorCallSite.ServiceType, obj,
                                                                   parameterValues, interceptors.ToArray());
                    }
                }
                return(obj);
            }
            catch (Exception ex) when(ex.InnerException != null)
            {
                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
                // The above line will always throw, but the compiler requires we throw explicitly.
                throw;
            }
        }
        protected override object VisitFactory(FactoryCallSite factoryCallSite, ServiceProviderEngineScope scope)
        {
            var obj           = factoryCallSite.Factory(scope);
            var interceptors  = InterceptorRuntimeCreate.CreatedInterceptors;
            var implementName = obj.GetType().FullName;

            if (interceptors != null && interceptors.Count > 0 &&
                factoryCallSite.ServiceType.IsInterface &&
                InterceptorRuntimeCreate.CanIntercept(implementName))
            {
                Castle.DynamicProxy.ProxyGenerator generator = new Castle.DynamicProxy.ProxyGenerator();
                obj = generator.CreateInterfaceProxyWithTarget(factoryCallSite.ServiceType,
                                                               obj,
                                                               interceptors.ToArray());
            }
            return(obj);
        }
        protected override object VisitCreateInstance(CreateInstanceCallSite createInstanceCallSite, ServiceProviderEngineScope scope)
        {
            try
            {
                object obj;
                var    interceptors  = InterceptorRuntimeCreate.CreatedInterceptors;
                var    implementName = createInstanceCallSite.ImplementationType.FullName;
                if (interceptors != null && interceptors.Count > 0 &&
                    InterceptorRuntimeCreate.CanIntercept(implementName))
                {
                    Castle.DynamicProxy.ProxyGenerator generator = new Castle.DynamicProxy.ProxyGenerator();

                    if (createInstanceCallSite.ServiceType.IsInterface)
                    {
                        obj = generator.CreateClassProxy(createInstanceCallSite.ImplementationType,
                                                         new[] { createInstanceCallSite.ServiceType },
                                                         interceptors.ToArray());
                    }
                    else
                    {
                        obj = generator.CreateClassProxy(createInstanceCallSite.ImplementationType,
                                                         interceptors.ToArray());
                    }
                }
                else
                {
                    obj = Activator.CreateInstance(createInstanceCallSite.ImplementationType);
                }
                //return Activator.CreateInstance(createInstanceCallSite.ImplementationType);
                return(obj);
            }
            catch (Exception ex) when(ex.InnerException != null)
            {
                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
                // The above line will always throw, but the compiler requires we throw explicitly.
                throw;
            }
        }