去除EF仓储类重复CommandTimeout配置且保留Dispose能力的方法

根据你的需求，给出3种适配不同场景的实现，均可消除重复代码同时保留资源释放能力：

方案1：私有上下文工厂方法（适配现有代码结构，无侵入） #

完全保留原有方法内的using块逻辑，只把「创建上下文+设置超时」的重复逻辑抽到私有方法中：

public class StudentRepository : IStudentRepository
{
    // 统一创建带180秒超时的SchoolContext
    private SchoolContext CreateLongTimeoutContext()
    {
        var context = new SchoolContext();
        context.Database.CommandTimeout = 180;
        return context;
    }

    public IEnumerable<Student> GetStudents()
    {
        using (var context = CreateLongTimeoutContext())
        {
            return context.Students.ToList();
        }            
    }

    public void InsertStudents(IEnumerable<Student> students)
    {
        using (var context = CreateLongTimeoutContext())
        {
            context.Students.AddRange(students);
            context.SaveChanges();
        }
    }
    
    public Student GetStudentByID(int id)
    {
        // 不需要长超时的操作继续用默认配置，不额外设置超时
        using (var context = new SchoolContext())
        {
            return context.Students.Find(id);
        }
    }
}

• 优点：完全兼容现有代码，资源依然由using块自动释放，不会出现连接泄漏；超时配置只对需要的方法生效，不会影响其他仓储；不需要改动依赖注入配置。
• 适用场景：当前仓储内只有部分方法需要长超时，且保持现有「每个方法独立创建上下文」的逻辑。

方案2：自定义超时上下文子类（更简洁，适配全仓储都需要长超时的场景） #

写一个继承SchoolContext的子类，在构造函数里默认设置超时，需要长超时的方法直接用这个子类即可：

// 自定义默认超时的上下文子类
public class LongTimeoutSchoolContext : SchoolContext
{
    public LongTimeoutSchoolContext()
    {
        Database.CommandTimeout = 180;
    }
}

public class StudentRepository : IStudentRepository
{
    public IEnumerable<Student> GetStudents()
    {
        using (var context = new LongTimeoutSchoolContext())
        {
            return context.Students.ToList();
        }            
    }

    public void InsertStudents(IEnumerable<Student> students)
    {
        using (var context = new LongTimeoutSchoolContext())
        {
            context.Students.AddRange(students);
            context.SaveChanges();
        }
    }
    
    public Student GetStudentByID(int id)
    {
        using (var context = new SchoolContext())
        {
            return context.Students.Find(id);
        }
    }
}

• 优点：不需要额外写工厂方法，上下文创建时自动带超时配置，重复代码更少。
• 注意：如果EF的迁移配置指定了上下文类型，需要同步修改对应配置，避免迁移出错。

方案3：注入上下文临时改超时（适配必须共享上下文/事务的场景） #

如果必须用依赖注入的SchoolContext（比如需要跨仓储共享事务），可以在操作前临时设置超时，操作完成后恢复默认值，不影响其他使用该上下文的逻辑：

public class StudentRepository : IStudentRepository
{
    private readonly SchoolContext _context;
    // 保存上下文的默认超时，用于操作后恢复
    private readonly int? _defaultCommandTimeout;

    public StudentRepository(SchoolContext context)
    {
        _context = context;
        _defaultCommandTimeout = _context.Database.CommandTimeout;
    }

    public IEnumerable<Student> GetStudents()
    {
        _context.Database.CommandTimeout = 180;
        try
        {
            return _context.Students.ToList();
        }
        finally
        {
            // 操作完成后恢复默认超时，不影响其他使用该上下文的仓储
            _context.Database.CommandTimeout = _defaultCommandTimeout;
        }
    }

    public void InsertStudents(IEnumerable<Student> students)
    {
        _context.Database.CommandTimeout = 180;
        try
        {
            _context.Students.AddRange(students);
            _context.SaveChanges();          
        }
        finally
        {
            _context.Database.CommandTimeout = _defaultCommandTimeout;
        }
    }
}

• 说明：这种场景下的上下文资源由依赖注入容器的生命周期自动管理，不会出现资源泄漏；超时仅在当前仓储的操作执行期间生效，不会全局污染配置。

内容的提问来源于stack exchange，提问作者Learner