Reusable Querying in Entity Framework WITHOUT Repository. How?

Let me say, I have come to the conclusion (after a lot of trial) that Repository & Unit of Work when using Entity Framework is just wrong, wrong, wrong and this says why quite well.

But I really hate on those embedded queries. Question is, where can I put them instead if I'm so against a repository, etc? (clean answers only please, examples much appreciated).

I just nuked two projects containing my repositories, unit of work and interfaces with hundreds of files because the payback was nowhere to be seen. I think lots of people, myself included, just jumped on the Repository bandwa开发者_运维技巧gon because that's what everybody else was doing but in retrospect, I think it's really a ride to nowhere.

/sigh

Richard

Where do you expect to put them? You have only few choices:

1. Let them be where they are and use custom extension methods, query views, mapped database views or custom defining queries to define reusable parts
2. Expose every single query as method on some separate class. The method mustn't expose IQueryable and mustn't accept Expression as parameter = whole query logic must be wrapped in the method. But this will make your class covering related methods much like repository (the only one which can be mocked or faked). This implementation is close to implementation used with stored procedures.
3. You will do the same as in previous method but instead of placing queries in separate class you will put them as static methods to entity directly. This is much worse testable because static methods cannot be replaced by mocking (it requires more complex testing framework). This is part of active record pattern where each entity is responsible for its loading and saving to database.

Example of custom extension method:

public static IQueryable<TEntity> GetByName(this IQueryalbe<TEntity> query, string name) 
    where TEntity : IEntityWithName
{
    return query.Where(e => e.Name == name);
}

Example of custom class exposing methods:

public class QueryProvider
{
    public QueryProvider() {}

    public IEnumerable<TEntity> GetByName(IYourContext context, string name)
        where TEntity : IEntityWithName
    {
        return context.CreateObjectSet<TEntity>().Where(e => e.Name == name).ToList();
    }
}

Build Reusable, Testable Queries Part 1

This is a blog post I wrote about building reusable queries. Using Extension Methods allows you to build composable queries.

using a pattern like the specification pattern can help you build queries that can be reused or saved (serialized). Further more if you have a double entry system you can execute the same query instance over two different databases.

the following example does not use EF but replace the IEnumerable by an EF context and you get what ou are looking for. parameters are passed in through the constructor.

public class PartialMatchQuery : IModelQuery<string, IEnumerable<string>>
{
    private readonly string partial;

    public PartialMatchQuery(string partialString)
    {
        partial = partialString;
    }

    public IEnumerable<string> Execute(IEnumerable<string> model)
    {
        return model.Where(s => s.ToLower().Contains(partial));
    }
}