静态类数据库访问

Question

我利用我的ASP.NET应用程序此刻的MVC模式（使用实体框架）的方式ASP.NET MVC的指导方针如下：

1）我Models文件夹包含所有的EF实体，以及我的ViewModels

2）我有一个Helpers文件夹，我存储为特定应用程序创建的类。

3）在我的Helpers文件夹中，我有一个名为MyHelper的静态类，其中包含使用EF访问数据库的方法。

namespace myApp.Helpers 
{ 
    public static class MyHelper 
    { 
     public static async Task<ProductVM> GetProductAsync(int productId) 
     { 
      using (var context = new myEntities()) 
      { 
       return await context.vwxProducts.Where(x => x.ProductId == productId).Select(x => new ProductVM { A = x.A, B = x.B }).FirstOrDefaultAsync(); 
      } 
     } 
    } 
} 

4）我的控制器，然后调用这些函数在必要时：

namespace myApp.Controllers 
{ 
    public class ProductController : Controller 
    { 

     [HttpGet] 
     public async Task<ActionResult> Index(int productId) 
     { 
      var productVM = await MyHelper.GetProductAsync(productId); 
      return View(productVM); 
     } 
    } 
} 

我经常遇到意见的类型，使得“不使用静态类，静态类是邪恶的，等等” 。这是否适用于这种情况？如果是，为什么？有没有更好的“结构”我的应用程序应遵循的最佳实践和避免这种陷阱？

Answer 1

你不能真正使用这个静态类。您的实体框架上下文应该每个请求只有一个实例。你的方法在这里为每个方法实例化一个新的上下文，这将导致实体框架出现很多问题。

一般概念很好，但你的MyHelper类应该是一个普通的类。添加一个构造函数，获取上下文的实例，然后使用DI容器将上下文注入到helper类和helper类中，并将其注入到控制器中。

UPDATE

助手

namespace myApp.Helpers 
{ 
    public class MyHelper 
    { 
     private readonly DbContext context; 

     public MyHelper(DbContext context) 
     { 
      this.context = context; 
     } 

     public async Task<ProductVM> GetProductAsync(int productId) 
     { 
      return await context.vwxProducts.Where(x => x.ProductId == productId).Select(x => new ProductVM { A = x.A, B = x.B }).FirstOrDefaultAsync(); 
     } 
    } 
} 

控制器

namespace myApp.Controllers 
{ 
    public class ProductController : Controller 
    { 
     private readonly MyHelper myHelper; 

     public ProductController(MyHelper myHelper) 
     { 
      this.myHelper = myHelper; 
     } 

     [HttpGet] 
     public async Task<ActionResult> Index(int productId) 
     { 
      var productVM = await myHelper.GetProductAsync(productId); 
      return View(productVM); 
     } 
    } 
} 

然后，你只需要建立一个DI容器注入的一切。代码完全取决于你最终选择哪个容器，所以我不能真正帮助你。不过，这通常很简单。只需阅读容器的文档。您需要将对象的生命周期范围设置为请求。再次，不同的容器是不同的，但它们都会有某种请求范围。

Answer 2

我正在考虑给ChrisPratt的回答添加评论，但结果太长了，所以让我添加单独的答案。

基本上，这不是一个生/死的选择。当然，静态方法不如用于数据库访问的类灵活。但是他们不坏本身。每个请求一个DbContext是一个东西旨在。这不是绝对必要的。它是kinda like dependency injection - 您获得更多的灵活性，从而增加代码的复杂性。

看看这三个问题进行解答，以考虑到他们所说的一切事件，我敢肯定，你就可以自己回答你的问题：

• Why would I use static methods for database access
• When to use static classes in C#
• One DbContext per web request... why?

编辑：克里斯在我的答案留下了很好的评论，我已经改变了答案一点，以考虑到他说的话。

Answer 3

你的想法是正确的，我总是使用它。但是风格是这样的： 1）对于每个实体（即User），我们在Providers文件夹内有一个静态类。这节课，我们可以做的一般方法（即创造，获取，GETALL，..）

public static class Users 
{ 
    public static IEnumerable<kernel_Users> GetAll() 
    { 
     Kernel_Context db = new Kernel_Context(); 
     return db.kernel_Users; 
    } 

public static kernel_Users Get(int userId) 
    { 
     Kernel_Context db = new Kernel_Context(); 
     return db.kernel_Users.Where(c => c.UserId == userId).FirstOrDefault(); 
    } 
    ... 
} 

2）我们有另一个类，是不是static.It是内部模型文件夹中。这是我们可以访问到实体的实例的地方：

public partial class kernel_Users 
{ 
    [Key] 
    public int UserId { get; set; } 
    public string Username { get; set; } 
    public string Password { get; set; } 

    [NotMapped] 
    public string FullName 
    { 
     get 
     { 
      return FirstName + " " + LastName; 
     } 
    } 
    public bool Delete(out string msg) 
    { 
     ... 
    } 
    ... 

}

Answer 4

我使用已在上下文中注入一个静态构造函数加载数据的高速缓存的目的的静态类这很少改变。它（应该）是线程安全的。我希望这可以帮助你，在我的经验中非常方便：

public static class StaticCache<T> where T: class 
{ 
    private static List<T> dbSet; 
    public static Dictionary<string, List<T>> cache = new Dictionary<string, List<T>>(); 
    private static readonly object Lock = new object(); 
    public static void Load(DbContext db, string connStr, string tableName) 
    { 
     lock (Lock) 
     { 
      try 
      { 
       if (connStr != null) 
       { 
        using (db) 
        { 
         dbSet = db.Set<T>().ToList();        
         cache.Add(tableName, dbSet); 
        } 
       } 

      } 
      catch { } 
     } 
    } 
} 
void Testit() 
{ 
    var context = new YourContextSubClass(connStr);  
    StaticCache<TableEntity>.Load(context, connstr, "tableEntityNameString"); 
}