fixed: #578

Author: dadhi

src/DryIoc/Container.cs

@@ -4442,20 +4442,34 @@ public static GeneratedExpressions GenerateResolutionExpressions(
         /// <summary>Excluding open-generic registrations, cause you need to provide type arguments to actually create these types.</summary>
         public static bool DefaultValidateCondition(ServiceRegistrationInfo reg) => !reg.ServiceType.IsOpenGeneric();
 
+        // todo: @vNext instead of `condition` we may use a transformer to close the open-generic types. But may be having `roots` parameters covers it as well.
         /// <summary>Helps to find potential problems in service registration setup. Method tries to resolve the specified registrations, collects exceptions, 
         /// and returns them to user. Does not create any actual service objects. You must specify <paramref name="condition"/> to define your resolution roots,
         /// otherwise container will try to resolve all registrations, which usually is not realistic case to validate.</summary>
         public static KeyValuePair<ServiceInfo, ContainerException>[] Validate(this IContainer container, Func<ServiceRegistrationInfo, bool> condition = null)
         {
-            var noOpenGenericsWithCondition = condition == null
-                ? (Func<ServiceRegistrationInfo, bool>)DefaultValidateCondition
-                : (r => condition(r) && DefaultValidateCondition(r));
-
-            var roots = container.GetServiceRegistrations().Where(noOpenGenericsWithCondition).Select(r => r.ToServiceInfo()).ToArray();
-            if (roots.Length == 0)
-                Throw.It(Error.FoundNoRootsToValidate, container);
+            var roots = ArrayTools.Empty<ServiceRegistrationInfo>();
+            if (condition == null)
+            {
+                var allNonGenericRegistrations = container.GetServiceRegistrations().Where(DefaultValidateCondition).ToArray();
+                if (allNonGenericRegistrations.Length == 0)
+                    Throw.It(Error.FoundNoRootsToValidate, container);
+                
+                // We try to find the registrations marked by `Setup.With(asResolutionRoot: true)` and if nothing found, fallback to the all found.
+                // This allow to make asResolutionRoot marking to be optional for validate, but if used - provide the convinient validation by convention. 
+                roots = allNonGenericRegistrations.Match(r => r.Factory.Setup.AsResolutionRoot);
+                if (roots.Length == 0)
+                    roots = allNonGenericRegistrations;
+            }
+            else
+            {
+                // condition overrides whatever resolution roots are marked in registrations 
+                roots = container.GetServiceRegistrations().Where(r => condition(r) && DefaultValidateCondition(r)).ToArray();
+                if (roots.Length == 0)
+                    Throw.It(Error.FoundNoRootsToValidate, container);
+            }
 
-            return container.Validate(roots);
+            return container.Validate(roots.Map(r => r.ToServiceInfo()));
         }
 
         /// <summary>Same as the Validate with the same parameters but throws the exception with all collected errors</summary>
@@ -14529,7 +14543,8 @@ public static readonly int
                 "The `serviceTypes` passed to Validate method is null or empty. Please pass the type(s) you want to Validate."),
             ValidateFoundErrors = Of(
                 "Validate method found the errors, please check the ContainerException.CollectedExceptions for the details." + NewLine +
-                "If you see too many (unexpected) errors, try narrowing the resolution roots by passing the selected service types or the condition to the Validate(AndThrow) method."),
+                "If you see too many (unexpected) errors, try narrowing the resolution roots by passing the selected service types or the condition to the Validate(AndThrow) method." + NewLine +
+                "Or alternatively, mark the service registrations with `setup: Setup.With(asResolutionRoot: true)`."),
             UnableToInterpretTheNestedLambda = Of(
                 "Unable to interpret the nested lambda with Body:" + NewLine + "{0}"),
             WaitForScopedServiceIsCreatedTimeoutExpired = Of(

test/DryIoc.IssuesTests/GHIssue576_Extension_methods_not_being_handled_correctly_in_MadeOf_service_returning_expression.cs

@@ -15,7 +15,9 @@ public int Run()
             Test_factory_extension_method_GHIssue577();
             Test_factory_extension_method_GHIssue577_exclude_from_Validate_via_metadata();
 
-            return 4;
+            Test_factory_extension_method_GHIssue578_respect_Setup_AsResolutionRoot();
+            
+            return 5;
         }
 
         [Test]
@@ -136,6 +138,39 @@ public void Test_factory_extension_method_GHIssue577_exclude_from_Validate_via_m
             Assert.AreEqual(typeof(Foo).FullName, ((SerilogLogger)foo.Logger).TypeName);
         }
 
+        [Test]
+        public void Test_factory_extension_method_GHIssue578_respect_Setup_AsResolutionRoot()
+        {
+            var container = new Container();
+
+            var loggerFactory = new SerilogLoggerFactory();
+
+            container.RegisterInstance<ILoggerFactory>(loggerFactory);
+
+            container.Register(
+                Made.Of(_ => ServiceInfo.Of<ILoggerFactory>(),
+                    f => f.CreateLogger(null)),
+                setup: Setup.With(condition: r => r.Parent.ImplementationType == null, asResolutionRoot: true));
+
+            container.Register(
+                Made.Of(_ => ServiceInfo.Of<ILoggerFactory>(),
+                    f => f.CreateLogger(Arg.Index<Type>(0)),
+                    r => r.Parent.ImplementationType),
+                setup: Setup.With(condition: r => r.Parent.ImplementationType != null));
+
+            container.Register<Foo>();
+
+            var errors = container.Validate();
+
+            Assert.IsEmpty(errors);
+
+            var log = container.Resolve<ILogger>();
+            Assert.IsNull(((SerilogLogger)log).TypeName);
+
+            var foo = container.Resolve<Foo>();
+            Assert.AreEqual(typeof(Foo).FullName, ((SerilogLogger)foo.Logger).TypeName);
+        }
+
         public sealed class Foo 
         {
             public readonly ILogger Logger;

test/DryIoc.TestRunner/Program.cs

@@ -8,10 +8,9 @@ public class Program
     {
         public static void Main()
         {
-            // RunAllTests();
-
-            new GHIssue576_Extension_methods_not_being_handled_correctly_in_MadeOf_service_returning_expression().Run();
+            RunAllTests();
 
+            // new GHIssue576_Extension_methods_not_being_handled_correctly_in_MadeOf_service_returning_expression().Run();
             // new GHIssue116_ReOpened_DryIoc_Resolve_with_decorators_goes_wrong_for_parallel_execution().Run();
             // new RequiredPropertiesTests().Run();            
             // new PropertyResolutionTests().Run();