You can use the ToConstant method which takes an already existing instance and registers it as singleton. var kernel = new StandardKernel(); kernel.Bind<MyClass>().ToConstant(myClassInstance); If you want to something more complex you can use the ToMethod (where you can use a Func to get your instance) combined with the InSingletonScope var kernel = new StandardKernel(); kernel.Bind<MyClass>().ToMethod(context … Read more
The principle purpose of MEF is extensibility; to serve as a ‘plug-in’ framework for when the author of the application and the author of the plug-in (extension) are different and have no particular knowledge of each other beyond a published interface (contract) library. Another problem space MEF addresses that’s different from the usual IoC suspects, … Read more
How can I use the dependency injection system builtin to ASP.Net 5 to create an instance of the required API controller for me? In your Startup.cs can tell the MVC to register all your controllers as services. services.AddMvc().AddControllersAsServices(); Then you can simply inject the desired controller in your other controller via the DI mechanism and … Read more
If you want to avoid this “boiler plate” code injecting services in child classes just for injection in parent classes’ constructor and then effectively using that services in child classes through inheritance, you could do this: edit: from Angular 5.0.0 ReflectiveInjector has been deprecated in favour of StaticInjector, below is updated code to reflect this … Read more
I would not worry about it. Instead, I would worry about the class being too complex. A class with many dependencies that uses them all but has no loops or if statements is fine. In some code I was working on recently there were around 14 dependencies in a class. However, there was only one … Read more
@Singleton (and any other scope annotation) makes your class a single instance in your dependencies graph (it means that this instance will be “singleton” as long as Component object exists). In short – everytime you’re injecting @Singleton annotated class (with @Inject annotation) it will be the same instance as long as you inject it from … Read more
Use @Singleton if you rely on singleton behavior and guarantees. Use @Reusable if an object would only be a @Singleton for performance reasons. @Reusable bindings have much more in common with unscoped bindings than @Singleton bindings: You’re telling Dagger that you’d be fine creating a brand-new object, but if there’s a convenient object already created … Read more
No, the built-in DI/IoC container is intentionally kept simple in both usage and features to offer a base for other DI containers to plug-in. So there is no built-in support for: Auto-Discovery, Auto-Registrations, Decorators or Injectors, or convention based registrations. There are also no plans to add this to the built-in container yet as far … Read more
The first question is the most difficult to answer. Is it bad practice to have Entities depend on outside classes? It’s certainly not the most common thing to do. If, for example, you inject a Repository into your Entities you effectively have an implementation of the Active Record pattern. Some people like this pattern for … Read more
The composition root is the single place in your application where the composition of the object graphs for your application take place, using the dependency injection container (although how this is done is irrelevant, it could be using a container or could be done manually using pure DI). There should only be one place where … Read more