用于数据库访问的静态类的 ASP.NET MVC 指南

Question

我目前在我的 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);
        }
    }
}

我通常在 SO 中遇到“不要使用静态类，静态类是邪恶的，等等”类型的 cmets。这适用于这种情况吗？如果是，为什么？我的应用是否应该遵循更好的“结构”以实现最佳实践并避免此类陷阱？

Answer 1

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

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

更新

帮手

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）对于每个实体（即用户），我们在 Providers 文件夹中有一个静态类。在这个类中，我们可以做通用方法（即 create、Get、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) 我们还有另一个非静态类。它位于 Models 文件夹中。这是我们可以访问实体实例的地方：

    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");
 }