C# 通用存储库模式属性区分大小写

我正在应用程序中使用通用存储库模式。我正在尝试这篇文章。问题是，数据库代码生成工具（先从现有数据库生成代码）生成了以下模型：

[Table("TableName1")]
public partial class TableName1 : IEntity
{
    public int ID { get; set; }

    [StringLength(50)]
    public string Name { get; set; }

    ::::::::
}

[Table("TableName2")]
public partial class TableName2 : IEntity
{
    public int Id { get; set; }

    [StringLength(50)]
    public string Name { get; set; }

    ::::::::
}

我刚刚在上述数据库模型中应用了IEntity，但TableName2类中存在问题，因为IEntity接口具有“ID”属性而不是“ID”。这是一个

public interface IEntity
{
    int ID { get; }
}

---

那么，如何在不查看案例的情况下将该属性转换为接受属性呢？如果我不想为每个表创建单独的独立新模型，我需要最简单的解决方案？

如果您使用代码优先的方法，实体框架将在生成表时自动将您的实体名称复数化，因此让我们先为您的问题添加一些上下文并删除所有抽象，假设我们正在创建一个用户存储库，实体框架将自动生成一个

Users

表

public partial class User : IEntity
{
    public int Id { get; set; }

    [StringLength(50)]
    public string Name { get; set; }
}

public partial class BlogPost : IEntity
{
    public int Id { get; set; }

    [StringLength(50)]
    public string Title { get; set; }
}

public interface IEntity
{
    int Id { get; }
}

没有办法绕过大小写规则，这是一条规则，尽管我们喜欢牛仔，但您编写的内容甚至不能编译为

接口

是一份合同。如果一个

类

实现了一个契约，它必须实现该契约所概述的一切；属性

Id

至少有一个

getter

我查看了您提供的链接，但它没有显示您应该如何正确地实现

IRepository

，您的每个实体都应该有自己的存储库，我将修改该界面，使其如下所示：

public interface IRepository<T> where T : class, IEntity
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

---

如果您使用代码优先的方法，实体框架将在生成表时自动将您的实体名称复数化，因此让我们首先为您的问题添加一些上下文并删除所有抽象，假设我们正在创建一个用户存储库，实体框架将自动生成一个

Users

表

public partial class User : IEntity
{
    public int Id { get; set; }

    [StringLength(50)]
    public string Name { get; set; }
}

public partial class BlogPost : IEntity
{
    public int Id { get; set; }

    [StringLength(50)]
    public string Title { get; set; }
}

public interface IEntity
{
    int Id { get; }
}

没有办法绕过大小写规则，这是一条规则，尽管我们喜欢牛仔，但您编写的内容甚至不能编译为

接口

是一份合同。如果一个

类

实现了一个契约，它必须实现该契约所概述的一切；属性

Id

至少有一个

getter

我查看了您提供的链接，但它没有显示您应该如何正确地实现

IRepository

，您的每个实体都应该有自己的存储库，我将修改该界面，使其如下所示：

public interface IRepository<T> where T : class, IEntity
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

---

我使用的方法现在被实体框架本身所克服，不确定是哪个版本的实体框架。下面的代码展示了实体框架的通用存储库模式的一个漂亮而干净的实现。这里不需要IEntity接口，因为我们使用DbSet类的便利的Find扩展方法

以下是我的假设：

public interface IRepository<T>
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

public class Repository<T> : IRepository<T> where T : class
{
    protected DbSet<T> DbSet;

    public Repository(DbContext dataContext)
    {
        DbSet = dataContext.Set<T>();
    }

    #region IRepository<T> Members

    public void Insert(T entity)
    {
        DbSet.Add(entity);
    }

    public void Delete(T entity)
    {
        DbSet.Remove(entity);
    }

    public IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate)
    {
        return DbSet.Where(predicate);
    }

    public IQueryable<T> GetAll()
    {
        return DbSet;
    }

    public T GetById(int id)
    {
        return DbSet.Find(id);
    }

    #endregion
}

公共接口IRepository
{
无效插入（T实体）；
无效删除（T实体）；
IQueryable搜索（表达式谓词）；
IQueryable GetAll（）；
T GetById（int-id）；
}

以下是存储库：

public interface IRepository<T>
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

public class Repository<T> : IRepository<T> where T : class
{
    protected DbSet<T> DbSet;

    public Repository(DbContext dataContext)
    {
        DbSet = dataContext.Set<T>();
    }

    #region IRepository<T> Members

    public void Insert(T entity)
    {
        DbSet.Add(entity);
    }

    public void Delete(T entity)
    {
        DbSet.Remove(entity);
    }

    public IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate)
    {
        return DbSet.Where(predicate);
    }

    public IQueryable<T> GetAll()
    {
        return DbSet;
    }

    public T GetById(int id)
    {
        return DbSet.Find(id);
    }

    #endregion
}

公共类存储库：IRepository，其中T:class
{
受保护的DbSet-DbSet；
公共存储库（DbContext dataContext）
{
DbSet=dataContext.Set（）；
}
#地区成员
公共无效插入（T实体）
{
添加（实体）；
}
公共作废删除（T实体）
{
删除（实体）；
}
公共IQueryable搜索（表达式谓词）
{
返回DbSet.Where（谓词）；
}
公共IQueryable GetAll（）
{
返回DbSet；
}
公共T GetById（int-id）
{
返回DbSet.Find（id）；
}
#端区
}

将实体框架代码保持原样。现在，我们已经准备好在应用程序中使用此通用存储库，下面介绍如何：

using (var dataContext = new UserBaseContext())
{
    var userRepository = new Repository<Users>(dataContext);

    Users user = userRepository
        .SearchFor(c => c.Name.StartsWith("A"))
        .Single();

    //do other stuff

}

使用（var dataContext=new UserBaseContext（））
{
var userRepository=新存储库（dataContext）；
Users=userRepository
.SearchFor（c=>c.Name.StartsWith（“A”））
.Single（）；
//做其他事情
}

---

这不会抱怨像casing之类的东西，很高兴我有了第一个工作的通用存储库：）

我使用的方法现在被实体框架本身克服了，不确定是哪个版本的实体框架。下面的代码展示了实体框架的通用存储库模式的一个漂亮而干净的实现。这里不需要IEntity接口，因为我们使用DbSet类的便利的Find扩展方法

以下是我的假设：

public interface IRepository<T>
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

public class Repository<T> : IRepository<T> where T : class
{
    protected DbSet<T> DbSet;

    public Repository(DbContext dataContext)
    {
        DbSet = dataContext.Set<T>();
    }

    #region IRepository<T> Members

    public void Insert(T entity)
    {
        DbSet.Add(entity);
    }

    public void Delete(T entity)
    {
        DbSet.Remove(entity);
    }

    public IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate)
    {
        return DbSet.Where(predicate);
    }

    public IQueryable<T> GetAll()
    {
        return DbSet;
    }

    public T GetById(int id)
    {
        return DbSet.Find(id);
    }

    #endregion
}

公共接口IRepository
{
无效插入（T实体）；
无效删除（T实体）；
IQueryable搜索（表达式谓词）；
IQueryable GetAll（）；
T GetById（int-id）；
}

以下是存储库：

public interface IRepository<T>
{
    void Insert(T entity);
    void Delete(T entity);
    IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate);
    IQueryable<T> GetAll();
    T GetById(int id);
}

public class Repository<T> : IRepository<T> where T : class
{
    protected DbSet<T> DbSet;

    public Repository(DbContext dataContext)
    {
        DbSet = dataContext.Set<T>();
    }

    #region IRepository<T> Members

    public void Insert(T entity)
    {
        DbSet.Add(entity);
    }

    public void Delete(T entity)
    {
        DbSet.Remove(entity);
    }

    public IQueryable<T> SearchFor(Expression<Func<T, bool>> predicate)
    {
        return DbSet.Where(predicate);
    }

    public IQueryable<T> GetAll()
    {
        return DbSet;
    }

    public T GetById(int id)
    {
        return DbSet.Find(id);
    }

    #endregion
}

公共类存储库：IRepository，其中T:class
{
受保护的DbSet-DbSet；
公共存储库（DbContext dataContext）
{
DbSet=dataContext.Set（）；
}
#地区成员
公共无效插入（T实体）
{
添加（实体）；
}
公共作废删除（T实体）
{
删除（实体）；
}
公共IQueryable搜索（表达式谓词）
{
返回DbSet.Where（谓词）；
}
公共IQueryable GetAll（）
{
返回DbSet；
}
公共T GetById（int-id）
{
返回DbSet.Find（id）；
}
#端区
}

将实体框架代码保持原样。现在，我们已经准备好在应用程序中使用此通用存储库，下面介绍如何：

using (var dataContext = new UserBaseContext())
{
    var userRepository = new Repository<Users>(dataContext);

    Users user = userRepository
        .SearchFor(c => c.Name.StartsWith("A"))
        .Single();

    //do other stuff

}

使用（var dataContext=new UserBaseContext（））
{
var userRepository=新存储库（dataContext）；
Users=userRepository
.SearchFor（c=>c.Name.StartsWith（“A”））
.Single（）；
//做其他事情
}

这是不可能的