internal bool TryValidate(ServiceDefinition definition, out Type implementationType)
        {
            implementationType = null;

            if (definition.ServiceType.GetTypeInfo().IsNonAspect())
            {
                return(false);
            }

            implementationType = definition.GetImplementationType();

            if (implementationType == null || implementationType == typeof(object))
            {
                return(false);
            }

            if (!implementationType.GetTypeInfo().IsClass)
            {
                return(false);
            }

            if (definition.ServiceType.GetTypeInfo().IsClass)
            {
                if (!(definition is TypeServiceDefinition))
                {
                    return(false);
                }
                if (!implementationType.GetTypeInfo().CanInherited())
                {
                    return(false);
                }
            }

            return(_aspectValidator.Validate(definition.ServiceType, true) || _aspectValidator.Validate(implementationType, false));
        }
        internal static bool RequiredPropertyInjection(this ServiceDefinition serviceDefinition)
        {
            if (serviceDefinition is ProxyServiceDefinition proxyServiceDefinition && proxyServiceDefinition.ServiceType.GetTypeInfo().IsInterface)
            {
                return(false);
            }
            var implType = serviceDefinition.GetImplementationType();

            if (implType == null)
            {
                return(false);
            }
            if (implType == typeof(object))
            {
                return(true);
            }
            return(PropertyInjectionUtils.TypeRequired(implType));
        }