I must also admit, that I use layered architecture and a very complicated meta-data based authorization. I cannot let top layer access datacontext directly. Top layer consumes some repository interface implementation that could actually be a secured proxy to the datacontext wrapper. This solutions also makes this possible to be implemented.

Here’s the interface:

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

namespace Common.DAL
{
    public interface IRepository : IDisposable
    {
        IList<T> Get<T>() where T : EntityObject;
        IList<T> Get<T>(DataLoadOptions dlo) where T : EntityObject;
        IList<T> Get<T>(Expression<Func<T, bool>> predicate) where T : EntityObject;
        IList<T> Get<T>(Expression<Func<T, bool>> predicate, DataLoadOptions dlo) where T : EntityObject;
        void Add<T>(T entity) where T : EntityObject;
        void Remove<T>(T entity) where T : EntityObject;
        void Save();
    }
}

Here we have several Get method overloads for convinience. Get method accepts a predicate and return IList. From the top level you can only pass you predicate, no more query changes later. In the lower layers the predicate can be analyzed or get more complicated for security reasons.

As you notice there is also a parameter of type DataLoadOptions. This stuff is needed to make joins in Linq to SQL style instead of string hardcoding so loved in Entity Framework. This class implementation will be shown in the end.

Save method is intended to be called when we want to submit all current changes to database.

Here is the class implementation:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Objects;
using System.Data.Objects.DataClasses;
using System.Linq;
using System.Linq.Expressions;
using RefreshMode=System.Data.Objects.RefreshMode;

namespace Common.DAL
{
    public class EntityFrameworkWrapperRepository : IRepository
    {
        private ObjectContext _db;
        public bool AutoSaveOnDispose { get; private set; }
        public bool AutoRefreshAfterSave { get; private set; }

        public EntityFrameworkWrapperRepository(ObjectContext objectContext, bool autoRefreshAfterSave)
        {
            if (objectContext == null)
                throw new ArgumentNullException("objectContext");

            AutoSaveOnDispose = false;
            AutoRefreshAfterSave = autoRefreshAfterSave;
            _db = objectContext;
        }

        #region Implementation of IRepository

        public IList<T> Get<T>() where T : EntityObject
        {
            return Get<T>(t => true);
        }

        public IList<T> Get<T>(DataLoadOptions dlo) where T : EntityObject
        {
            return Get<T>(t => true, dlo);
        }

        public IList<T> Get<T>(Expression<Func<T, bool>> predicate) where T : EntityObject
        {
            return Get<T>(predicate, null);
        }

        public IList<T> Get<T>(Expression<Func<T, bool>> predicate, DataLoadOptions dlo) where T : EntityObject
        {
            if (_disposed)
                throw new ObjectDisposedException(GetType().ToString());

            //looking for entityset type
            var entitySetType = ResolveEntitySetType<T>();

            var propertyType = typeof(ObjectQuery<>).MakeGenericType(new[] { entitySetType });

            var pi = _db.GetType().GetProperties()
                .Where(p => p.PropertyType == propertyType)
                .FirstOrDefault();

            if (pi == null)
                throw new InvalidOperationException("EntitySet not found");
            var entitySet = pi.GetValue(_db, null);

            if (dlo != null)
            {
                foreach (var member in dlo.GetPreloadedMembers<T>())
                {
                    var includeMethod = propertyType
                        .GetMethod("Include");

                    entitySet = includeMethod.Invoke(entitySet, new[] {member.Name});
                }
            }

            //get the exact child class
            var ofTypeMethod = propertyType
                .GetMethod("OfType")
                .MakeGenericMethod(new[] { typeof(T) });

            return ((IQueryable<T>)ofTypeMethod.Invoke(entitySet, null))
                .Where(predicate)
                .ToList();
        }

        public void Add<T>(T entity) where T : EntityObject
        {
            if (_disposed)
                throw new ObjectDisposedException(GetType().ToString());

            if (entity == null)
                throw new ArgumentNullException("entity");

            var entitySetType = ResolveEntitySetType<T>();

            var addMethod = _db.GetType().GetMethods()
                .Where(m => m.Name.StartsWith("Add"))
                .Where(m => m.GetParameters()
                                .Where(p => p.ParameterType == entitySetType).Count() == 1)
                .FirstOrDefault();

            if (addMethod == null)
                throw new InvalidOperationException("Add method not found");

            addMethod.Invoke(_db, new []{entity});
        }

        public void Remove<T>(T entity) where T : EntityObject
        {
            if (_disposed)
                throw new ObjectDisposedException(GetType().ToString());

            _db.DeleteObject(entity);
        }

        public void Save()
        {
            if (_disposed)
                throw new ObjectDisposedException(GetType().ToString());

            if (AutoRefreshAfterSave)
            {
                var changedEntities = _db.ObjectStateManager
                    .GetObjectStateEntries(EntityState.Added | EntityState.Modified)
                    .Where(e => e.Entity != null)
                    .Select(e => e.Entity).ToList();

                _db.SaveChanges();

                changedEntities.ForEach(e => _db.Refresh(RefreshMode.StoreWins, e));
            }
            else
            {
                _db.SaveChanges();
            }
        }

        private Type ResolveEntitySetType<T>()
        {
            var objectType = typeof(T);
            while (objectType.BaseType != typeof(EntityObject))
            {
                objectType = objectType.BaseType;
            }
            return objectType;
        }

        #endregion

        #region Implementation of IDisposable

        private bool _disposed;

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    if(AutoSaveOnDispose)
                        Save();

                    _db.Dispose();
                }

                _db = null;
                _disposed = true;
            }

        }

        public void Dispose()
        {
            Dispose(true);

            GC.SuppressFinalize(this);
        }

        ~EntityFrameworkWrapperRepository()
        {
            Dispose(false);
        }

        #endregion        
    }
}

The constructor accepts two parameters. The ObjectContext is the context to wrap, flag autoRefreshAfterSave is needed in case when you are using stored procedures to publish changes to the database and you’ve got some database generated values like rowversion. Without autorefresh these fields won’t be picked up by the EntityFramework.

Here I implement the interface. Reflection is needed a lot to make life better. In get method we first must figure out the entity set type. If an entity is a child in some inheritance hierarchy, then it’s entity set is of type of it’s most base class in entity hierarchy. This is solved recursively in ResolveEntitySetType method. After that I call Include method to make all needed joins. Remembering inheritance I call OfType method to specify that we want to get the type that was passed to us in method call. After all I apply the predicate.

In the Add method I also figure out the entity set type an look for an Add method in ObjectContext accepting this type parameter.

Remove is easy.

Save method has some tricky stuff. As mentioned earlier in some cases we’ve got to refresh entities after saving to database. To accomplish that I pick up the change set, call the SaveChanges method and then refresh all entities in the change set.

In the end I implement the Disposable pattern and that’s it!

If you are using POCOs, it will be easy to implement another wrapper to handle them. Probably later I’ll make a post about that, as soon as we move to .Net 4.

There are also things I’d like to improve. Reflection look-ups are done for each method call. This hits performance. To improve that I will probably do ObjectContext investigation in the constructor in advance and put EntitySet properties and Add methods to hashtables so that they would be found more quick later.

Almost forgot! The DataLoadOptions. I took the code from this post http://mosesofegypt.net/post/Introducing-DataLoadOptions-for-Entity-Framework-ObjectContext.aspx I really like the Linq to SQL style. But it has a drawback too. With this class you can only make joins to the first circle of references. Probably later I’ll improve that.

Here’s the class:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace Common.DAL
{
    public class DataLoadOptions
    {
        private static readonly string[] ValidTypes = new[] { "ComplexObject ", "StructuralObject", "EntityObject", "EntityCollection`1" };
        private readonly Dictionary<MetaPosition, MemberInfo> _includes;

        public DataLoadOptions()
        {
            _includes = new Dictionary<MetaPosition, MemberInfo>();
        }

        public MemberInfo[] GetPreloadedMembers<TEntity>()
        {
            var type = typeof(TEntity);
            var preloadedMembers = new List<MemberInfo>();

            foreach (var prop in _includes.Values.OfType<PropertyInfo>())
            {
                if (prop.DeclaringType == type)
                {
                    preloadedMembers.Add(prop);
                }
            }
            return preloadedMembers.ToArray();
        }

        internal bool IsPreloaded(MemberInfo member)
        {
            return _includes.ContainsKey(new MetaPosition(member));
        }

        public void LoadWith<T>(Expression<Func<T, object>> expression)
        {

            MemberInfo loadWithMemberInfo = GetLoadWithMemberInfo(expression);
            if (IsPreloaded(loadWithMemberInfo))
            {
                throw new InvalidOperationException("Association is already added");
            }
            Preload(loadWithMemberInfo);
        }

        private void Preload(MemberInfo association)
        {

            _includes.Add(new MetaPosition(association), association);
        }

        private static MemberInfo GetLoadWithMemberInfo(LambdaExpression lambda)
        {
            var body = lambda.Body;
            if ((body != null) && ((body.NodeType == ExpressionType.Convert) || (body.NodeType == ExpressionType.ConvertChecked)))
            {
                body = ((UnaryExpression)body).Operand;
            }
            var expression = body as MemberExpression;

            ValidateMemberExpression(expression);

            if (expression != null) return expression.Member;

            throw new InvalidOperationException("The expression specified must be of the form p.A, where p is the parameter and A is a property member.");
        }
        private static void ValidateMemberExpression(MemberExpression expression)
        {
            if ((expression == null) || (expression.Expression.NodeType != ExpressionType.Parameter) || expression.Member.MemberType != MemberTypes.Property)
            {
                throw new InvalidOperationException("The expression specified must be of the form p.A, where p is the parameter and A is a property member.");
            }
            var member = expression.Member as PropertyInfo;
            if (member != null)
            {
                //Member type must be EntityCollection<T> or StructuralObject
                var isEntityCollection = ValidTypes.Any(s => s == member.PropertyType.Name);
                var isEntity = member.PropertyType.BaseType != null &&
                               ValidTypes.Any(s => s == member.PropertyType.BaseType.Name);

                if (!isEntity && !isEntityCollection)
                {
                    var errorMsg =
                    String.Format(
                        "Related end \"{0}\" must be of type that implements System.Data.Objects.DataClasses.EntityCollection<T> or System.Data.Objects.DataClasses.IEntityWithRelationships",
                        expression);
                    throw new InvalidOperationException(errorMsg);
                }
            }
            else
            {
                throw new InvalidOperationException(String.Format("{0} must be property member", expression));
            }
        }

        private struct MetaPosition : IEqualityComparer<MetaPosition>, IEqualityComparer
        {
            private readonly int _metadataToken;

            private readonly Assembly _assembly;

            internal MetaPosition(MemberInfo mi)
                : this(mi.DeclaringType.Assembly, mi.MetadataToken)
            {
            }
            private MetaPosition(Assembly assembly, int metadataToken)
            {
                _assembly = assembly;
                _metadataToken = metadataToken;
            }

            public override bool Equals(object obj)
            {
                if (obj == null)
                {
                    return false;
                }
                if (obj.GetType() != GetType())
                {
                    return false;
                }
                return AreEqual(this, (MetaPosition)obj);
            }
            public bool Equals(MetaPosition x, MetaPosition y)
            {
                return AreEqual(x, y);
            }
            public override int GetHashCode()
            {
                return _metadataToken;
            }
            public int GetHashCode(MetaPosition obj)
            {
                return obj._metadataToken;
            }

            public static bool operator ==(MetaPosition x, MetaPosition y)
            {
                return AreEqual(x, y);
            }
            public static bool operator !=(MetaPosition x, MetaPosition y)
            {
                return !AreEqual(x, y);
            }

            bool IEqualityComparer.Equals(object x, object y)
            {
                return Equals((MetaPosition)x, (MetaPosition)y);
            }
            int IEqualityComparer.GetHashCode(object obj)
            {
                return GetHashCode((MetaPosition)obj);
            }

            private static bool AreEqual(MetaPosition x, MetaPosition y)
            {
                return ((x._metadataToken == y._metadataToken) && (x._assembly == y._assembly));
            }

        }
    }
}