Question

I’m trying to write a C# repository with atomic contexts and feel like this is a perfect situation for the usage of a closure, but I can’t quite grok how to get it done in C#. I have this as a main method in my repository:

...
    protected virtual IQueryable<T> AsQueryable()
    {
        return _context.ObjectSet<T>().AsQueryable();
    }
...

Meanwhile, I have derived classes with methods like:

...
    public IQueryable<Arc> ByRun(Run run)
    {
        IQueryable<Arc> query = from o in AsQueryable()
                                     from r in o.Runs
                                     where r.Id == run.Id
                                     select o;
        return query;
    }
...

and I want to change my query method to return IEnumerable and to dispose quickly of the context, so want to use (something like) this:

...
    protected virtual IEnumerable<T> AsEnumerable()
    {
        using (IContextUnitOfWork unitOfWork = new EFUnitOfWork())
        {
            return unitOfWork.ObjectSet<T>().ToList();
        }
    }
...

The problem, of course, is that once the context is disposed, calling LINQ on the resulting IEnumerable set will fail. Thus, my thought is that I should bundle up the ByRun() method and pass it to AsEnumerable() to be used as a closure.

While not my original language style, I learned closures in Ruby. There, what I’m trying to do would look something like this mixed up pseudo-code:

ByRun(Run run)
  AsEnumerable do |query|
    from o in query
           from r in o.Runs
           where r.Id == run.Id
           select o;
  end
end

where the AsEnumerable method would open the context, perform the operation that was passed in, and return. I’m sure I can do this once I understand the syntax, so I’m looking for my desired AsEnumerable and ByRun methods implemented this way.

Answer 1

If I understand the question correctly, you want to have a wrapper on any query to ensure that AsEnumerable is called at the end and context is disposed just after the query?

If so (assuming that your base class is generic with T parameter), try this:

protected virtual IEnumerable<T> AsEnumerable(Func<ObjectSet<T>, IQueryable<T>> query)
{
    using (IContextUnitOfWork unitOfWork = new EFUnitOfWork())
    {
        return query(unitOfWork.ObjectSet<T>()).AsEnumerable();
    }
}

And usage example:

public IEnumerable<Arc> ByRun(Run run)
{
    return AsEnumerable(query => from o in query
                                 from r in o.Runs
                                 where r.Id == run.Id
                                 select o);
}

The parameter of AsEnumerable here is the lambda expression containing any delegate that takes ObjectSet<T> as the only parameter and returns IQueryable<T>. So it’s logically equivalent to have the following code in the derived class:

public IEnumerable<Arc> ByRun(Run run)
{
    using (IContextUnitOfWork unitOfWork = new EFUnitOfWork())
    {
        return (from o in unitOfWork.ObjectSet<T>()
                from r in o.Runs
                where r.Id == run.Id
                select o).AsEnumerable();
    }
}