Suggestion on how to deal with scopes in Application layer that does not depend on Infrastructure layer about dbcontextscope HOT 5 OPEN

// ######## 
// Domain
// ########

public interface IDbContext
{
}

public interface ISqlContext : IDbContext
{
    public DbSet<Employee>  Employees   { get; }
    public DbSet<Manager>   Managers    { get; }
    public DbSet<Staff>     Staff       { get; }
}

public interface IMySqlContext : IDbContext
{
    // another db context if we want
}

// ########
// Application Layer
// ########

SomeQueryHandler : IQueryHandler<TInput, TOut>
{
    private IDbContextScopeFactory  _dbContextScopeFactory  { get; set; }   // DI through constructor or property.
    // Your setup code
    // ...

    public TOut Execute(TInput)
    {
        using(var dbContextScope = _dbContextScopeFactory.CreateReadOnly())
        {
            ISqlContext dbCtx = dbContextScope.DbContexts.GetByInterface<ISqlContext>();

            // Do our DB query, with full access to the DbSet magic that is offered through IQueryable
            // I can't think of another way to do it, because IDbScopeCollection must return a type that inherits DbContext
            // and your extension method must return an IDbContext
        }
    }
}

SomeCommandHandler : ICommandHandler<TCommand>
{
    private IDbContextScopeFactory  _dbContextScopeFactory  { get; set; }   // DI through constructor or property.
    // Your setup code
    // ...

    public void Execute(TCommand)
    {
        using(var dbContextScope = _dbContextScopeFactory.Create())
        {
            ISqlContext dbCtx = dbContextScope.DbContexts.GetByInterface<ISqlContext>();

            // Again do Db Calls on the DbSets, but how would I call any methods that are part of the DbContext?

            dbContextScope.SaveChanges();
        }
    }
}

// ########
// Infrastructure Layer
// ########

public MyContext : DbContext, ISqlContext
{
    public MyContext : base("myconnectionstring")
    {
    }

    public DbSet<Employee>  Employees   { get; set; }
    public DbSet<Manager>   Managers    { get; set; }
    public DbSet<Staff>     Staff       { get; set; }
}

// ########
// Composition Root, assign our static funcs
// ########

DbContextScopeExtensions.GetDbContextFromCollection = (collection,type) =>
{
    if(type == typeof(ISqlContext)) return collection.Get<MyContext>();

    //return a default context? not quite sure what to do here.
}

// ########
// Domain
// ########

public interface IDbContext
{
    public DbContext DbCtx  { get; }
}

public interface ISqlContext : IDbContext
{
}

// ########
// Application
// ########

// Making appropriate changes, I also access the DbSets using the DbContext.Set<TEntity>()


// ########
// Then in your Infrastructure
// ########

public MyContext : DbContext, IDbContext
{
    public MyContext : base("myconnectionstring")
    {
    }

    public DbContext DbCtx  {
        get {
            return this;
        }
    }

    // Assign DbSets here instead of in the ISqlContext
    public DbSet<Employee>  Employees   { get; set; }
    public DbSet<Manager>   Managers    { get; set; }
    public DbSet<Staff>     Staff       { get; set; }
}