Linq to Entities with Repository Pattern 和 EF

Question

I have been recently working on a Entity Framework and Repository pattern, in the repository class i have created a function called find, which takes a predicate generates the entity out of it. here's my Repository function.

public T Find(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderby = null, string includeProperties = "")
{
    IQueryable<T> query = dbSet;
    if (filter != null)
    {
        query = query.Where(filter);
    }
    foreach(var includeProperty in includeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
    {
        query = query.Include(includeProperty);
    }

    if (orderby != null)
    {
        return orderby(query).First();
    }
    else
    {
        return query.First();
    }
}

Here's my DTO class.

public class UsersDo
{
    public int UserId {get;set}
    public string Username {get;set}
    ...
}

Now i am calling the Find function on my page like:

usersDao.Find(x=>x.Username == "username")

However i gets the error

The entity or complex type 'UsersDo' cannot be constructed in a LINQ to Entities query.

Could anyone suggest what's going wrong here.

EDIT
under repository class, i have a constructor:

private readonly DbSet<T> dbSet;
private readonly DataContext context;
public GenericDao(DataContext _context)
{
    context = _context;
    dbSet = context.Set<T>();
}

my Dao class:

public class UsersDao : GenericDao<UsersDo>, IUsers
{
     public UsersDao(DataContext context) : base (context) {}
     ...
}

Answer 1

Can you try this

public class UserContext : DbContext
{
    public DbSet<UsersDo> Users { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<UsersDo>()
            .HasKey(e => e.UsersId);

        base.OnModelCreating(modelBuilder);
    }
}

public class Repo<T> where T : class
{
    private readonly DbSet<T> dbSet;

    public Repo(DbContext context)
    {
        dbSet = context.Set<T>();
    }

    public T Find(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderby = null, string includeProperties = "")
    {
        IQueryable<T> query = dbSet;
        if (filter != null)
        {
            query = query.Where(filter);
        }
        foreach (var includeProperty in includeProperties.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderby != null)
        {
            query = orderby(query);
        }

        // If you use the First() method you will get an exception when the result is empty.
        return query?.FirstOrDefault();
    }
}

------- Test the code

internal class Program
{
    private static void Main(string[] args)
    {
        var usersDao = new Repo<UsersDo>(new UserContext());

        var r = usersDao.Find(x => x.Username == "username");
    }
}

Answer 2

I'd highly recommend a simplified repository pattern that will help with mocking your data source for testing, and provide more flexibility. I do not recommend using generic repositories, but rather to treat a repository similar to a Controller. (I serve data for a particular set of operations) This cuts down on the number of dependency references, though favours SRP over DNRY.

For example:

public class OrderRepository : IOrderRepository
{
    private MyDbContext Context
    {
        return _contextLocator.Get<MyDbContext>() ?? throw new InvalidOperation("The repository must be called from within a context scope.");
    }

    IQueryable<Order> IOrderRepository.GetOrders()
    {
        var query = Context.Orders.Where(x => x.IsActive);
        return query;
    }

    IQueryable<Order> IOrderRepository.GetOrderById(int orderId)
    {
        var query = Context.Orders.Where(x => x.IsActive && x.OrderId == orderId);
        return query;
    }

    Order IOrderRepository.CreateOrder( /* Required references/values */)
    {
    }

    void IOrderRepository.DeleteOrder(Order order)
    {
    }
}

By returning IQueryable the consuming code can maintain control over optional filter criteria, sorting, paging, and operations against the data without triggering unnecessary data reads. There is no need for complicated expression parameters for filtering, sorting, or extra parameters to manage paging. The repository serves as the gate-keeper for required filters such as IsActive, authorization checks, etc. The repository also can serve as an entity factory, ensuring that all mandatory fields and references are provided when creating a new entity. I also let the repository manage the delete operations to ensure that all validation and integrity are enforced, plus auditing records, and handle soft-delete scenarios. (IsActive)

Some people shun the use of IQueryable on the grounds it "leaks" EF-isms into the controllers. However, it leaks them no more than complicated methods passing expressions in an attempt to abstract away EF. Every condition expression is equally vulnerable to needing to conform with EF-isms. (Ie passing an order-by expression which references a private method on an entity or a static method)

The benefit of a repository pattern like this (versus just leaving code accessing DbSets) is ease of testing. A mocked repository just has to return a List<T> AsQueryable and your controllers etc. can be tested in isolation. It also provides a nice centralization for required filters and operations against entities.

Answer 3

The problem is userDoa is not registered entity in your DbContext.

Also,

public class UsersDao : GenericDao<UsersDo>, IUsers
{
     public UsersDao(DataContext context) : base (context) {}
     ...
}

is not needed I believe. The problem is not related with your generic repository.

public class DataContext : DbContext
{
     public virtual DbSet<UserDo> UserDos { get; set; }
}

public class UserDo 
{
    [Key]
    public int UserId {get;set}

    public string Username {get;set}
}

then

var result = new UserContext().Find(x => x.Username == "John");