Object graph visualization using VisualizeObjectGraph produces incomplete result for IEnumerable<> dependecies

VisualizeObjectGraph does not include component types that are part of IEnumerable<> dependency.

How To Reproduce

Consider the following registrations:

var container = new Container();

container.Collection.Register(typeof(IValidator<>), typeof(IValidator<>).Assembly);
container.Register(typeof(IValidator<>), typeof(CompositeValidator<>));
container.Register<MyService>();

container.Verify();

var actual = container.GetRegistration(typeof(MyService)).VisualizeObjectGraph();

Console.WriteLine(actual);

Using types:

class MyService { public MyService(IValidator<MyModel> myModelValidator) { } }

interface IValidator<T> { }

class Composite<T> : IValidator<T> { public Composite(IEnumerable<IValidator<T>> v) { } }

class Validator1 : IValidator<MyModel> { public Validator1(Dependency d) { } }
class Validator2 : IValidator<MyModel> { public Validator2(Dependency d) { } }

class Dependency { }

class MyModel { }

Prints to the console

MyService( // Transient
    Composite<MyModel>( // Transient
        IEnumerable<IValidator<MyModel>>( // Singleton
            Dependency(), // Transient
            Dependency()))) // Transient

Expected to print

MyService( // Transient
    Composite<MyModel>( // Transient
        IEnumerable<IValidator<MyModel>>( // Singleton
            Validator1( // Transient
                Dependency()), // Transient
            Validator2( // Transient
                Dependency())))) // Transient

Additional context

• SimpleInjector 4.7.1
• .NET Core 3.0 console app

[dotnetjunkie]

Wow, that was quite a ride. I’ve been digging deep into this again today and am happy to announce that I was able to fix the problem. And with it, several small bugs surrounding the creation of KnownRelationship types concerning collection elements. That part was a bit a mess. Although there were quite a few tests concerning this part of the system, horrifically enough, those tests just echoed what the system was doing, instead of verifying what the system should have been doing. In other words, there were tests that tested the wrong behavior. Nice.

I was able to fix the problem by added an internal flag to KnownRelationship and by letting the ContainerControlledCollection produce KnownRelationship instances that are flagged as UseForVerification = false. This allows the elements of a ContainerControlledCollection to be used for visualization purposes, while being skipped when it comes to diagnostics. In other words, there is now a distinction between “visualization only” and “visualization and verification” registrations.

https://github.com/simpleinjector/SimpleInjector/commit/926563f239efd67f22a0c09ead94a0c9767269a1 shows the complete change.

[dotnetjunkie]

This bug has been fixed in v4.9.1.