About two years ago have written a post and an article in codeproject about the repository pattern implementation with EF V1. After that I got a lot of requests in my articles to make it compatible for EF4 POCO support. So here I am going to make that. In this implementation of repository, I am going to add some new methods which has helped me to regularly while working with EF4 POCO support.

Hope it will help you-

public class Repository<E, C> : IRepository<E, C>, IDisposable
    where E : BaseDataContract
    where C : BaseContext
{
    private C _ctx;

    private string _KeyProperty = "ID";

    public string KeyProperty
    {
        get
        {
            return _KeyProperty;
        }
        set
        {
            _KeyProperty = value;
        }
    }

    public C Session
    {
        get { return _ctx; }
        set { _ctx = value; }
    }

    public Repository(C session)
    {
        _ctx = session;
    }

    public Repository(C session, string keyProperty) : this(session)
    {
        _KeyProperty = keyProperty;
    }

    #region IRepository<E,C> Members

    public int Save()
    {
        return _ctx.SaveChanges();
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(string entitySetName)
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        return _ctx.CreateQuery<E>("[" + entitySetName + "]");
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery()
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]");
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(string entitySetName, ISpecification<E> where)
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        return
            (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + entitySetName + "]")
            .Where(where.EvalPredicate);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(ISpecification<E> where)
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        return
            (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + typeof(E).Name + "]")
            .Where(where.EvalPredicate);
    }
    /// <summary>
    /// Query Entity with Paging
    /// </summary>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> DoQuery(int maximumRows, int startRowIndex)
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        return (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Skip<E>(startRowIndex).Take(maximumRows);
    }
    /// <summary>
    /// Query Entity in sorted Order
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="ErrorCode">custom Error Message</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> DoQuery(Expression<Func<E, object>> sortExpression)
    {
        if (null == sortExpression)
        {
            return ((IRepository<E, C>)this).DoQuery();
        }
        return (ObjectQuery<E>)((IRepository<E, C>)this).DoQuery().OrderBy<E, object>(sortExpression);
    }
    /// <summary>
    /// Query All Entity in sorted Order with Paging support
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection Of entites</returns>
    public ObjectQuery<E> DoQuery(Expression<Func<E, object>> sortExpression, int maximumRows, int startRowIndex)
    {
        if (sortExpression == null)
        {
            return ((IRepository<E, C>)this).DoQuery(maximumRows, startRowIndex);
        }
        return (ObjectQuery<E>)((IRepository<E, C>)this).DoQuery(sortExpression).Skip<E>(startRowIndex).Take(maximumRows);
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> SelectAll(string entitySetName)
    {
        return DoQuery(entitySetName);
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> SelectAll()
    {
        try
        {
            return DoQuery(); //_ctx.CreateQuery<E>("[" + typeof(E).Name + "]");
        }
        catch (Exception)
        {
            throw;
        }
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> SelectAll(string entitySetName, ISpecification<E> where)
    {
        return DoQuery(entitySetName, where);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> SelectAll(ISpecification<E> where)
    {
        return DoQuery(where);
    }
    /// <summary>
    /// Select All Entity with Paging
    /// </summary>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> SelectAll(int maximumRows, int startRowIndex)
    {
        return DoQuery(maximumRows, startRowIndex);
    }
    /// <summary>
    /// Select All Entity in sorted Order
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="ErrorCode">custom Error Message</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> SelectAll(Expression<Func<E, object>> sortExpression)
    {
        if (null == sortExpression)
        {
            return DoQuery(sortExpression);
        }
        return DoQuery(sortExpression);
    }
    /// <summary>
    /// Select All Entity in sorted Order with Paging support
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection Of entites</returns>
    public ObjectQuery<E> SelectAll(Expression<Func<E, object>> sortExpression, int maximumRows, int startRowIndex)
    {
        if (sortExpression == null)
        {
            return DoQuery(maximumRows, startRowIndex);
        }
        return DoQuery(sortExpression, maximumRows, startRowIndex);
    }
    /// <summary>
    /// Get Entity By Primary Key
    /// </summary>
    /// <typeparam name="E">Entity Type</typeparam>
    /// <param name="Key">Primary Key Value</param>
    /// <returns>return entity</returns>
    public E SelectByKey(string Key)
    {
        _ctx.ContextOptions.LazyLoadingEnabled = true;
        // First we define the parameter that we are going to use the clause.
        var xParam = Expression.Parameter(typeof(E), typeof(E).Name);
        MemberExpression leftExpr = MemberExpression.Property(xParam, this._KeyProperty);
        Expression rightExpr = Expression.Constant(Key);
        BinaryExpression binaryExpr = MemberExpression.Equal(leftExpr, rightExpr);
        //Create Lambda Expression for the selection
        Expression<Func<E, bool>> lambdaExpr = Expression.Lambda<Func<E, bool>>(binaryExpr, new ParameterExpression[] { xParam });
        //Searching ....
        ObjectQuery<E> resultCollection = ((IRepository<E, C>)this).SelectAll(new Specification<E>(lambdaExpr));
        if (null != resultCollection && resultCollection.Count() > 0)
        {
            //return valid single result
            return resultCollection.First<E>();
        }//end if
        return null;
    }
    /// <summary>
    /// Check if value of specific field is already exist
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="fieldName">name of the Field</param>
    /// <param name="fieldValue">Field value</param>
    /// <param name="key">Primary key value</param>
    /// <returns>True or False</returns>
    public bool TrySameValueExist(string fieldName, object fieldValue, string key)
    {
        // First we define the parameter that we are going to use the clause.
        var xParam = Expression.Parameter(typeof(E), typeof(E).Name);
        MemberExpression leftExprFieldCheck = MemberExpression.Property(xParam, fieldName);
        Expression rightExprFieldCheck = Expression.Constant(fieldValue);
        BinaryExpression binaryExprFieldCheck = MemberExpression.Equal(leftExprFieldCheck, rightExprFieldCheck);

        MemberExpression leftExprKeyCheck = MemberExpression.Property(xParam, this._KeyProperty);
        Expression rightExprKeyCheck = Expression.Constant(key);
        BinaryExpression binaryExprKeyCheck = MemberExpression.NotEqual(leftExprKeyCheck, rightExprKeyCheck);
        BinaryExpression finalBinaryExpr = Expression.And(binaryExprFieldCheck, binaryExprKeyCheck);

        //Create Lambda Expression for the selection
        Expression<Func<E, bool>> lambdaExpr = Expression.Lambda<Func<E, bool>>(finalBinaryExpr, new ParameterExpression[] { xParam });
        //Searching ....
        return ((IRepository<E, C>)this).TryEntity(new Specification<E>(lambdaExpr));
    }
    /// <summary>
    /// Check if Entities exist with Condition
    /// </summary>
    /// <param name="selectExpression">Selection Condition</param>
    /// <returns>True or False</returns>
    public bool TryEntity(ISpecification<E> selectSpec)
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Any<E>(selectSpec.EvalPredicate);
    }
    /// <summary>
    /// Get Count of all records
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <returns>count of all records</returns>
    public int GetCount()
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Count();
    }
    /// <summary>
    /// Get count of selection
    /// </summary>
    /// <typeparam name="E">Selection Condition</typeparam>
    /// <returns>count of selection</returns>
    public int GetCount(ISpecification<E> selectSpec)
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]")
            .Where(selectSpec.EvalPredicate).Count();
    }
    /// <summary>
    /// Delete data from context
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="entity"></param>
    public void Delete(E entity)
    {
        //object deletedObject;
        //_ctx.TryGetObjectByKey(entity.EntityKey, out deletedObject);
        _ctx.DeleteObject(entity);
    }
    /// <summary>
    /// Delete data from context
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="entity"></param>
    public void Delete(object entity)
    {
        //object deletedObject;
        //_ctx.TryGetObjectByKey(((EntityObject)entity).EntityKey, out deletedObject);
        _ctx.DeleteObject(entity);
    }
    /// <summary>
    /// Insert new data into context
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="entity"></param>
    public void Add(E entity)
    {
        _ctx.AddObject(entity.GetType().Name, entity);
    }
    /// <summary>
    /// Insert if new otherwise attach data into context. Plus,
    /// returns a list of changed property name and value (in
    /// this format--> "propName|originalValue|newValue")- if any.
    /// </summary>
    /// <param name="entity"></param>
    public List<String> AddOrAttach(E entity, EntityKey key = null)
    {
        try
        {
            _ctx.ContextOptions.LazyLoadingEnabled = false;

            ObjectStateEntry entry = null;
            //Add the object graph into the context
            if (null == key )
            {
                var entitySet = _ctx.GetEntitySet(entity.GetType());
                key = _ctx.CreateEntityKey(entitySet.Name, entity);
            }

            if( null != key )
                _ctx.ObjectStateManager.TryGetObjectStateEntry(key, out entry);
            if (entry == null)
            {
                _ctx.AddObject(typeof(E).Name, entity);
                _ctx.ObjectStateManager.ChangeObjectState(entity, StateHelpers.GetEquivelantEntityState(entity.ObjectState));
            }
            else
            {
                _ctx.ApplyCurrentValues(typeof(E).Name, entity);
            }
            //get the changed column values (needed for audit trail)
            List<String> changedCols = new List<string>();
            var ose = (entry != null)? entry : _ctx.ObjectStateManager.GetObjectStateEntry(entity);
            foreach (var propName in ose.GetModifiedProperties())
            {
                string pNameValue = propName;
                pNameValue += "|" + ose.OriginalValues[propName] + "|" + ose.CurrentValues[propName];
                changedCols.Add(pNameValue);
            }

            return changedCols;
        }
        catch (Exception)
        {
            throw;
        }
    }
    /// <summary>
    /// Start Transaction
    /// </summary>
    /// <returns></returns>
    public DbTransaction BeginTransaction()
    {
        if (_ctx.Connection.State != ConnectionState.Open)
        {
            _ctx.Connection.Open();
        }
        return _ctx.Connection.BeginTransaction();
    }
    /// <summary>
    /// Change state of Navigation Object(s)
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <typeparam name="T"></typeparam>
    /// <param name="context"></param>
    /// <param name="entity"></param>
    /// <param name="state"></param>
    public void ChangeStateOfNavigationObject(E entity, State state)
    {
        if (null != entity)
        {
            var navigationProperties = _ctx.GetNavigationProperty<C, E>();
            if (null != navigationProperties)
            {
                foreach (var navigationProperty in navigationProperties)
                {
                    var info = entity.GetType().GetProperty(navigationProperty.Name);
                    var value = info.GetValue(entity, null);

                    if (value != null)
                    {

                        if (((AssociationType)navigationProperty.RelationshipType).IsForeignKey
                            &&
                            navigationProperty.FromEndMember.RelationshipMultiplicity !=
                            RelationshipMultiplicity.Many)
                        {
                            Type t = value.GetType();
                            Type baseType;
                            if (!t.IsGenericType)
                            {
                                baseType = t.BaseType;

                                if (baseType.BaseType.Equals(typeof(BaseDataContract)))
                                {
                                    MethodInfo method = this.GetType().GetMethod("ChangeObjectStatetoAttach");
                                    MethodInfo generic = method.MakeGenericMethod(baseType);
                                    generic.Invoke(this, new object[] { value, state });
                                }
                            }
                            else
                            {
                                Type[] genericBases = t.GetGenericArguments();
                                // Q&D: pick the first one
                                baseType = genericBases[0];

                                if (baseType.BaseType.Equals(typeof(BaseDataContract)))
                                {
                                    MethodInfo method =
                                        this.GetType().GetMethod("ChangeCollectionObjectStatetoAttach");
                                    MethodInfo generic = method.MakeGenericMethod(baseType);
                                    generic.Invoke(this, new object[] { value, state });
                                }
                            }
                        }
                        else
                        {
                            info.SetValue(entity, null, null);
                        }
                    }//end if
                }
            }
        }
    }
    /// <summary>
    /// change state of an single object
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="state"></param>
    public void ChangeObjectStatetoAttach<T>(T entity, State state) where T : BaseDataContract
    {
        if (null != entity)
        {
            var dataContract = entity as BaseDataContract;
            dataContract.ObjectState = state;
            EntityKey entityKey = _ctx.CreateEntityKey(
                _ctx.GetEntitySet(dataContract.GetType()).Name, dataContract);
            ObjectStateEntry storeEntity;
            if (_ctx.ObjectStateManager.TryGetObjectStateEntry(entityKey, out storeEntity))
            {
                _ctx.ApplyCurrentValues(_ctx.GetEntitySet(typeof(T)).Name, entity);
                //(storeEntity as T).ObjectState = State.Unchanged;
            }
            else
            {
                _ctx.AddObject(_ctx.GetEntitySet(dataContract.GetType()).Name, dataContract);
            }
            _ctx.ObjectStateManager.ChangeObjectState(dataContract,
                                                         StateHelpers.
                                                             GetEquivelantEntityState
                                                             (dataContract.ObjectState));
        }
    }
    /// <summary>
    ///
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="state"></param>
    public void ChangeCollectionObjectStatetoAttach<T>(FixupCollection<T> entities, State state)
       where T : BaseDataContract
    {
        if (null != entities)
        {
            for (int i = 0; i < entities.Count; i++)
            {
                ChangeObjectStatetoAttach<T>(entities[i], state);
            }
        }
    }

    #endregion

    #region IDisposable Members

    public void Dispose()
    {
        if (null != _ctx)
        {
            if (_ctx.Connection.State == ConnectionState.Open)
                _ctx.Connection.Close();
            _ctx.Dispose();
        }
    }

    #endregion

}

To work with some bulk operation and getting related entities on runtime,  I have added some extension methods to find out related navigation info – 

   1: public static List<NavigationProperty> GetNavigationProperty<TObjectContext, T>(

   2:         this ObjectContext context)

   3:         where TObjectContext : ObjectContext

   4:          {

   5:              var containerName = context.DefaultContainerName;

   6:              var model = DataSpace.CSpace;

   7:              var workspace = context.MetadataWorkspace;

   8:              var container = workspace.GetEntityContainer(containerName, model);

   9:              EntitySetBase entitySet = context.GetEntitySet(typeof (T));

  10:  

  11:              if (entitySet == null)

  12:                  return null;

  13:  

  14:              //materialize nav props for testing

  15:              var navigationProps = entitySet.ElementType.Members

  16:                  .Where(m => m.BuiltInTypeKind == BuiltInTypeKind.NavigationProperty

  17:                  )

  18:                  .Cast<NavigationProperty>()

  19:                  .ToList();

  20:  

  21:             return navigationProps;

  22:          }

  23:   

  24:         public static EntitySetBase GetEntitySet(this ObjectContext context, Type entityType)

  25:         {

  26:             if (context == null)

  27:             {

  28:                 throw new ArgumentNullException("context");

  29:             }

  30:             if (entityType == null)

  31:             {

  32:                 throw new ArgumentNullException("entityType");

  33:             }

  34:             EntityContainer container = context.MetadataWorkspace.GetEntityContainer(context.DefaultContainerName, DataSpace.CSpace);

  35:             if (container == null)

  36:             {

  37:                 return null;

  38:             }

  39:             EntitySetBase entitySet = container.BaseEntitySets.Where(item => item.ElementType.Name.Equals(entityType.Name))

  40:                                                               .FirstOrDefault();

  41:             return entitySet;

  42:         }

Also some methods in context which I got from my very favorite Matthieu MEZIL post of bulk delete operation -

   1: public class BaseContext : ObjectContext, IObjectContextWithBulkOperations

   2:     {

   3:         #region Constructors

   4:  

   5:         public BaseContext(string connectionString, string containerName)

   6:             : base(connectionString, containerName)

   7:         {

   8:             this.ContextOptions.LazyLoadingEnabled = false;

   9:         }

  10:  

  11:         public BaseContext(EntityConnection connection, string containerName)

  12:             : base(connection, containerName)

  13:         {

  14:             this.ContextOptions.LazyLoadingEnabled = false;

  15:         }

  16:     

  17:         #endregion

  18:  

  19:         #region IContext Members

  20:  

  21:         public string Save()

  22:         {

  23:             string validationErrors;

  24:             if (ValidateBeforeSave(out validationErrors))

  25:             {

  26:                 //StateFixup();

  27:                 SaveChanges();

  28:                 return "";

  29:             }

  30:             return "Data Not Saved due to Validation Errors: " + validationErrors;

  31:         }

  32:  

  33:         public IEnumerable<T> ManagedEntities<T>()

  34:         {

  35:             var oses =

  36:                 ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified |

  37:                                                          EntityState.Unchanged | EntityState.Detached);

  38:             return oses.Where(entry => entry.Entity is T)

  39:                        .Select(entry => (T)entry.Entity);

  40:         }

  41:  

  42:         public bool ValidateBeforeSave(out string validationErrors)

  43:         {

  44:             bool isvalid = true;

  45:             validationErrors = "";

  46:             return isvalid;

  47:         }

  48:  

  49:         public void ChangeState<T>(State state, T entity) where T : class

  50:         {

  51:             ObjectStateManager.ChangeObjectState(entity, StateHelpers.GetEquivelantEntityState(state));

  52:         }

  53:  

  54:         #endregion

  55:  

  56:         public void UpdateTrackedEntity<T>(T modifiedEntity) where T : class

  57:         {

  58:             var set = this.CreateObjectSet<T>();

  59:             set.ApplyCurrentValues(modifiedEntity);

  60:         }

  61:  

  62:         #region IObjectContextWithBulkOperations Member

  63:  

  64:         private List<Action> _bulkDeletedActions;

  65:         private List<Action> BulkDeletedActions

  66:         {

  67:             get

  68:             {

  69:                 if (_bulkDeletedActions == null)

  70:                     _bulkDeletedActions = new List<Action>();

  71:                 return _bulkDeletedActions;

  72:             }

  73:         }

  74:  

  75:         private List<object> _bulkDeletedEntities;

  76:         public List<object> BulkDeletedEntities

  77:         {

  78:             get

  79:             {

  80:                 if (_bulkDeletedEntities == null)

  81:                     _bulkDeletedEntities = new List<object>();

  82:                 return _bulkDeletedEntities;

  83:             }

  84:         }

  85:  

  86:         private Dictionary<Type, List<Func<object, bool>>> _bulkDeletedFuncs;

  87:         public Dictionary<Type, List<Func<object, bool>>> BulkDeletedFuncs

  88:         {

  89:             get

  90:             {

  91:                 if (_bulkDeletedFuncs == null)

  92:                     _bulkDeletedFuncs = new Dictionary<Type, List<Func<object, bool>>>();

  93:                 return _bulkDeletedFuncs;

  94:             }

  95:         }

  96:  

  97:         public void Delete<TBase, T>(ObjectSet<TBase> entitySet, Expression<Func<T, bool>> predicate)

  98:             where T : class, TBase

  99:             where TBase : class

 100:         {

 101:             Delete<TBase, T>(entitySet, predicate, true);

 102:         }

 103:         public void DeleteLoadedEntities<TBase, T>(ObjectSet<TBase> entitySet, Expression<Func<T, bool>> predicate)

 104:             where T : class, TBase

 105:             where TBase : class

 106:         {

 107:             if ((predicate = CalculatePredicate(entitySet, predicate)) != null)

 108:                 Delete<TBase, T>(entitySet, predicate, false);

 109:         }

 110:  

 111:         private Expression<Func<T, bool>> CalculatePredicate<TBase, T>(ObjectSet<TBase> entitySet, Expression<Func<T, bool>> oldPredicate)

 112:             where T : class, TBase

 113:             where TBase : class

 114:         {

 115:             IEnumerable<PropertyInfo> keyMembers = entitySet.EntitySet.ElementType.KeyMembers.Select(km => typeof(T).GetProperty(km.Name)).ToList();

 116:             IEnumerable<T> entitiesEnumerable = ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged)

 117:                                                 .Select(ose => ose.Entity)

 118:                                                 .OfType<T>();

 119:             ParameterExpression parameter = oldPredicate.Parameters.Single();

 120:             if (!entitiesEnumerable.Any())

 121:                 return null;

 122:             return Expression.Lambda<Func<T, bool>>(

 123:                 Expression.AndAlso(

 124:                     oldPredicate.Body,

 125:                     entitiesEnumerable.Select(e =>

 126:                         keyMembers.Select(km =>

 127:                             Expression.Equal(

 128:                                 Expression.MakeMemberAccess(parameter, km),

 129:                                 Expression.Constant(km.GetValue(e, null))))

 130:                         .Aggregate((accumulate, clause) =>

 131:                             Expression.AndAlso(accumulate, clause)))

 132:                     .Aggregate((accumulate, clause) =>

 133:                         Expression.OrElse(accumulate, clause)))

 134:                 , oldPredicate.Parameters);

 135:         }

 136:  

 137:         private void Delete<TBase, T>(ObjectSet<TBase> entitySet, Expression<Func<T, bool>> predicate, bool propagateToFutureEntities)

 138:             where TBase : class

 139:             where T : class, TBase

 140:         {

 141:             ObjectQuery<T> objectQuery = (ObjectQuery<T>)entitySet.OfType<T>().Where(predicate);

 142:             string selectSQLQuery = objectQuery.ToTraceString();

 143:             List<KeyValuePair<string, List<string>>> froms = new List<KeyValuePair<string, List<string>>>();

 144:             Match fromMatch = Regex.Match(entitySet.OfType<T>().ToTraceString(), "(FROM|JOIN)[ ]+((\\[[^\\]]+\\]).)*\\[([^\\]]+)\\]");

 145:             List<AssociationType> ssdlAsscociations = MetadataWorkspace.GetItems(DataSpace.SSpace).OfType<AssociationType>().ToList();

 146:             string firstFrom = null;

 147:             while (fromMatch.Success)

 148:             {

 149:                 string fromValue = fromMatch.Groups[4].Value;

 150:                 if (Regex.IsMatch(selectSQLQuery, string.Format("(FROM|JOIN)[ ]+((\\[[^\\]]+\\]).)*\\[{0}\\]", fromValue)))

 151:                 {

 152:                     var index = (from ssdlAssociation in ssdlAsscociations

 153:                                  where ssdlAssociation.ReferentialConstraints.Any(rc => fromValue == rc.ToProperties.First().DeclaringType.Name)

 154:                                  from table in froms.Select((f, i) => new { Table = f, Index = i })

 155:                                  where ssdlAssociation.ReferentialConstraints.Any(rc => table.Table.Key == rc.FromProperties.First().DeclaringType.Name)

 156:                                  orderby table.Index

 157:                                  select new { Index = table.Index, SSDLAssociation = ssdlAssociation, FKs = table.Table }).FirstOrDefault();

 158:                     if (index != null)

 159:                         froms.Insert(index.Index, new KeyValuePair<string, List<string>>(fromValue, (from fk in index.FKs.Value

 160:                                                                                                      let referentailConstraint = index.SSDLAssociation.ReferentialConstraints.First(rc => index.FKs.Key == rc.FromProperties.First().DeclaringType.Name)

 161:                                                                                                      select referentailConstraint.ToProperties.ElementAt(referentailConstraint.FromProperties.Select((p, pIndex) => new { p.Name, Index = pIndex }).First(p => p.Name == fk).Index).Name).ToList()));

 162:                     else

 163:                     {

 164:                         if (firstFrom == null)

 165:                             firstFrom = fromValue;

 166:                         froms.Add(new KeyValuePair<string, List<string>>(fromValue, MetadataWorkspace.GetItems(DataSpace.SSpace).OfType<EntityType>().First(et => et.Name == fromValue).KeyMembers.Select(km => km.Name).ToList()));

 167:                     }

 168:                 }

 169:                 fromMatch = fromMatch.NextMatch();

 170:             }

 171:             StringBuilder delete = new StringBuilder();

 172:  

 173:             string selectSQLQueryWithoutSelect = selectSQLQuery.Substring(selectSQLQuery.IndexOf("FROM"));

 174:             IEnumerator<EdmMember> keyMembersEnumerator = null;

 175:  

 176:             if (froms.Count > 1)

 177:             {

 178:                 delete.Append("declare @DeleteIds table (");

 179:                 StringBuilder keys = new StringBuilder();

 180:                 keyMembersEnumerator = MetadataWorkspace.GetItems(DataSpace.SSpace).OfType<EntityType>().

 181:                     First(et => et.Name == firstFrom).KeyMembers.ToList().GetEnumerator();

 182:                 keyMembersEnumerator.MoveNext();

 183:                 for (; ; )

 184:                 {

 185:                     string keyName = keyMembersEnumerator.Current.Name;

 186:                     keys.Append(keyName);

 187:                     delete.Append(keyName);

 188:                     delete.Append(" ");

 189:                     delete.Append(keyMembersEnumerator.Current.TypeUsage.EdmType.Name);

 190:                     Facet maxLength = keyMembersEnumerator.Current.TypeUsage.Facets.FirstOrDefault(f => f.Name == "MaxLength");

 191:                     if (maxLength != null)

 192:                     {

 193:                         delete.Append("(");

 194:                         delete.Append(maxLength.Value);

 195:                         delete.Append(")");

 196:                     }

 197:                     if (keyMembersEnumerator.MoveNext())

 198:                     {

 199:                         keys.Append(", ");

 200:                         delete.Append(", ");

 201:                     }

 202:                     else

 203:                         break;

 204:                 }

 205:                 delete.Append(");\n");

 206:  

 207:                 delete.Append("INSERT INTO @DeleteIds SELECT ");

 208:                 delete.Append(keys.ToString());

 209:                 delete.Append(" ");

 210:                 delete.Append(selectSQLQueryWithoutSelect.Replace("@p__linq__", "@p"));

 211:                 delete.Append(";\n");

 212:             }

 213:  

 214:             foreach (KeyValuePair<string, List<string>> from in froms)

 215:             {

 216:                 delete.Append("DELETE FROM [");

 217:                 delete.Append(from.Key);

 218:                 delete.Append("] FROM ");

 219:  

 220:                 if (froms.Count > 1)

 221:                 {

 222:                     delete.Append("[");

 223:                     delete.Append(from.Key);

 224:                     delete.Append("]");

 225:                     delete.Append("INNER JOIN @deleteIds D ON ");

 226:  

 227:                     keyMembersEnumerator.Reset();

 228:                     keyMembersEnumerator.MoveNext();

 229:                     int index = 0;

 230:                     for (; ; )

 231:                     {

 232:                         delete.Append("[");

 233:                         delete.Append(from.Key);

 234:                         delete.Append("].");

 235:                         delete.Append(from.Value[index++]);

 236:                         delete.Append(" = D.");

 237:                         delete.Append(keyMembersEnumerator.Current);

 238:  

 239:                         if (keyMembersEnumerator.MoveNext())

 240:                             delete.Append(" AND ");

 241:                         else

 242:                             break;

 243:                     }

 244:                 }

 245:                 else

 246:                     delete.Append(selectSQLQueryWithoutSelect.Substring(4).TrimStart());

 247:  

 248:                 delete.Append(";\n");

 249:             }

 250:  

 251:             BulkDeletedActions.Add(() => ExecuteStoreCommand(delete.ToString(), objectQuery.Parameters.Select(p => p.Value).ToArray()));

 252:  

 253:             Func<T, bool> predicateCompiled = predicate.Compile();

 254:             Func<object, bool> predicateCompiledObject = o =>

 255:             {

 256:                 T t = o as T;

 257:                 if (t == null)

 258:                     return false;

 259:                 return predicateCompiled(t);

 260:             };

 261:             if (propagateToFutureEntities)

 262:             {

 263:                 List<Func<object, bool>> bulkDeletedFuncs;

 264:                 if (BulkDeletedFuncs.TryGetValue(typeof(TBase), out bulkDeletedFuncs))

 265:                     bulkDeletedFuncs.Add(predicateCompiledObject);

 266:                 else

 267:                     BulkDeletedFuncs.Add(typeof(TBase), new List<Func<object, bool>>() { predicateCompiledObject });

 268:             }

 269:             EntityType entityType = MetadataWorkspace.GetItems(DataSpace.CSpace).OfType<EntityType>().First(et => et.Name == typeof(T).Name);

 270:             var oneToOneSubEntityTypes = (from np in entityType.NavigationProperties

 271:                                           where np.FromEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One

 272:                                           let otherEntityType = np.ToEndMember.GetEntityType()

 273:                                           let otherNavigationProperty = otherEntityType.NavigationProperties.FirstOrDefault(otherNP => otherNP.RelationshipType == np.RelationshipType)

 274:                                           select new

 275:                                           {

 276:                                               EntityType = otherEntityType,

 277:                                               ClrType = typeof(T).GetProperty(np.Name).PropertyType,

 278:                                               OtherNavigationPropertyName = otherNavigationProperty == null ? null : otherNavigationProperty.Name,

 279:                                               ReferencialConstraint = ((AssociationType)np.RelationshipType).ReferentialConstraints.FirstOrDefault()

 280:                                           }).ToList();

 281:             foreach (var subEntityTypeLoop in oneToOneSubEntityTypes)

 282:             {

 283:                 var subEntityType = subEntityTypeLoop;

 284:                 if (subEntityType.OtherNavigationPropertyName != null)

 285:                 {

 286:                     List<string> entityTypeKeys, subEntityTypeKeys;

 287:                     if (subEntityType.ReferencialConstraint.FromProperties.First().DeclaringType == entityType)

 288:                     {

 289:                         entityTypeKeys = subEntityType.ReferencialConstraint.FromProperties.Select(p => p.Name).ToList();

 290:                         subEntityTypeKeys = subEntityType.ReferencialConstraint.ToProperties.Select(p => p.Name).ToList();

 291:                     }

 292:                     else

 293:                     {

 294:                         entityTypeKeys = subEntityType.ReferencialConstraint.ToProperties.Select(p => p.Name).ToList();

 295:                         subEntityTypeKeys = subEntityType.ReferencialConstraint.FromProperties.Select(p => p.Name).ToList();

 296:                     }

 297:                     ParameterExpression entityParameter = Expression.Parameter(typeof(object), "entity");

 298:                     ParameterExpression subEntityParameter = Expression.Parameter(typeof(object), "subEntity");

 299:                     Func<object, object, bool> associateToBulkEntities =

 300:                         Expression.Lambda<Func<object, object, bool>>(

 301:                             entityTypeKeys.Select((entityTypeKey, keyIndex) =>

 302:                                 Expression.Equal(

 303:                                     Expression.MakeMemberAccess(

 304:                                         Expression.Convert(

 305:                                             subEntityParameter,

 306:                                             subEntityType.ClrType),

 307:                                         subEntityType.ClrType.GetProperty(subEntityTypeKeys[keyIndex])),

 308:                                     Expression.MakeMemberAccess(

 309:                                         Expression.Convert(

 310:                                             entityParameter,

 311:                                             typeof(T)),

 312:                                         typeof(T).GetProperty(entityTypeKey)))).

 313:                             Aggregate((accumulate, keyPredicate) => Expression.AndAlso(accumulate, keyPredicate)),

 314:                             entityParameter,

 315:                             subEntityParameter).

 316:                             Compile();

 317:                     Func<object, bool> npPredicate = subE => BulkDeletedEntities.OfType<T>().Any(e => associateToBulkEntities(e, subE));

 318:  

 319:                     List<Func<object, bool>> bulkDeletedFuncs;

 320:                     if (BulkDeletedFuncs.TryGetValue(subEntityType.ClrType, out bulkDeletedFuncs))

 321:                         bulkDeletedFuncs.Add(npPredicate);

 322:                     else

 323:                         BulkDeletedFuncs.Add(subEntityType.ClrType, new List<Func<object, bool>>() { npPredicate });

 324:                 }

 325:             }

 326:             foreach (var entity in ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged).

 327:                                     Select(ose => new { Entity = ose.Entity as T, ose.State }).

 328:                                     Where(e => e.Entity != null && predicateCompiled(e.Entity)))

 329:             {

 330:                 if (entity.State != EntityState.Deleted)

 331:                     DeleteObjectAndAddThemIntoBulkDeletedEntities(entity.Entity);

 332:                 else

 333:                 {

 334:                     BulkDeletedEntities.Add(entity.Entity);

 335:                     foreach (var subEntity in oneToOneSubEntityTypes.

 336:                                                 SelectMany(subEntityType =>

 337:                                                     ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged).

 338:                                                     Where(ose => subEntityType.ClrType.IsAssignableFrom(ose.Entity.GetType()) && !BulkDeletedEntities.Contains(ose.Entity))))

 339:                         ApplyBulkDeletedFuncs(subEntity.Entity, subEntity.State);

 340:                 }

 341:             }

 342:         }

 343:  

 344:         private void ApplyBulkDeletedFuncs(object entity, EntityState entityState)

 345:         {

 346:             List<Func<object, bool>> bulkDeletedFuncs;

 347:             if (_bulkDeletedFuncs != null)

 348:             {

 349:                 Type t = entity.GetType();

 350:                 do

 351:                 {

 352:                     if (BulkDeletedFuncs.TryGetValue(t, out bulkDeletedFuncs))

 353:                         foreach (Func<object, bool> bulkDeletedFunc in bulkDeletedFuncs)

 354:                             if (bulkDeletedFunc(entity))

 355:                             {

 356:                                 if (entityState != EntityState.Deleted)

 357:                                     DeleteObjectAndAddThemIntoBulkDeletedEntities(entity);

 358:                                 else

 359:                                     BulkDeletedEntities.Add(entity);

 360:                                 return;

 361:                             }

 362:                 } while ((t = t.BaseType) != null);

 363:             }

 364:         }

 365:  

 366:         private void DeleteObjectAndAddThemIntoBulkDeletedEntities(object entity)

 367:         {

 368:             CollectionChangeEventHandler objectStateManagerObjectStateManagerChanged = (sender, e) => BulkDeletedEntities.Add(e.Element);

 369:             ObjectStateManager.ObjectStateManagerChanged += objectStateManagerObjectStateManagerChanged;

 370:             DeleteObject(entity);

 371:             ObjectStateManager.ObjectStateManagerChanged -= objectStateManagerObjectStateManagerChanged;

 372:             BulkDeletedEntities.Add(entity);

 373:         }

 374:         #endregion

 375:  

 376:     }

you can add or remove these features according your needs. Here i have tried to provide you some of written code which I think used in more or less in every application. Good luck.

My Recent published article in CodeProject is also available here in my blog post for those my friends who feels a little interest(!!) to read my blog post.

The Repository pattern is defined by P of EAA as:

Mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects.

Repository provides a in-memory like collection interface for accessing domain objects. So as far as the consuming component is concerned, it uses the repository just like a collection when working with Domain objects. The repository then neatly abstracts the internal mechanics of how the Add / Remove calls to the repository translate to the actual data access calls to the data store. Objects can be added to and removed from the Repository, as they can from a simple collection of objects, and the mapping code encapsulated by the Repository will carry out the appropriate operations behind the scenes. Conceptually, a Repository encapsulates the set of objects persisted in a data store and the operations performed over them, providing a more object-oriented view of the persistence layer. Repository also supports the objective of achieving a clean separation and one-way dependency between the domain and data mapping layers.

So with the repository we get a nice abstraction that provides us with persistence ignorance and a nice separation of concerns where the responsibility of persisting domain objects is encapsulated by the Repository that  leaving the domain objects to deal entirely with the domain model and domain logic.

Here I use the Composite Repository pattern.

/// <summary>
/// Repository Interface defines the base
/// functionality required by all Repositories.
/// </summary>
/// <typeparam name="T">
/// The entity type that requires a Repository.
/// </typeparam>
public interface IRepository<E, C>
{
    DbTransaction BeginTransaction();
    void Add(E entity);
    void AddOrAttach(E entity);
    void DeleteRelatedEntries(E entity);
    void DeleteRelatedEntries(E entity, ObservableCollection<string> keyListOfIgnoreEntites);
    void Delete(E entity);
    int Save();

    ObjectQuery<E> DoQuery(string entitySetName);
    ObjectQuery<E> DoQuery();
    ObjectQuery<E> DoQuery(string entitySetName, ISpecification<E> where);
    ObjectQuery<E> DoQuery(ISpecification<E> where);
    ObjectQuery<E> DoQuery(int maximumRows, int startRowIndex);
    ObjectQuery<E> DoQuery<T>(Expression<Func<E, T>> sortExpression);
    ObjectQuery<E> DoQuery<T>(Expression<Func<E, T>> sortExpression, int maximumRows, int startRowIndex);

    IList<E> SelectAll(string entitySetName);
    IList<E> SelectAll();
    IList<E> SelectAll(string entitySetName, ISpecification<E> where);
    IList<E> SelectAll(ISpecification<E> where);
    IList<E> SelectAll(int maximumRows, int startRowIndex);
    IList<E> SelectAll<T>(Expression<Func<E, T>> sortExpression);
    IList<E> SelectAll<T>(Expression<Func<E, T>> sortExpression, int maximumRows, int startRowIndex);

    E SelectByKey(string Key);

    bool TrySameValueExist(string fieldName, object fieldValue, string key);
    bool TryEntity(ISpecification<E> selectSpec);

    int GetCount();
    int GetCount(ISpecification<E> selectSpec);
}

You can write your own Repository for each business object like RoleReporitosy, UserReporsitory etc etc…or You can Implement this interface as a generic somthing like this -

public class Repository<E, C> : IRepository<E, C>, IDisposable
    where E : EntityObject
    where C : ObjectContext
{
    private readonly C _ctx;

    private string _KeyProperty = "ID";

    public string KeyProperty
    {
        get
        {
            return _KeyProperty;
        }
        set
        {
            _KeyProperty = value;
        }
    }

    public C Session
    {
        get { return _ctx; }
    }

    public Repository(C session)
    {
        _ctx = session;
    }

    #region IRepository<E,C> Members

    public int Save()
    {
        return _ctx.SaveChanges();
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(string entitySetName)
    {
        return _ctx.CreateQuery<E>("[" + entitySetName + "]");
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery()
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]");
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(string entitySetName, ISpecification<E> where)
    {
        return
            (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + entitySetName + "]")
            .Where(where.EvalPredicate);
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public ObjectQuery<E> DoQuery(ISpecification<E> where)
    {
        return
            (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + typeof(E).Name + "]")
            .Where(where.EvalPredicate);
    }
    /// <summary>
    /// Query Entity with Paging
    /// </summary>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> DoQuery(int maximumRows, int startRowIndex)
    {
        return (ObjectQuery<E>)_ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Skip<E>(startRowIndex).Take(maximumRows);
    }
    /// <summary>
    /// Query Entity in sorted Order
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="ErrorCode">custom Error Message</param>
    /// <returns>Collection of Entities</returns>
    public ObjectQuery<E> DoQuery<T>(Expression<Func<E, T>> sortExpression)
    {
        if (null == sortExpression)
        {
            return ((IRepository<E, C>)this).DoQuery();
        }
        return (ObjectQuery<E>)((IRepository<E, C>)this).DoQuery().OrderBy<E, T>(sortExpression);
    }
    /// <summary>
    /// Query All Entity in sorted Order with Paging support
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection Of entites</returns>
    public ObjectQuery<E> DoQuery<T>(Expression<Func<E, T>> sortExpression, int maximumRows, int startRowIndex)
    {
        if (sortExpression == null)
        {
            return ((IRepository<E, C>)this).DoQuery(maximumRows, startRowIndex);
        }
        return (ObjectQuery<E>)((IRepository<E, C>)this).DoQuery(sortExpression).Skip<E>(startRowIndex).Take(maximumRows);
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. In Version
    /// 2.0 this pluralizing behaviour will change and this
    /// method overload should be used only if Developers
    /// change EntitySet names from the default name generated.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public IList<E> SelectAll(string entitySetName)
    {
        return DoQuery(entitySetName).ToList();
    }
    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public IList<E> SelectAll()
    {
        try
        {
            return DoQuery().ToList(); //_ctx.CreateQuery<E>("[" + typeof(E).Name + "]");
        }
        catch (Exception)
        {
            throw;
        }
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// the parameter entitySetName in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <param name=”entitySetName”>
    /// The EntitySet name of the entity in the model.
    /// </param>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public IList<E> SelectAll(string entitySetName, ISpecification<E> where)
    {
        return DoQuery(entitySetName, where).ToList();
    }

    /// <summary>
    /// A generic method to return ALL the entities
    /// of type TEntity. This overload will use the
    /// typeof(TEntity).Name in the resolution of mapping
    /// between the CSDL and SSDL. This method is useful
    /// for Models that DO NOT have their pluralized names
    /// changed by the developer.
    /// </summary>
    /// <typeparam name=”TEntity”>
    /// The Entity to load from the database.
    /// </typeparam>
    /// <returns>Returns a set of TEntity.</returns>
    public IList<E> SelectAll(ISpecification<E> where)
    {
        return DoQuery(where).ToList();
    }
    /// <summary>
    /// Select All Entity with Paging
    /// </summary>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection of Entities</returns>
    public IList<E> SelectAll(int maximumRows, int startRowIndex)
    {
        return DoQuery(maximumRows, startRowIndex).ToList();
    }
    /// <summary>
    /// Select All Entity in sorted Order
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="ErrorCode">custom Error Message</param>
    /// <returns>Collection of Entities</returns>
    public IList<E> SelectAll<T>(Expression<Func<E, T>> sortExpression)
    {
        if (null == sortExpression)
        {
            return DoQuery(sortExpression).ToList();
        }
        return DoQuery(sortExpression).ToList();
    }
    /// <summary>
    /// Select All Entity in sorted Order with Paging support
    /// </summary>
    /// <param name="sortExpression">Sort Expression/condition</param>
    /// <param name="maximumRows">Max no of row to Fetch</param>
    /// <param name="startRowIndex">Start Index</param>
    /// <returns>Collection Of entites</returns>
    public IList<E> SelectAll<T>(Expression<Func<E, T>> sortExpression, int maximumRows, int startRowIndex)
    {
        if (sortExpression == null)
        {
            return DoQuery(maximumRows, startRowIndex).ToList();
        }
        return DoQuery(sortExpression, maximumRows, startRowIndex).ToList();
    }
    /// <summary>
    /// Get Entity By Primary Key
    /// </summary>
    /// <typeparam name="E">Entity Type</typeparam>
    /// <param name="Key">Primary Key Value</param>
    /// <returns>return entity</returns>
    public E SelectByKey(string Key)
    {
        // First we define the parameter that we are going to use the clause.
        var xParam = Expression.Parameter(typeof(E), typeof(E).Name);
        MemberExpression leftExpr = MemberExpression.Property(xParam, this._KeyProperty);
        Expression rightExpr = Expression.Constant(Key);
        BinaryExpression binaryExpr = MemberExpression.Equal(leftExpr, rightExpr);
        //Create Lambda Expression for the selection
        Expression<Func<E, bool>> lambdaExpr = Expression.Lambda<Func<E, bool>>(binaryExpr, new ParameterExpression[] { xParam });
        //Searching ....
        IList<E> resultCollection = ((IRepository<E, C>)this).SelectAll(new Specification<E>(lambdaExpr));
        if (null != resultCollection && resultCollection.Count() > 0)
        {
            //return valid single result
            return resultCollection.First<E>();
        }//end if
        return null;
    }
    /// <summary>
    /// Check if value of specific field is already exist
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="fieldName">name of the Field</param>
    /// <param name="fieldValue">Field value</param>
    /// <param name="key">Primary key value</param>
    /// <returns>True or False</returns>
    public bool TrySameValueExist(string fieldName, object fieldValue, string key)
    {
        // First we define the parameter that we are going to use the clause.
        var xParam = Expression.Parameter(typeof(E), typeof(E).Name);
        MemberExpression leftExprFieldCheck = MemberExpression.Property(xParam, fieldName);
        Expression rightExprFieldCheck = Expression.Constant(fieldValue);
        BinaryExpression binaryExprFieldCheck = MemberExpression.Equal(leftExprFieldCheck, rightExprFieldCheck);

        MemberExpression leftExprKeyCheck = MemberExpression.Property(xParam, this._KeyProperty);
        Expression rightExprKeyCheck = Expression.Constant(key);
        BinaryExpression binaryExprKeyCheck = MemberExpression.NotEqual(leftExprKeyCheck, rightExprKeyCheck);
        BinaryExpression finalBinaryExpr = Expression.And(binaryExprFieldCheck, binaryExprKeyCheck);

        //Create Lambda Expression for the selection
        Expression<Func<E, bool>> lambdaExpr = Expression.Lambda<Func<E, bool>>(finalBinaryExpr, new ParameterExpression[] { xParam });
        //Searching ....
        return ((IRepository<E, C>)this).TryEntity(new Specification<E>(lambdaExpr));
    }
    /// <summary>
    /// Check if Entities exist with Condition
    /// </summary>
    /// <param name="selectExpression">Selection Condition</param>
    /// <returns>True or False</returns>
    public bool TryEntity(ISpecification<E> selectSpec)
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Any<E>(selectSpec.EvalPredicate);
    }
    /// <summary>
    /// Get Count of all records
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <returns>count of all records</returns>
    public int GetCount()
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]").Count();
    }
    /// <summary>
    /// Get count of selection
    /// </summary>
    /// <typeparam name="E">Selection Condition</typeparam>
    /// <returns>count of selection</returns>
    public int GetCount(ISpecification<E> selectSpec)
    {
        return _ctx.CreateQuery<E>("[" + typeof(E).Name + "]")
            .Where(selectSpec.EvalPredicate).Count();
    }
    /// <summary>
    /// Delete data from context
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="entity"></param>
    public void Delete(E entity)
    {
        _ctx.DeleteObject(entity);
    }
    /// <summary>
    /// Insert new data into context
    /// </summary>
    /// <typeparam name="E"></typeparam>
    /// <param name="entity"></param>
    public void Add(E entity)
    {
        _ctx.AddObject(entity.GetType().Name, entity);
    }
    /// <summary>
    /// Insert if new otherwise attach data into context
    /// </summary>
    /// <param name="entity"></param>
    public void AddOrAttach(E entity)
    {
        // Define an ObjectStateEntry and EntityKey for the current object.
        EntityKey key;
        object originalItem;
        // Get the detached object's entity key.
        if (entity.EntityKey == null)
        {
            // Get the entity key of the updated object.
            key = _ctx.CreateEntityKey(entity.GetType().Name, entity);
        }
        else
        {
            key = entity.EntityKey;
        }
        try
        {
            // Get the original item based on the entity key from the context
            // or from the database.
            if (_ctx.TryGetObjectByKey(key, out originalItem))
            {//accept the changed property
                if (originalItem is EntityObject &&
                    ((EntityObject)originalItem).EntityState != EntityState.Added)
                {
                    // Call the ApplyPropertyChanges method to apply changes
                    // from the updated item to the original version.
                    _ctx.ApplyPropertyChanges(
                        key.EntitySetName, entity);
                }
            }
            else
            {//add the new entity
                Add(entity);
            }//end else
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    /// <summary>
    /// Start Transaction
    /// </summary>
    /// <returns></returns>
    public DbTransaction BeginTransaction()
    {
        if (_ctx.Connection.State != ConnectionState.Open)
        {
            _ctx.Connection.Open();
        }
        return _ctx.Connection.BeginTransaction();
    }
    /// <summary>
    /// Delete all realted entries
    /// </summary>
    /// <param name="entity"></param>
    public void DeleteRelatedEntries(E entity)
    {
        foreach (var relatedEntity in (((IEntityWithRelationships)entity).RelationshipManager.GetAllRelatedEnds().SelectMany(re => re.CreateSourceQuery().OfType<EntityObject>()).Distinct()).ToArray())
        {
            _ctx.DeleteObject(relatedEntity);
        }//end foreach
    }
    /// <summary>
    /// Delete all realted entries
    /// </summary>
    /// <param name="entity"></param>
    public void DeleteRelatedEntries(E entity, ObservableCollection<string> keyListOfIgnoreEntites)
    {
        foreach (var relatedEntity in (((IEntityWithRelationships)entity).RelationshipManager.GetAllRelatedEnds().SelectMany(re => re.CreateSourceQuery().OfType<EntityObject>()).Distinct()).ToArray())
        {
            PropertyInfo propInfo = relatedEntity.GetType().GetProperty(this._KeyProperty);
            if (null != propInfo)
            {
                string value = (string)propInfo.GetValue(relatedEntity, null);
                if (!string.IsNullOrEmpty(value) &&
                    keyListOfIgnoreEntites.Contains(value))
                {
                    continue;
                }//end if
            }//end if
            _ctx.DeleteObject(relatedEntity);
        }//end foreach
    }

    #endregion

    #region IDisposable Members

    public void Dispose()
    {
        if (null != _ctx)
        {
            _ctx.Dispose();
        }
    }

    #endregion

}

Notice that , Here I also implement IDicpose interface to dispose the context manually.To get the name of Entityset, Here I have used typeof  ,but you can you metadata query to retrieve the entityset name.

var container = context.MetadataWorkspace.GetEntityContainer(context.DefaultContainerName, DataSpace.CSpace);
string entitySetName = (from meta in container.BaseEntitySets
                        where meta.ElementType.Name == entityTypeName
                        select meta.Name).FirstOrDefault();

Here I am not gointo the code. 

The specification pattern we can implement a re-usable business logic component that can be passed around to satisfy certain business criteria . The specification object has a clear and limited responsibility, which can be separated and decoupled from the domain object that uses it. I would highly recommend reading the white paper by Martin Fowler and Eric Evans on the Specification pattern. 

public interface ISpecification<E>
{
    /// <summary>
    /// Select/Where Expression
    /// </summary>
    Expression<Func<E, bool>> EvalPredicate { get; }
    /// <summary>
    /// Function to evaluate where Expresiion
    /// </summary>
    Func<E, bool> EvalFunc { get; }
}

You can write your own specification by implementing your interface like RoleSpecification and put down your business logic there.For general use you can also Implement this composite specification interface like this-

public class Specification<E> : ISpecification<E>
{
    #region Private Members

    private Func<E, bool> _evalFunc = null;
    private Expression<Func<E, bool>> _evalPredicate;

    #endregion

    #region Virtual Accessors

    public virtual Expression<Func<E, bool>> EvalPredicate
    {
        get { return _evalPredicate; }
    }

    public virtual Func<E, bool> EvalFunc
    {
        get { return _evalFunc; }
    }

    #endregion

    #region Constructors

    public Specification(Expression<Func<E, bool>> predicate)
    {
        _evalPredicate = predicate;
    }

    private Specification() { }

    #endregion
}

To use this Repository and Specification class from your business layer, one thing I must have to say that I am sharing a single context in the CRUD process/operation. You must keep alive the context in your entire process of a crud operation. For this I make a Global variable of my EF ObjectContext and   all using repository and in the constructor I initialize all this variables like this-

#region Global members

Repository< User, SecurityEntities> _userRepository = null;
Repository< Role, SecurityEntities> _roleRepository = null;
Repository< Task, JerichoSecurityEntities> _taskRepository = null;
Repository< RoleInUser,SecurityEntities> _roleInUserRepository
         = null;
Repository< RoleTask,SecurityEntities> _roleTaskRepository
         = null;
Repository< DBAuditForSecurity, SecurityEntities> _securityAuditRepository

SecurityEntities _ctx = null;
#endregion

public BLLRoleManagement()
{
    _ctx = Helper.SecurityContextInstance;
    _userRepository = new Repository< User,SecurityEntities>(_ctx);
    _roleRepository = new Repository< Role, SecurityEntities>(_ctx);
    _taskRepository = new Repository< Task, SecurityEntities>(_ctx);
    _roleInUserRepository = new Repository< RoleInUser, SecurityEntities>(_ctx);
    _roleTaskRepository = new Repository< RoleTask, SecurityEntities>(_ctx);
    _securityAuditRepository = new Repository< DBAuditForSecurity, SecurityEntities>(_ctx);
}

………………………….

……………………………………………

Now In my BLLRoleManagement, say I have method to delete User. That will be something like this –

/// <summary>
/// Delete User
/// </summary>
/// <param name="userID">User ID</param>
/// <returns>True Or False</returns>
public static bool DeleteUser(
    string UserID)
{
    try
    {
        using (DbTransaction transaction = userRepository.BeginTransaction())
        {
            User UserTobeRemoved = userRepository.SelectByKey(UserID);
            if (UserTobeRemoved == null)
                return false;

            userRepository.DeleteRelatedEntries(UserTobeRemoved);
            userRepository.Delete(UserTobeRemoved);
            if (userRepository.Save() >= 0)
            {
                transaction.Commit();
                return true;
            }
        }
    }
    catch (Exception ex)
    {
        throw ErrorHandler.WrapException(ex, ErrorCodes.DB_DeleteUser_Error_Code);
    }
    return false;
}

So You can call this method like –

new BLLRoleManagement().DeleteUser(userID);

/// <summary>
/// Get Current Relationship Dictionary of Entites
/// </summary>
/// <returns>Dictionary of Current Entites</returns>
public static Dictionary<Type, List<Type>> GetCurrentDBEntityRelationshipChildren<T>() where T : ObjectContex
{
    try
    {
        //Take a dictionary
        Dictionary<Type, List<Type>> objectCollection = new Dictionary<Type, List<Type>>();
        //Get al properties contex
        PropertyInfo[] properties = typeof(T).GetProperties();

        foreach (var item in properties)
        {//check
            //Pickup the properties only those represent entitys of database
            if (item.PropertyType.BaseType.Equals(typeof(ObjectQuery)))
            {
                //Get Propety value
                Type entityType = item.PropertyType.GetGenericArguments().First(); ;
                if (null != entityType)
                {
                    try
                    {
                        AddToDictionary(objectCollection, entityType, null);
                        PropertyInfo[] entityProperties = entityType.GetProperties();

                        foreach (var entityProp in entityProperties)
                        {
                            if (entityProp.PropertyType.BaseType.Equals(typeof(RelatedEnd))) //Collection Property
                            {
                                #region Detail Reference - Add on "* to 1" relationship
                                Type detail = entityProp.PropertyType.GetGenericArguments().First();
                                if (null != detail)
                                {
                                    AddToDictionary(objectCollection, entityType, detail);
                                }//end if
                                #endregion
                            }
                            else if (entityProp.PropertyType.BaseType.Equals(typeof(EntityReference)))
                            {
                                #region Master referance - Add on "1 to 1" relationship
                                bool addInDictionary = false;
                                Type master = entityProp.PropertyType.GetGenericArguments().First();
                                if (null != master)
                                {
                                    try
                                    {
                                        IEnumerable<PropertyInfo> props = master.GetProperties().Where(p => p.PropertyType.BaseType.Equals(typeof(EntityReference)));
                                        if (null != props && props.Count() > 0)
                                        {
                                            foreach (var p in props)
                                            {
                                                if (p.PropertyType.GetGenericArguments().FirstOrDefault().Equals(entityType)
                                                     && p.PropertyType.BaseType.Equals(typeof(EntityReference))
                                                     && !IsInDictionary(objectCollection, master, entityType))
                                                {
                                                    addInDictionary = true;
                                                }
                                            }
                                        }
                                    }
                                    catch (System.Reflection.TargetException ex)
                                    {
                                        throw ErrorHandling.ErrorHandler.WrapException(ex, ErrorCodes.DB_EntityRelationship_Error_Code);
                                    }
                                    catch (TargetInvocationException ex)
                                    {
                                        throw ErrorHandling.ErrorHandler.WrapException(ex, ErrorCodes.DB_EntityRelationship_Error_Code);
                                    }
                                    if (addInDictionary)
                                    {
                                        AddToDictionary(objectCollection, entityType, master);
                                    }
                                }//end if
                                #endregion
                            }
                        }
                    }//end try
                    catch (ReflectionTypeLoadException ex)
                    {
                        throw ErrorHandling.ErrorHandler.WrapException(ex, ErrorCodes.DB_EntityRelationship_Error_Code);
                    }
                    catch (EntityException ex)
                    {
                        throw ErrorHandling.ErrorHandler.WrapException(ex, ErrorCodes.DB_EntityRelationship_Error_Code);
                    }
                }//end if 

            }//end if
        }//end foreach
        //return the dictionary od priority list
        return objectCollection;
    }
    catch (Exception ex)
    {
        throw ErrorHandling.ErrorHandler.WrapException(ex, ErrorCodes.DB_EntityRelationship_Error_Code);
    }
}

#region Private Methods
/// <summary>
/// Add Value into into Dictionary on checking old data
/// </summary>
/// <param name="Dictionary">Dictionary</param>
/// <param name="Key">Key</param>
/// <param name="Value">Value</param>
private static void AddToDictionary(Dictionary<Type, List<Type>> Dictionary, Type Key, Type Value)
{
    if (Dictionary.ContainsKey(Key))
    {
        List<Type> prevValue = Dictionary[Key] as List<Type>;
        if (prevValue != null && null != Value)
        {
            prevValue.Add(Value);
            Dictionary[Key] = prevValue;
        }//end if
    }
    else
    {//add new entry with default priority
        if (null != Value)
        {
            Dictionary.Add(Key, new List<Type>() { Value });
        }
        else
        {
            Dictionary.Add(Key, new List<Type>());
        }
    }//end else
}
/// <summary>
/// Is in dictionary ?
/// </summary>
/// <param name="Dictionary"></param>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
private static bool IsInDictionary(Dictionary<Type, List<Type>> Dictionary, Type key, Type value)
{
    if (Dictionary.ContainsKey(key))
    {
        foreach (var item in (Dictionary[key] as List<Type>))
        {
            if (item.Equals(value))
            {
                return true;
            }
        }
    }
    return false;
}

Now I  was going to  Sort this Using an Sorting algorithm , To make that First I  declared a enum –

[Flags]
public enum EnitySetRefType
{
    None = 0x00,
    ReferencedBy = 0x01,
    RefAndRefBy = 0x02,
    References = 0x04
}

And make a Wrapper class  Of EntitySet Like this -

/// <summary>
/// Wrapper class of EntitySet
/// </summary>
public class EntitySetTypeWrapper
{
    #region Data Members

    // member variables
    public static int MaxLen;
    public static readonly SortedList<string, EntitySetTypeWrapper> sortedList = new SortedList<string, EntitySetTypeWrapper>();

    // Instance variables
    private List<string> _referencedBy = new List<string>();
    private EnitySetRefType _refType;
    private string _name;

    #endregion

    #region Properites

    /// <summary>
    /// Get/Set for ReferencedBy
    /// </summary>
    public List<string> ReferencedBy
    {
        get { return (_referencedBy); }
        set { _referencedBy = value; }
    }

    /// <summary>
    /// Get/Set for RefType
    /// </summary>
    public EnitySetRefType RefType
    {
        get { return (_refType); }
        set { _refType = value; }
    }

    /// <summary>
    /// Get/Set for Name
    /// </summary>
    public string Name
    {
        get { return (_name); }
        set { _name = value; }
    }

    #endregion

    #region Constructor

    /// <summary>
    ///
    /// </summary>
    /// <param name="row"></param>
    private EntitySetTypeWrapper(string _name)
    {
        Name = _name;
        if (Name.Length > MaxLen)
            MaxLen = Name.Length;

        AddRefType(EnitySetRefType.None);
    }

    #endregion

    #region Methods - Private
    /// <summary>
    /// Private Method
    /// </summary>
    /// <param name="referenceType"></param>
    private void AddRefType(EnitySetRefType referenceType)
    {
        if (_refType == EnitySetRefType.RefAndRefBy)
            return;

        _refType |= referenceType;

        if (_refType == (EnitySetRefType.ReferencedBy | EnitySetRefType.References))
            _refType = EnitySetRefType.RefAndRefBy;
    }
    #endregion
}

Now What I have to do , I should make a Comparer class to sort the entity set Using this wrapper class . So I make a class named EntityInfoComparer  which is inherited from IComparer<EntitySetTypeWrapper>

public class EntityInfoComparer : IComparer<EntitySetTypeWrapper>
{
    /// <summary>
    /// Compare Two Entity
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    public int Compare(EntitySetTypeWrapper x, EntitySetTypeWrapper y)
    {
        // Invalid Data
        if ((x == null) || (y == null))
            throw new ArgumentException("Invalid data type");

        // Objects are the Same
        if (x == y)
        {
            return (0);
        }

        // Sort by Category Number - Object X is in a LOWER Categroy than Object Y
        if (x.RefType < y.RefType)
            return (-1);

        // Sort by Category Number - Object X is in a HIGHER Categroy than Object Y
        if (x.RefType > y.RefType)
            return (1);

        // Sort by Category Number - Object X and Object Y are in the SAME Category
        // Is this a Category 3
        if (x.RefType == EnitySetRefType.RefAndRefBy)
        {
            if (IsInReferenceList(y.Name, x))
            {
                return (-1);
            }

            if (IsInReferenceList(x.Name, y))
            {
                return (1);
            }
        }

        // As a last resort sort by name
        return CompareName(x, y);
    }

    /// <summary>
    /// Compare Two Entity
    /// </summary>
    /// <param name="x">First Entity Defination</param>
    /// <param name="y">Second Entity Defination</param>
    /// <returns></returns>
    private static int CompareName(EntitySetTypeWrapper x, EntitySetTypeWrapper y)
    {
        return (x.Name.CompareTo(y.Name));
    }

    /// <summary>
    /// Is in Reference List?
    /// </summary>
    /// <param name="entityName">Name of Entity</param>
    /// <param name="entityInfo">Entity Defination</param>
    /// <returns></returns>
    private static bool IsInReferenceList(string entityName, EntitySetTypeWrapper entityInfo)
    {
        // Nothing to compare
        if (entityInfo.ReferencedBy.Count == 0)
            return (false);

        // This Entity is Referenced By Entity
        if (entityInfo.ReferencedBy.Contains(entityName))
            return (true);

        // Recursive call
        foreach (string childEntityName in entityInfo.ReferencedBy)
        {
            // Looking for a child of this entity
            if (IsInReferenceList(entityName, EntitySetTypeWrapper.sortedList[childEntityName]))
                return (true);
        }

        return (false);
    }
}

So , Going to sort using the above dictionary and wrapper class of entity set.So I am going to write an static mathod who First make a dictionary using the method GetCurrentDBEntityRelationshipChildren and then make a SortedList<string, EntitySetTypeWrapper> using the dictionary contents and at the end I sort the SortedList using EntityInfoComparer.

/// <summary>
/// Create a sorted EntitySet list
/// </summary>
/// <returns></returns>
public static List<EntitySetTypeWrapper> CreateSortedEntityListOnChildFirst<T>() where T : ObjectContext
{
    // Retrieve Tables and Foreign Key Relationships
    //DataSet dataSet = GetDatabaseTableInformation();
    Dictionary<Type, List<Type>> entries = GenericDataAccessHelper.GetCurrentDBEntityRelationshipChildren<T>();

    sortedList.Clear();
    // Add All Tables to a List
    foreach (Type key in entries.Keys)
    {
        EntitySetTypeWrapper tableInfo = new EntitySetTypeWrapper(key.Name);
        sortedList.Add(tableInfo.Name, tableInfo);
    }

    // Find Reference Table Information For Each Table
    foreach (var item in entries)
    {
        EntitySetTypeWrapper entityInfo = sortedList[(item.Key as Type).Name];

        List<Type> valueRange = item.Value as List<Type>;
        if (null != valueRange && valueRange.Count > 0 && entityInfo != null)
        {
            foreach (var value in valueRange)
            {
                string childTable = value.Name;

                if (childTable.Equals(entityInfo.Name))
                    continue;

                // Add Child Table to Current Table
                if (!entityInfo.ReferencedBy.Contains(childTable))
                {
                    entityInfo.ReferencedBy.Add(childTable);

                    // Add Reference Type Enumeration For Both Referenced and Referenced By Tables
                    entityInfo.AddRefType(EnitySetRefType.ReferencedBy);
                    sortedList[childTable].AddRefType(EnitySetRefType.References);
                }
            }//end foreach
        }
        // Sort Referenced By Tables By Name
        entityInfo.ReferencedBy.Sort();
    }
    // Perform the Sort with the Custom Sorter
    List<EntitySetTypeWrapper> list = new List<EntitySetTypeWrapper>(sortedList.Values);
    list.Sort(new EntityInfoComparer());

    return (list);
}

That’s the end of  story here…Still its working good with the Domain models of Entity set .  Hope it will help you also. Feel free if you wanna comment on this.

In its part 1, I have talked about creating audit trail objects using the object state entries. As I said before In Second Part I will talk about roll back feature of this audit trail. In first part, I have said that, to get the Rollback feature from that audit trail we have to consider some issues.  We have to maintain the order of entity graph while insertion and deletion. That means root entity has been inserted before the children and during deletion we have to make it reverse. The most important issue is that we have to make sure that each audit trail entry has been inserted according this order. Other issues

1.  We have to maintain insertion date-time to sort the audit trial.

2.  Store the old data and new data.

3.  Store the state the data as audit action.

If user chooses a certain time to roll back, we have to start with last audits and do the roll back action for each audit till the certain time. So now the question is arises that what will be roll back action. You can guess that it’s depending on the Audit action of each entity. During rollback –

1.  Inserted data will be deleted.

2.  Deleted data will be inserted.

3.  Modified data will replaced by the old one.

If we see to conceptual model, our Entity set for Audit was-

Here “RevisionStamp” holds the audit insertion date-time, Actions holds the audit action of the entity object (Insert/deleted/modified).Other properties describe themselves with their names.

So here “Deleted” and “Modified” object will be roll backed with “Old data” property. And Inserted data will be roll backed with “New data” property.

   So First I am going to retrieve all the audits those happen after a specific date-time. This specific date-time is taken from the user. What we have to do, do rollback action for each audit till to specific date and we have to start with last one(bottom  to Top).That is why we are going to sort the audit with “RevisionStamp” in a descending order and start doing rollback-

public static bool RollBack(DateTime rollBackDate, string userName)
{
    using (TransactionScope transactionScope = new TransactionScope(System.Transactions.TransactionScopeOption.Required, TimeSpan.FromMinutes(30)))
    {
        AdventureWorksEntities context = new AdventureWorksEntities();
        try
        {
            if (context.Connection.State != ConnectionState.Open)
            {//Open the connection
                context.Connection.Open();
            }//end if
            //find all audits to roll back
            IEnumerable<DBAudit> auditsToRollBack = DataAdapter.GetEntity<DBAudit>(context, a => a.RevisionStamp >= rollBackDate);

            if (null != auditsToRollBack && auditsToRollBack.Count() > 0)
            {//if any data found to roll back
                //Order by the audits by creational datetime
                IEnumerable<DBAudit> orderedAudits = auditsToRollBack.OrderByDescending(a => a.RevisionStamp);

                foreach (var audit in orderedAudits)
                {//iterate each audit
                    AuditTrailHelper.DoRollBackAction(ref context, audit, userName);
                }//end foreach
                int i = context.SaveChanges();
                if (i > 0)
                {
                    transactionScope.Complete();
                    return true;
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            // Explicitly dispose of the context,
            // which closes the connection.
            context.Dispose();
        }
    }
    return false;
}

In DoRollBackAction as I said before, “Deleted” and “Modified” object will be roll backed with “Old data” property. And Inserted data will be roll backed with “New data” property.

As I stored old data and new data with XML Serialization while creating Audit object, I have to desterilize those data into “EntityObject” and do the reverse action according to the audit action.

private static void DoRollBackAction(ref AdventureWorksEntities context,  DBAudit auditInfo, string userName)
        {
            if (auditInfo.Actions == AuditTrailHelper.AuditActions.U.ToString() || auditInfo.Actions ==AuditTrailHelper.AuditActions.D.ToString())
            {//For action of Update and Delete
                //Deserialized old data from the XML
                object oldData = AuditTrailHelper.GetAuditObjectFromXML(auditInfo.OldData, auditInfo.TableName);

                if (oldData is EntityObject)
                {
                    EntityObject oldEntity = (EntityObject)oldData;
                    oldEntity.EntityKey = null;
                    //add in case of delete or edit the current one with old data
                    DataAdapter.EditEntity(ref context, oldEntity);
                }
            }
            else if (auditInfo.Actions == AuditTrailHelper.AuditActions.I.ToString())
            {//For Insert Action
                object newData = AuditTrailHelper.GetAuditObjectFromXML(auditInfo.NewData, auditInfo.TableName);

                if (newData is EntityObject)
                {
                    //Otherwise, delete the entity that has been inserted before
                    EntityObject newEntity = (EntityObject)newData;
                    newEntity.EntityKey = null;
                    EntityKey key = context.CreateEntityKey(newEntity.GetType().Name, newEntity);

                    object objToRemoved = null;
                    if (context.TryGetObjectByKey(key, out objToRemoved))
                    {//delete the entity
                        context.DeleteObject(objToRemoved);
                    }//end if
                }
            }
            //delete the audit
            context.DeleteObject(auditInfo);
        }
    }

      

After serializing the entity Object we get the XML string like this –

<SalesOrderDetail xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <EntityKey>
    <EntitySetName>SalesOrderDetail</EntitySetName>
    <EntityContainerName>AdventureWorksEntities</EntityContainerName>
  </EntityKey>
  <SalesOrderID>1</SalesOrderID>
  <SalesOrderDetailID>0</SalesOrderDetailID>
  <OrderQty>1</OrderQty>
  <UnitPrice>1898.0944</UnitPrice>
  <UnitPriceDiscount>0</UnitPriceDiscount>
  <LineTotal>0</LineTotal>
  <rowguid>6bfaa372-292a-4fd6-84d3-c4e900f09589</rowguid>
  <ModifiedDate>2009-03-26T16:16:41.9691358+06:00</ModifiedDate>
  <SalesOrderHeaderReference />
  <SpecialOfferProductReference>
    <EntityKey>
      <EntitySetName>SpecialOfferProduct</EntitySetName>
      <EntityContainerName>AdventureWorksEntities</EntityContainerName>
      <EntityKeyValues>
        <EntityKeyMember>
          <Key>SpecialOfferID</Key>
          <Value xsi:type="xsd:int">1</Value>
        </EntityKeyMember>
        <EntityKeyMember>
          <Key>ProductID</Key>
          <Value xsi:type="xsd:int">777</Value>
        </EntityKeyMember>
      </EntityKeyValues>
    </EntityKey>
  </SpecialOfferProductReference>
</SalesOrderDetail>

I have to deserialized this xml string.During deserializing, I have created a XML document and create an XML reader using that document.Using that reader I deserialized the entity object. The method to deserialize the entityobject is –      

public static object GetAuditObjectFromXML(string ObjectInXML, string typeName)
{
    XDocument doc = XDocument.Parse(ObjectInXML);
    //Assuming doc is an XML document containing a serialized object and objType is a System.Type set to the type of the object.
    XmlReader reader = doc.CreateReader();

    Type entityType = Assembly.GetExecutingAssembly().GetType("ImplAuditTrailUsingEF." + typeName);

    XmlSerializer ser = new XmlSerializer(entityType);
    return ser.Deserialize(reader);
}

For inserting deleted object or change back modifed object I wrote a single method to edit the object – “EditEntity(ref AdventureWorksEntities context, EntityObject entity)”.Is this method I change the existance object and attch to the container otherwise I have inserted the entityObject into the context.To save all of this change we must need a entry in Object state cache.

public static void EditEntity(ref AdventureWorksEntities context, EntityObject entity)
{
    // Define an ObjectStateEntry and EntityKey for the current object.
    EntityKey key;
    object originalItem;
    // Get the detached object’s entity key.
    if (entity.EntityKey == null)
    {
        // Get the entity key of the updated object.
        key = context.CreateEntityKey(entity.GetType().Name, entity);
    }
    else
    {
        key = entity.EntityKey;
    }
    try
    {
        // Get the original item based on the entity key from the context
        // or from the database.
        if (context.TryGetObjectByKey(key, out originalItem))
        {//accept the changed property
            // Call the ApplyPropertyChanges method to apply changes
            // from the updated item to the original version.
            context.ApplyPropertyChanges(
                key.EntitySetName, entity);
        }
        else
        {//add the new entity
            context.AddObject(entity.GetType().Name, entity);
        }//end else
    }
    catch (System.Data.MissingPrimaryKeyException ex)
    {
        throw ex;
    }
    catch (System.Data.MappingException ex)
    {
        throw ex;
    }
    catch (System.Data.DataException ex)
    {
        throw ex;
    }
}

Now all we have to do is just call the “RollBack” method and give it a specific date to roll back.

private void btnRollBack_Click(object sender, RoutedEventArgs e)
{
    AuditTrailHelper.RollBack(dtpRollBackDate.SelectedDate.Value, "Admin");
}

That’s all for implementation of Audit trial with entity framework. Here I deleted the audits which has been rolling backed. Definitely each Roll Back operation is also a db operation and I do audit for each roll back operation.

You can get the SourceCode and the article also in codeproject site  -   http://www.codeproject.com/KB/database/ImplAudingTrailUsingEFP-2.aspx

 Here I am going to talk about audit trail implementation that’s capable to rollback to a certain period. To make such implementation I am going to use the Entity framework’s caching Management that is called as “ObjectStateManager”.Using this Manager I will be capable to find out the object that is currently changed or added or deleted and resides in EF cache as Object state entry. In part 1, I just going to talk about creating audit trail objects using the object state entry. In Second Part I will talk about roll back feature of this audit trial.

 First I make table audit trail in database

For this table, I am going to make an Entity set in my conceptual level as

In Entity Framework, to save my all changes into Db we have call “Context.SaveChanges()” and This Context is a container that has been inherited  from “ObjectContext” Class.To create the Audit trail  Objects for each “Modified/Added/Deleted”I am going to catch the event

Context.SavingChanges +=new EventHandler(Context_SavingChanges);

In sample program I have done it with writing partial class of

public partial class AdventureWorksEntities

    {

partial void OnContextCreated()

        {

            this.SavingChanges += new EventHandler(AdventureWorksEntities_SavingChanges);

        }

        void AdventureWorksEntities_SavingChanges(object sender, EventArgs e)

        {

        }

So in my “AdventureWorksEntities_SavingChanges” method I am going to create all “dbaudit” objects those are going to save in DB.Here its takes each entry from EF cache of state- Added or Deleted or Modified and call a factory method to produce audit trail object.

    public partial class AdventureWorksEntities

    {

        public string UserName { get; set; }

        List<DBAudit> auditTrailList = new List<DBAudit>();

        public enum AuditActions

        {

            I,

            U,

            D

        }

        partial void OnContextCreated()

        {

            this.SavingChanges += new EventHandler(AdventureWorksEntities_SavingChanges);

        }

        void AdventureWorksEntities_SavingChanges(object sender, EventArgs e)

        {

            IEnumerable<ObjectStateEntry> changes = this.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified);

            foreach (ObjectStateEntry stateEntryEntity in changes)

            {

                if (!stateEntryEntity.IsRelationship &&

                        stateEntryEntity.Entity != null &&

                            !(stateEntryEntity.Entity is DBAudit))

                {//is a normal entry, not a relationship

                    DBAudit audit = this.AuditTrailFactory(stateEntryEntity, UserName);

                    auditTrailList.Add(audit);

                }

            }

            if (auditTrailList.Count > 0)

            {

                foreach (var audit in auditTrailList)

                {//add all audits

                    this.AddToDBAudit(audit);

                }

            }

        }

And here “AuditTrailFactory” is Factory method to create “dbaudit” object. In Entity Framework each entry holds all change definition. Especially for Modify state it keeps the modified properties. I have collected all these properties and serialized them as XML. Using this field you can easily show the changes of modified object with doing any comparison of old and new data. 

        private DBAudit AuditTrailFactory(ObjectStateEntry entry, string UserName)

        {

            DBAudit audit = new DBAudit();

            audit.AuditId = Guid.NewGuid().ToString();

            audit.RevisionStamp = DateTime.Now;

            audit.TableName = entry.EntitySet.Name;

            audit.UserName = UserName;

            if (entry.State == EntityState.Added)

            {//entry is Added

                audit.NewData = GetEntryValueInString(entry, false);

                audit.Actions = AuditActions.I.ToString();

            }

            else if (entry.State == EntityState.Deleted)

            {//entry in deleted

                audit.OldData = GetEntryValueInString(entry, true);

                audit.Actions = AuditActions.D.ToString();

            }

            else

            {//entry is modified

                audit.OldData = GetEntryValueInString(entry, true);

                audit.NewData = GetEntryValueInString(entry, false);

                audit.Actions = AuditActions.U.ToString();

                IEnumerable<string> modifiedProperties = entry.GetModifiedProperties();

                //assing collection of mismatched Columns name as serialized string

                audit.ChangedColumns = XMLSerializationHelper.XmlSerialize(modifiedProperties.ToArray());

            }

            return audit;

        }

Here “GetEntryValueInString” is for creating XML text of Previous or modified object. First I made a clone the current object. Using “entry.GetModifiedProperties()” I can get only modified properties of an object and Using “OriginalValues” and “CurrentValues” I can build myself the old data and new data. Factory has told me what that wants – old or new. At the End I have done XML serialized and return XML string. 

        private string GetEntryValueInString(ObjectStateEntry entry, bool isOrginal)

        {

            if (entry.Entity is EntityObject)

            {

                object target = CloneEntity((EntityObject)entry.Entity);

                foreach (string propName in entry.GetModifiedProperties())

                {

                    object setterValue = null;

                    if (isOrginal)

                    {

                        //Get orginal value

                        setterValue = entry.OriginalValues[propName];

                    }

                    else

                    {

                        //Get orginal value

                        setterValue = entry.CurrentValues[propName];

                    }

                    //Find property to update

                    PropertyInfo propInfo = target.GetType().GetProperty(propName);

                    //update property with orgibal value

                    if (setterValue == DBNull.Value)

                    {//

                        setterValue = null;

                    }

                    propInfo.SetValue(target, setterValue, null);

                }//end foreach

                XmlSerializer formatter = new XmlSerializer(target.GetType());

                XDocument document = new XDocument();

                using (XmlWriter xmlWriter = document.CreateWriter())

                {

                    formatter.Serialize(xmlWriter, target);

                }

                return document.Root.ToString();

            }

            return null;

        }

To clone the entity I have used the method which I have found in MSDN forum Post (Thanx Patrick Magee J )-

        public EntityObject CloneEntity(EntityObject obj)

        {

            DataContractSerializer dcSer = new DataContractSerializer(obj.GetType());

            MemoryStream memoryStream = new MemoryStream();

            dcSer.WriteObject(memoryStream, obj);

            memoryStream.Position = 0;

            EntityObject newObject = (EntityObject)dcSer.ReadObject(memoryStream);

            return newObject;

        }

That is all for Part-1 where I just create the Audit trail objects for each CUD operation.

You can get the SourceCode and the article also in codeproject site  -   http://www.codeproject.com/KB/database/ImplAudingTrailUsingEFP1.aspx

private static object ConvertTo(object source, Type targetType, Dictionary propertyMapDictionary)
{
    //create a instance of target object
    object target = Activator.CreateInstance(targetType);

    if (target != null && null != propertyMapDictionary && propertyMapDictionary.Count > 0)
    {
        //determine the source type
        Type sourceType = source.GetType();
        foreach (var item in propertyMapDictionary.Keys)
        {
            if (propertyMapDictionary.ContainsKey(item)
            && propertyMapDictionary[item] != null
            && propertyMapDictionary[item] != string.Empty)
            {
                //Initialize parameter expresssions for getter method
                System.Linq.Expressions.ParameterExpression param = System.Linq.Expressions.Expression.Parameter(typeof(Object), "param");
                System.Linq.Expressions.Expression convertedParam = System.Linq.Expressions.Expression.Convert(param, sourceType);
                System.Linq.Expressions.LambdaExpression GetPropertyValueExp = System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Property(convertedParam, propertyMapDictionary[item]), param);
                //Create dynamic getter Delegate
                Delegate dynamicGetter = GetPropertyValueExp.Compile();

                //Get property info target type
                PropertyInfo ITargetPInfo = targetType.GetProperty(item, BindingFlags.Public | BindingFlags.Instance);
                //Determmine set method
                MethodInfo SetterMethodInfo = ITargetPInfo.GetSetMethod();
                //Initialize the parameter- expressions for setter method
                System.Linq.Expressions.ParameterExpression paramo = System.Linq.Expressions.Expression.Parameter(targetType, "param");
                System.Linq.Expressions.ParameterExpression parami = System.Linq.Expressions.Expression.Parameter(ITargetPInfo.PropertyType, "newvalue");
                System.Linq.Expressions.MethodCallExpression MethodCallSetterOfProperty = System.Linq.Expressions.Expression.Call(paramo, SetterMethodInfo, parami);
                System.Linq.Expressions.LambdaExpression SetPropertyValueExp = System.Linq.Expressions.Expression.Lambda(MethodCallSetterOfProperty, paramo, parami);
                //Create a dynamic setter Delegate
                Delegate dynamicSetter = SetPropertyValueExp.Compile();
                //Invoke getter method and get the source property value
                object actualValue = dynamicGetter.DynamicInvoke(source);
                //Invoke setter method and set the target property value
                dynamicSetter.DynamicInvoke(target, System.Convert.ChangeType(actualValue, ITargetPInfo.PropertyType));
            }//end if
        }//end foreach
    }
    return target;
}        

Its basically map only those properties that is found in dictionary (Mapping definition) and pick up value and set it to the target object .Here I didn’t do any datatype check for the mapped property. What I am trying to do here , I just use expression to fetch attribute value and set it to target object .