Unit of Work and EF

问题

I'm making an interface following the Unit of Work pattern. My interface looks like this:

public interface IDataContext : IDisposable
{
    void SaveChanges();   
    TSource Create<TSource>(TSource toCreate) where TSource : class;
    TSource Update<TSource>(TSource toUpdate) where TSource : class;
    bool Delete<TSource>(TSource toDelete) where TSource : class;
    IQueryable<TSource> Query<TSource>();
}

So far so good. Now I implement it in my Data Layer, which uses EF4 as data provider. I came up with this code for the "Query" method, but I think it's not very clean, I feel there's a clever way to do it but I can't really figure out.

public IQueryable<TSource> Query<TSource>()
    {
        var type = typeof(TSource);
        IQueryable item = null;

        if (type == typeof(Activity)) item = _entities.ActivitySet;
        if (type == typeof(Company)) item = _entities.CompanySet;
        if (type == typeof(Phase)) item = _entities.PhasesSet;
        if (type == typeof(Project)) item = _entities.ProjectSet;
        if (type == typeof(ProjectState)) item = _entities.ProjectStateSet;
        if (type == typeof(ProjectType)) item = _entities.ProjectTypeSet;
        if (type == typeof(User)) item = _entities.UserSet;
        if (type == typeof(UserType)) item = _entities.UserTypeSet;
        if (item != null) return item as IQueryable<TSource>;

        throw new NotImplementedException(string.Format("Query not implemented for type {0}", type.FullName));
    }

The problems I see here are all the IFs get tested every time, althought I could chain them in a cascading if-else but still looks pretty awful to me. The other problems is that I have to manually add one line for each new entity that might get added, but it's not my main concern.

Anyone has any good advice on this? Thanks.

回答1:

If you are using EF4 you can just call CreateObjectSet<>.

using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Linq;

namespace WindowsFormsApplication1
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            var context = new DataContext(new NorthwindEntities());
            var list = context.Query<Customer>().ToList();
            var list2 = context.Query<Customer>().ToList();
        }
    }

    public class DataContext : IDataContext
    {
        private Dictionary<Type, object> _objectSets = new Dictionary<Type,object>();
        private ObjectContext _entities;

        public DataContext(ObjectContext objectContext)
        {
            this._entities = objectContext;
        }

        public IQueryable<T> Query<T>()
            where T : class
        {
            Type entityType = typeof(T);
            ObjectSet<T> objectSet;

            if (this._objectSets.ContainsKey(entityType))
            {
                objectSet = this._objectSets[entityType] as ObjectSet<T>;
            }
            else
            {
                objectSet = this._entities.CreateObjectSet<T>();
                this._objectSets.Add(entityType, objectSet);
            }

            return objectSet;
        }
    }

    interface IDataContext
    {
        IQueryable<T> Query<T>() where T : class;
    }
}

If you are using EF1 you can call CreateQuery<> but you will also need to find the Entity Set Name.

using System;
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Data.Objects;
using System.Linq;

namespace WindowsFormsApplication2
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            var context = new DataContext(new NorthwindEntities());
            var list = context.Query<Customer>().ToList();
        }
    }

    public class DataContext : IDataContext
    {
        private Dictionary<string, string> _entitySets;
        private ObjectContext _entities;

        public DataContext(ObjectContext objectContext)
        {
            this._entities = objectContext;
        }

        public IQueryable<T> Query<T>()
            where T : class
        {
            return this._entities.CreateQuery<T>(this.GetEntitySetName<T>());
        }

        private string GetEntitySetName<T>()
            where T : class
        {
            if (this._entitySets == null)
            {
                // create a dictionary of the Entity Type/EntitySet Name
                this._entitySets = this._entities.MetadataWorkspace
                                                 .GetItems<EntityContainer>(DataSpace.CSpace)
                                                 .First()
                                                 .BaseEntitySets.OfType<EntitySet>().ToList()
                                                 .ToDictionary(d => d.ElementType.Name, d => d.Name);
            }

            Type entityType = typeof(T);

            // lookup the entity set name based on the entityType
            return this._entitySets[entityType.Name];
        }
    }

    interface IDataContext
    {
        IQueryable<T> Query<T>() where T : class;
    }
}

回答2:

One way can be not using autogenerated ObjectContext with all predefined ObjectSets and instead call:

public IQueryable<TSource> Query<TSource>
{
  return _entities.CreateObjectSet<TSource>();
}

But I'm not sure what performance impact has creating object set each time you want to execute query. I usually have some lazy initialization of object sets (using dictionary to store already created object sets) and reusing them for single unit of work instance.

来源：https://stackoverflow.com/questions/4545938/unit-of-work-and-ef