依赖注入，实体框架

Question

So I am using entity framework and trying to refactor my code to use dependency Injection. All was going good until I got to DbContext. This is a windows forms application. So far I have this:

 public interface ICruiserContext
{
    DbSet<Customer> Customers { get; set; }
    DbSet<Address> Addresses { get; set; }
    DbSet<Order> Orders { get; set; }
    DbSet<Item> Items { get; set; }
    DbSet<SkuMap> SkuMaps { get; set; }
    DbSet<UnitOfMeasure> UnitOfMeasures { get; set; }
    DbSet<RelativeUnit> RelativeUnits { get; set; }
    DbSet<ShippingMethod> ShippingMethods { get; set; }
    DbSet<ShippingMethodMap> ShippingMethodMaps { get; set; }
}

and I have a controller that needs the Context(most code was stripped out):

   class ShippingMethodMapper : IMapper
{
    private readonly string _shippingMethod;
    private readonly ICruiserContext _context;

    public ShippingMethodMapper(string shippingMethod,  ICruiserContext context)
    {
        _shippingMethod = shippingMethod;
        _context = context;
    }

    public ICollection<string> GetRemoteValues()
    {
        return new List<string>
        {
            _shippingMethod
        };
    }

    public ICollection<string> GetLocalValues()
    {
        throw new NotImplementedException();
    }

     public void Save(string remoteValue, string localValue)
    {
        throw new NotImplementedException();
    }
}

So since you only want to use the context for one transaction, every time this controller is created, a new context needs to be created, but if I simply inject using

context = new CruiserContext();

Then the code that is creating the controller is no longer testable as it has a hard dependency on the database context now, and if the context ever changed I would have to edit every file that creates a new instance, violating the Open / Closed principle. So my idea was maybe to use a simply factory, and delegate the instancing responsibility it it :

public static class ContextService
{
    public static ICruiserContext GetContext()
    {
        return new CruiserContext();
    }
}

But since static classes can not have interfaces, now I just have hard dependencies on the factory. So what is the best way to inject dbContext that can be tested and mocked.

Answer 1

Use a non-static class with the interface

public interface ICruiserContextFactory
{
    ICruiserContext CreateContext();
}

This is a standard aproach when you're working with IDisposable instances.
Passing factory interface to your class will also allow you to write unit tests.

Answer 2

You use Inversion of Control principle right. Nex step - using IoC-Containers . It's powerfull pattern will help you to solve your problems with injections and tesing.