You can’t make constructors generic, but you can use a generic static method instead: public static Constructor CreateInstance<T>(int blah, IGenericType<T> instance) and then do whatever you need to after the constructor, if required. Another alternative in some cases might be to introduce a non-generic interface which the generic interface extends. EDIT: As per the comments… … Read more
I give you dependency injection for five-year-olds. When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn’t want you to have. You might even be looking for something we don’t even have or which has … Read more
You definitely do not want to call Dispose() on an object that was injected into your class. You can’t make the assumption that you are the only consumer. Your best bet is to wrap your unmanaged object in some managed interface: public class ManagedFileReader : IManagedFileReader { public string Read(string path) { using (StreamReader reader … Read more
SimpleIoc crib sheet: 1) You register all your interfaces and objects in the ViewModelLocator class ViewModelLocator { static ViewModelLocator() { ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default); if (ViewModelBase.IsInDesignModeStatic) { SimpleIoc.Default.Register<IDataService, Design.DesignDataService>(); } else { SimpleIoc.Default.Register<IDataService, DataService>(); } SimpleIoc.Default.Register<MainViewModel>(); SimpleIoc.Default.Register<SecondViewModel>(); } public MainViewModel Main { get { return ServiceLocator.Current.GetInstance<MainViewModel>(); } } } 2) Every object is a singleton by … Read more
If you need to resolve service using the service provider manually you can use this AddSingleton/AddScoped/AddTransient overload: // Works for AddScoped and AddTransient as well services.AddSingleton<IBarService>(sp => { var fooService = sp.GetRequiredService<IFooService>(); return new BarService(fooService); } If you really want to, you can build an intermediate service provider using the BuildServiceProvider() method on the IServiceCollection: … Read more
Well, it depends :-). If the class cannot do its job without the dependency, then add it to the constructor. The class needs the new dependency, so you want your change to break things. Also, creating a class that is not fully initialized (“two-step construction”) is an anti-pattern (IMHO). If the class can work without … Read more
If you accept Fowler’s definition, Inversion of Control is a much broader term than DI that covers all framework usage where you plug into a framework, but the framework is still in control. For example, in .NET, frameworks such as ASP.NET or Windows Presentation Foundation are ultimately in control, but provide various events and Seams … Read more
The Inversion-of-Control (IoC) pattern, is about providing any kind of callback (which “implements” and/or controls reaction), instead of acting ourselves directly (in other words, inversion and/or redirecting control to the external handler/controller). For example, rather than having the application call the implementations provided by a library (also known as toolkit), a framework calls the implementations provided by the application. The Dependency-Injection (DI) pattern is a … Read more
A simple way to solve this is with the strategy pattern. Note that you can add or remove login providers without changing the design – you simply need to change the DI configuration. Interfaces public interface IAuthenticate{ bool Login(string user, string pass); bool AppliesTo(string providerName); } public interface IAuthenticateStrategy { bool Login(string providerName, string user, … Read more
I don’t know NInject, but unless it works vastly different than Windsor, StructureMap etc. the answers tend to stay the same, as there are some common DI patterns. With that in mind: The first thing to realize is that DI isn’t tied to a particular framework such as NInject or Windsor. It is a set … Read more