Performance degradation with singleton pattern and container.getAll() for explicit dependency injection

[unadlib]

Expected Behavior

When using InversifyJS with the singleton pattern and explicit dependency injection:

1. The performance should remain consistent regardless of the order of dependencies in the list.
2. Using container.getAll() to retrieve dependency instances should not cause significant performance degradation, even with complex dependency graphs.

Current Behavior

1. When modules with more dependencies are placed earlier in the list for explicit injection, it leads to significant performance degradation.
2. The performance worsens as the number of dependencies and the complexity of the dependency graph increases.
3. Using container.getAll() to iterate through the list and obtain each dependency instance becomes increasingly slow with larger and more complex dependency lists.

Possible Solution

1. Optimize the way InversifyJS resolves and instantiates dependencies in the singleton pattern, especially when using container.getAll().
2. Implement a caching mechanism for resolved dependencies to reduce repeated resolution of complex dependency chains.
3. Provide an alternative method to container.getAll() that is more efficient for large dependency graphs.
4. Offer guidance on optimal ordering of dependencies to minimize performance impact.

Steps to Reproduce (for bugs)

1. Set up a project using InversifyJS with the singleton pattern.
2. Create a list of dependencies for explicit injection, with modules having varying numbers of dependencies. Ensure some modules have complex dependency chains.
3. Use container.getAll() to retrieve instances of these dependencies.
4. Measure performance with different orderings of the dependency list, particularly with more complex dependencies at the beginning vs. the end of the list.
5. Observe the performance difference and increased resolution time as the list grows and more complex dependencies are moved to the front.

Additional context:

• This issue becomes more pronounced in larger applications with numerous dependencies.
• The performance impact may vary depending on the specific structure of the dependency graph.