When using dependency injection (DI) and inversion of control (IoC) objects will typically have a constructor that accepts
the set of dependencies required for
the object to function properly.
For example, if I have a form that requires a service to populate a combo box you might see something like this:
// my files
public interface IDataService {
IList<MyData> GetData();
}
public interface IComboDataService {
IList<MyComboData> GetComboData();
}
public partial class PopulatedForm : BaseForm {
private IDataService service;
public PopulatedForm(IDataService service) {
//...
InitializeComponent();
}
}
This works fine at
the top level, I just use my IoC container to resolve
the dependencies:
var form = ioc.Resolve<PopulatedForm>();
But in
the face of generated code, this gets harder. In winforms a second file composing
the rest of
the partial class is generated. This file references other components, such as custom
controls, and uses no-args constructors to create such controls:
// generated file: PopulatedForm.Designer.cs
public partial class PopulatedForm {
private void InitializeComponent() {
this.customComboBox = new UserCreatedComboBox();
// customComboBox has an IComboDataService dependency
}
}
Since this is generated code, I can't pass in
the dependencies and there's no easy way to have my IoC container automatically inject all
the dependencies.
One solution is to pass in
the dependencies of each child component to PopulatedForm even though it may not need them directly, such as with
the IComboDataService required by
the UserCreatedComboBox. I then have
the responsibility to make sure that
the dependencies are provided through various properties or setter methods. Then, my PopulatedForm constructor might look as follows:
public PopulatedForm(IDataService service, IComboDataService comboDataService) {
this.service = service;
InitializeComponent();
this.customComboBox.ComboDataService = comboDataService;
}
Another possible solution is to have
the no-args constructor to do
the necessary resolution:
public class UserCreatedComboBox {
private IComboDataService comboDataService;
public UserCreatedComboBox() {
if (!DesignMode && IoC.Instance != null) {
comboDataService = Ioc.Instance.Resolve<IComboDataService>();
}
}
}
Neither solution is particularly good. What patterns and alternatives are available to more capably handle dependency-injection in
the face of generated code? I'd love to see both general solutions, such as patterns, and ones specific to C#, Winforms, and Autofac.
