Dependency Injection in WinForms using Ninject and Entity Framework

public class NinjectFactory : NinjectModule { private IKernel _ninjectKernel; public NinjectFactory() { _ninjectKernel = new StandardKernel(); } public override void Load() { _ninjectKernel.Bind(typeof(IRepository<>)).To(typeof(GenericRepository<>)); _ninjectKernel.Bind(typeof(IProductionRepository)).To(typeof(ProductionRepository)); } }

Public Class TaskForm Inherits BaseBusinessDialogForm Private _repository As TaskRepository Private _task As Production.Task = Nothing Public Sub New(ByVal task As Production.Task) InitializeComponent() _repository = New TaskRepository(ConnectString) If task.TaskID = 0 Then _task = task Else _task = _repository.GetByID(task.TaskID) End If MyBase.BusinessObject = _task Me.TaskBindingSource.DataSource = MyBase.BusinessObject End Sub

Dim kernel As IKernel = New StandardKernel(New NinjectFactory()) ''Dim kernel As IKernel = New StandardKernel(New NinjectFactoryTest()) mfrmMDI = kernel.Get(Of Forms.MDI)() Application.DoEvents() mfrmMDI.ShowDialog()

You create composition root as one entry point for your resolutions. You pass INjectModule as a parameter so that you can configure it it tests differently. One of the benefits of Composition Root is that not all of your assemblies will depend on NInject and you will have one single point to change resolution logic. It is really a cool pattern, when you might change IoC container or introduce some dynamic interception in future.

public class CompositionRoot
{
    private static IKernel _ninjectKernel;

    public static void Wire(INinjectModule module)
    {
        _ninjectKernel = new StandardKernel(module);
    }

    public static T Resolve<T>()
    {
        return _ninjectKernel.Get<T>();
    }
}

Your module would look like this

public class ApplicationModule : NinjectModule
{
    public override void Load()
    {
        Bind(typeof(IRepository<>)).To(typeof(GenericRepository<>));
    }
}

In main method you pass ApplicationModule as a parameter and resolve Form1 and start it.

[STAThread]
static void Main()
{
    CompositionRoot.Wire(new ApplicationModule());

    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    Application.Run(CompositionRoot.Resolve<Form1>());
}

In Form1 constructor you pass required repository with specific closed generic parameters

public partial class Form1 : Form
{
    private IRepository<Process> _processRepository;

    public Form1(IRepository<Process> productionRepository)
    {
        this._processRepository = productionRepository;        
        InitializeComponent();
    }  

    private void button1_Click(object sender, EventArgs e)
    {
        MessageBox.Show(_processRepository.ToString());
    }
}

Your repositories could be very complex, but I won't add any functionality to them, instead of ToString() method so that we could see if a dependency was resolved correctly. Note there are no attributes whatsoever on repositories.

public interface IRepository<T>
{
}

public class GenericRepository<T> : IRepository<T>
{
    public override string ToString()
    {
        return "MyRepository with type : "+typeof(T).Name;
    }
}

Now when you run your application, you will see, that all has wired up and message box shows an enclosed type as Process

enter image description here

Recommended topics

Hot tags