为什么我应该在构造函数中使用对象的接口类型，而不是实际的类对象

我已经将我的企业级项目外包给了自由职业者，并且我也得到了一个很好的设置。但是现在合同已经完成，此人也已经使用了新技术，换句话说，他不愿意延长合同。现在，我正在研究自己的这段代码。我确实有2 3年的C＃和MVC背景。下面是我的应用程序体系结构的粗略想法。希望我已尽力抽象出企业级应用程序的体系结构细节。如果您需要任何进一步的简要介绍，请告诉我。

我所有的实体都定义为C＃POCO类，如下所示：

public class Product : BaseEntity
{
   public int ProductId { get; set; }
   public string ProductName { get; set; }
}

现在我有一个IDbContext，如：

public interface IDbContext : IDisposable
{
    IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity;      
}

基础实体是每个POCO实体都继承的Partial POCO类。这是一个实现此IDBContext的类：

public class MyObjectContext : DbContext, IDbContext
{
    public new IDbSet<TEntity> Set<TEntity>() where TEntity : BaseEntity
    {
        return base.Set<TEntity>();
    }
}

现在，我已经定义了一个IDbContextFactory，它负责提供DBContexts：

public interface IDbContextFactory
{
    Lazy<IDbContext> CreateDbContext();
}

实现此IDBContextFactory接口的类具有以下结构：

public class MyDbContextFactory : IDbContextFactory
{
    public MyDbContextFactory(string dbConnectionString)
    {
        _dbConnectionString = Settings.DbConnectionString;
        _dbContext = CreateDbContext();
    }

    public IDbContext CreateDbContext()
    {
        IDbContext dbContext = new IDbContext(() => CreateNewContext());
        return dbContext;
    }

    private MyObjectContext CreateNewContext()
    {
        return new MyObjectContext (_dbConnectionString);
    }
}

IRepo模式在这里的作用是：

public partial interface IRepository<T> where T : BaseEntity
{
    T GetById(object id);
}

现在，实现此接口的Repository类如下：

public partial class EfRepository<T> : IRepository<T> where T : BaseEntity
{
    private readonly Lazy<IDbContext> _dbContext;
    private readonly IDbContextFactory _dbContextFactory;
    private readonly Lazy<ObjectStateManager> _objectStateManager;

    public EfRepository(IDbContextFactory dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
        _dbContext= _dbContextFactory.CreateDbContext();
        _objectStateManager= new Lazy<ObjectStateManager>(() => ((IObjectContextAdapter)_dbContext.Value).ObjectContext.ObjectStateManager);
    }

    public T GetById(object id)
    {
        return this.Entities.Find(id);
    }
}

到现在为止，我们已经完成了数据库访问管理的基础结构级别设置。现在，事情是利用此设置到Controllers中（如下所述，因为我已经直接从Controllers访问存储库）：

public class CountryController: BaseController
{
    private readonly Lazy<IRepository<Country>> _countryRepository;

    public CountryController(Lazy<IRepository<Country>> countryRepository)
    {
        _countryRepository = countryRepository;
    }

    public Country GetCountryById(int id)
    {
        Country country = _countryRepository.Value.GetById(id);

        if (country != null)
            return country;
        else
            return null;
    }

希望以上所有内容都清楚。现在这是我需要回答的一些问题：

1）为什么我们会有这样的分层流：

IDBContext -> IDBContextFactory -> IRepository <T>

然后最终将此IRepository运用于Controller中以访问Data对象。换句话说，为什么在为Country Controller实施构造函数注入时依赖接口而不是实际的类对象？

2）这对于企业级应用程序是正确的方法，因为它应具有很大的可扩展性以备将来使用。如果还有其他的话，我会很高兴知道吗？

3）在Controller的构造函数中，我使用了Lazy>，所以此Lazy的目的是什么，实际上有什么好处？