这是一个好的做法是通过一个EF的DbContext为代表的服务附加上

Question

所有变化具有以下方面：而这个服务

public class DemoContext : DbContext 
{ 
    private readonly string _connectionStringName = "DemoContext"; 
    public DemoContext() : base("name=DemoContext") 
    { 
     //_connectionStringName = "DemoContext"; 
     Configuration.ProxyCreationEnabled = false; 
     Configuration.LazyLoadingEnabled = false; 
     //Database.SetInitializer(new MigrateDatabaseToLatestVersion<DemoContext, Migrations.Configuration>(_connectionStringName)); 
     Database.SetInitializer(new NullDatabaseInitializer<DemoContext>()); 
    } 
    public DbSet<Employee> Employees { get; set; } 
    public DbSet<Company> Companies { get; set; } 
} 

public class Employee 
{ 
    [Key] 
    public int EmployeeId { get; set; } 
    public string Name { get; set; } 
    public DateTime DateOfBirth { get; set; } 
} 

public class Company 
{ 
    [Key] 
    public int CompanyId { get; set; } 
    public string CompanyName { get; set; } 
} 

：

public class EmployeeSvc 
{ 
    private readonly DemoContext _context; 

    public EmployeeSvc(Func<DemoContext> context) 
    { 
     _context = context(); 
    } 

    public void Add(EmployeeAgg employee) 
    { 
     _context.Employees.Attach(new Employee() 
     { 
      Name = employee.Name, 
      DateOfBirth = employee.DateOfBirth 
     }); 
    } 

    public void UpdateAll() 
    { 
     var employees = _context.Employees.ToList(); 
     foreach (var employee in employees) 
     { 
      employee.Name = $"{Guid.NewGuid()}"; 
     } 
    } 
} 

public class CompanySvc 
{ 
    private readonly DemoContext _context; 

    public CompanySvc(Func<DemoContext> context) 
    { 
     _context = context(); 
    } 
    public void Add(CompanyAgg company) 
    { 
     _context.Companies.Attach(new Company() 
     { 
      CompanyName = company.CompanyName 
     }); 
    } 

    public void UpdateAll() 
    { 
     var empresas = _context.Companies.ToList(); 
     foreach (var empresa in empresas) 
     { 
      empresa.CompanyName = $"{Guid.NewGuid()}"; 
     } 
    } 
} 

public class EmployeeAgg 
{ 
    public string Name { get; set; } 
    public DateTime DateOfBirth { get; set; } 
} 

public class CompanyAgg 
{ 
    public string CompanyName { get; set; } 
} 

ANF以下客户端代码：

static void Main(string[] args) 
    { 
     var context = new DemoContext(); 
     // ReSharper disable AccessToDisposedClosure 
     var employeeSvc = new EmployeeSvc(() => context); 
     var companySvc = new CompanySvc(() => context); 
     // ReSharper restore AccessToDisposedClosure 
     Console.WriteLine("Adding entities to context inside services"); 
     employeeSvc.Add(new EmployeeAgg() 
     { 
      DateOfBirth = DateTime.Now.AddYears(-10), 
      Name = $"Employee name" 
     }); 
     companySvc.Add(new CompanyAgg() 
     { 
      CompanyName = $"Company name" 
     }); 

     employeeSvc.UpdateAll(); 
     companySvc.UpdateAll(); 
     context.SaveChanges();    
     context.Dispose(); 
     Console.ReadLine(); 
    } 

它是一个很好的做法传递的DbContext以应用服务为代表，为了有一个参考到单个实例并跟踪其上的所有更改？

Answer 1

如果你需要注入你的dbContext，最好使用接口。 func <>不适用。 依赖注入接口是合适的。

Answer 2

也许这是您的示例代码，但这里没有必要使用委托。你可能也仅仅接受DbContext并通过在同一个实例：

public class EmployeeSvc 
{ 
    private readonly DemoContext _context; 
    public EmployeeSvc(DemoContext context) 
    { 
     _context = context(); 
    } 
    // snip ... 
} 

public class CompanySvc 
{ 
    private readonly DemoContext _context; 
    public CompanySvc(DemoContext context) 
    { 
     _context = context(); 
    } 
    // snip ... 
} 


var context = new DemoContext(); 
var employeeSvc = new EmployeeSvc(context); 
var companySvc = new CompanySvc(context); 

这会给你完全相同的结果，而不需要在一个委托传递，并立即调用它。

但是我想可能你的实际代码有点复杂。如果是这样，你应该看看dependency injection和DI集装箱。

DI容器允许您管理您的依赖关系及其生命周期。常见的生命周期是生命周期，其中容器将始终构造在相同实例中传递的依赖关系。