使用 Entity Framework 实现存储库模式
4.77/5 (54投票s)
在数据访问层使用 Entity Framework 4.0 及以下版本实现存储库模式（使用 ObjectContext 和 EntityObject）
引言
《企业应用架构模式》将存储库模式定义为：
介于领域和数据映射层之间，使用类似集合的接口来访问领域对象。
存储库为访问领域对象提供了一个类似内存的集合接口。因此，就消费组件而言，它在使用领域对象时就像使用一个集合一样使用存储库。存储库然后很好地抽象了将添加到存储库/从存储库中移除的调用转换为对数据存储的实际数据访问调用的内部机制。对象可以像添加到简单对象集合中一样被添加到存储库和从存储库中移除，并且由存储库封装的映射代码将在后台执行适当的操作。概念上，存储库封装了存储在数据存储中的对象集以及对其执行的操作，从而提供了持久化层更面向对象的视图。存储库还支持实现领域和数据映射层之间清晰分离和单向依赖的目标。
因此，通过存储库，我们可以获得一个很好的抽象，它为我们提供了持久化无关性以及清晰的关注点分离，其中持久化领域对象的责任由存储库封装，而领域对象则完全处理领域模型和领域逻辑。以下是使用存储库模式在数据访问层中代替直接访问数据库代码的一些原因：
- 重复代码
- 潜在的编程错误率更高
- 业务数据类型不严格
- 难以集中数据相关策略，例如缓存
- 无法轻松地独立于外部依赖项测试业务逻辑
Using the Code
在这里，我使用了复合存储库模式
/// <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>
{
string KeyProperty { get; set; }
void Add(E entity);
void AddOrAttach(E entity);
void DeleteRelatedEntries(E entity);
void DeleteRelatedEntries
(E entity, ObservableCollection<string> keyListOfIgnoreEntites);
void Delete(E entity);
ObjectQuery<E> DoQuery();
ObjectQuery<E> DoQuery(ISpecification<E> where);
ObjectQuery<E> DoQuery(int maximumRows, int startRowIndex);
ObjectQuery<E> DoQuery(Expression<Func<E, object>> sortExpression);
ObjectQuery<E> DoQuery(Expression<Func<E, object>> 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(Expression<Func<E, object>> sortExpression);
IList<E> SelectAll(Expression<Func<E, object>> 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);
}
您可以为每个业务对象编写自己的 Repository，例如 RoleRepository、UserReporsitory 等。或者，您可以将此 interface 实现为一个通用的 Repository 类，如下所示：
public class Repository<E, C> : IRepository<E>
where E : class
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
/// </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>
private ObjectQuery<E> DoQuery(string entitySetName)
{
return _ctx.CreateQuery<E>("[" + entitySetName + "]");
}
/// <summary>
/// A generic method to return ALL the entities
/// </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>("[" + this.GetEntitySetName( typeof(E).Name) + "]");
}
/// <summary>
/// </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>
private ObjectQuery<E> DoQuery(string entitySetName, ISpecification<E> where)
{
return
(ObjectQuery<E>)_ctx.CreateQuery<E>("[" + entitySetName + "]")
.Where(where.EvalPredicate);
}
/// <summary>
/// </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>
("[" + this.GetEntitySetName( 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>
("[" + this.GetEntitySetName(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 this.DoQuery();
}
return (ObjectQuery<E>)((IRepository<E>)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 entities</returns>
public ObjectQuery<E> DoQuery(Expression<Func<E, object>>
sortExpression, int maximumRows, int startRowIndex)
{
if (sortExpression == null)
{
return ((IRepository<E>)this).DoQuery(maximumRows, startRowIndex);
}
return (ObjectQuery<E>)((IRepository<E>)this).DoQuery
(sortExpression).Skip<E>(startRowIndex).Take(maximumRows);
}
/// <summary>
/// A generic method to return ALL the entities
/// </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
/// </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
/// </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
/// </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(Expression<Func<E, object>> 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 entities</returns>
public IList<E> SelectAll(Expression<Func<E, object>>
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 ....
var resultCollection = (ObjectQuery<E>)_ctx.CreateQuery<E>
("[" + this.GetEntitySetName(typeof(E).Name) + "]")
.Where(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 _ctx.CreateQuery<E>
("[" + this.GetEntitySetName(typeof(E).Name) + "]").Any<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>("[" +
this.GetEntitySetName( 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>("[" +
this.GetEntitySetName( 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>("[" + this.GetEntitySetName( 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>
/// Delete data from context
/// </summary>
/// <typeparam name="E"></typeparam>
/// <param name="entity"></param>
public void Delete(object 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( this.GetEntitySetName(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 (((IEntityWithKey)entity).EntityKey == null)
{
// Get the entity key of the updated object.
key = _ctx.CreateEntityKey
(this.GetEntitySetName(entity.GetType().Name), entity);
}
else
{
key = ((IEntityWithKey)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 ApplyCurrentValues method to apply changes
// from the updated item to the original version.
_ctx.ApplyCurrentValues(key.EntitySetName, entity);
}
}
else
{//add the new entity
Add(entity);
}//end else
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Delete all related 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 related 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
}
private string GetEntitySetName(string entityTypeName)
{
var container = this._ctx.MetadataWorkspace.GetEntityContainer
(this._ctx.DefaultContainerName, DataSpace.CSpace);
return (from meta in container.BaseEntitySets
where meta.ElementType.Name == entityTypeName
select meta.Name).FirstOrDefault();
}
#endregion
}
请注意，在这里我也实现了 IDispose interface 以手动释放 context。要获取 Entityset 的名称，我使用了 typeof，但您也可以进行 metadata query 来检索 EntitySet 名称。
container = context.MetadataWorkspace.GetEntityContainer
(context.DefaultContainerName, DataSpace.CSpace);
string entitySetName = (from meta in container.BaseEntitySets
where meta.ElementType.Name == entityTypeName
select meta.Name).FirstOrDefault();
在这里，我没有深入研究代码。我使用了 ObjectQuery 来获取 MargeOption 和 EnablePlanCaching 属性的功能。
ObjectQuery.EnablePlanCaching 属性 - 指示是否应缓存查询计划。计划缓存缓存了在组合查询本身时计算出的信息。通过缓存此信息，后续执行相同的查询（即使您更改了参数值）将比第一次执行快得多。此信息是按 app-domain 缓存的，因此您通常会在对同一 Web 应用程序等的多个客户端请求中受益于查询缓存。在这里，所有 DoQuery 方法都负责查询，而其他查询方法，如 SelectAll 或 Select 方法，内部则使用这些带有各种参数的 DoQuery 方法。
将 MergeOption 设置为 NoTracking 有助于我们利用 EF 返回不需要被上下文跟踪的数据的能力。假设我没有计划对这些数据进行更改。因此，我想避免 EF 为其跟踪的每个对象创建 ObjectStateEntry 实例时带来的性能损失，以及强制上下文了解对这些对象所做的任何更改。
SelectByKey 使用主键的 Expression 树创建 LINQ 表达式，并且在创建实体存储库时，您可以将此主键属性作为 string 提供。在使用 POCO 作为您的实体时，您可以设置属性编程来完成此类工作。
TrySameValueExist 通过允许您设置自定义字段和值进行比较来执行相同的工作。它将为您创建 Expression，并添加 PrimaryKey 比较，以排除您正在查询的对象（并且 PrimaryKey != currentObjectPrimaryKey）。
Add 和 Delete 方法分别简单地调用 ObjectContext 的 AddObject 和 DeleteObject 方法。AddOrAttach 方法用于您不确定对象是否已添加的特殊情况。它很昂贵，因为它会查询数据库来检查是否存在。
specification pattern（规范模式）可以实现一个可重用的业务逻辑组件，该组件可以传递以满足特定业务标准。specification 对象具有清晰而有限的职责，可以与使用它的领域对象分离和解耦。我强烈建议阅读 Martin Fowler 和 Eric Evans 关于规范模式的白皮书。
public interface ISpecification<E>
{
/// <summary>
/// Select/Where Expression
/// </summary>
Expression<Func<E, bool>> EvalPredicate { get; }
/// <summary>
/// Function to evaluate where Expression
/// </summary>
Func<E, bool> EvalFunc { get; }
}
您可以自己编写 specification，通过实现 RoleSpecification 这样的 interface，并将您的业务逻辑放在那里。对于一般用途，您也可以实现 Interface; 这样的复合规范：
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 bool Matches(E entity)
{
return _evalPredicate.Compile().Invoke(entity);
}
public virtual Expression<Func<E, bool>> EvalPredicate
{
get { return _evalPredicate; }
}
public virtual Func<E, bool> EvalFunc
{
get { return _evalPredicate != null ? _evalPredicate.Compile() : null; }
}
#endregion
#region Constructors
public Specification(Expression<Func<E, bool>> predicate)
{
_evalPredicate = predicate;
}
private Specification() { }
#endregion
#region Private Nested Classes
private class AndSpecification : Specification<E>
{
private readonly ISpecification<E> _left;
private readonly ISpecification<E> _right;
public AndSpecification(ISpecification<E> left, ISpecification<E> right)
{
this._left = left;
this._right = right;
this._evalFunc =
(Func<E, bool>)Delegate.Combine
(left.EvalPredicate.Compile(),
right.EvalPredicate.Compile());
_evalPredicate = left.EvalPredicate.And(right.EvalPredicate);
}
public override bool Matches(E entity)
{
return EvalPredicate.Compile().Invoke(entity);
}
}
private class OrSpecification : Specification<E>
{
private readonly ISpecification<E> _left;
private readonly ISpecification<E> _right;
public OrSpecification(ISpecification<E> left, ISpecification<E> right)
{
this._left = left;
this._right = right;
this._evalFunc =
(Func<E, bool>)Delegate.Combine
(left.EvalPredicate.Compile(),
right.EvalPredicate.Compile());
_evalPredicate = left.EvalPredicate.Or(right.EvalPredicate);
}
public override bool Matches(E entity)
{
return EvalPredicate.Compile().Invoke(entity);
}
}
#endregion
#region Operator Overloads
public static Specification<E> operator
&(Specification<E> left, ISpecification<E> right)
{
return new AndSpecification(left, right);
}
public static Specification<E> operator
|(Specification<E> left, ISpecification<E> right)
{
return new OrSpecification(left, right);
}
#endregion
}
在这里，应用了一些运算符重载，将每个 specification（复合规范的左侧和右侧）的 lambda 表达式（或谓词）组合起来，创建一个新的 lambda 表达式。这个新的 lambda 表达式将用于查询。因此，当您使用多个已定义的 specification 作为业务规则时，它将为您提供帮助。
要从您的业务层使用这个 Repository 类，我必须说的是，我在 CRUD 过程/操作中共享同一个 context。您必须在整个 CRUD 操作过程中保持 context 的活动状态。为此，我在所有操作的顶部设置了一个 UnitOfWork。
public interface IUnitOfWork : IDisposable
{
IRepository<TSet> GetRepository<TSet>() where TSet : class;
DbTransaction BeginTransaction();
int Save();
}
在这里，**工作单元 (Unit of Work)** 被引入，作为多个存储库的“保护伞”，并由所有存储库共享，而不是直接共享对象上下文。像 save、transaction 这样的方法可以切换到那里。这是实现：
public class UnitOfWork<C> : IUnitOfWork where C : ObjectContext
{
private DbTransaction _transaction;
private Dictionary<Type, object> _repositories;
private C _ctx;
public UnitOfWork()
{
_ctx = Activator.CreateInstance<C>();
_repositories = new Dictionary<Type, object>();
}
public IRepository<TSet> GetRepository<TSet>() where TSet : class
{
if (_repositories.Keys.Contains(typeof(TSet)))
return _repositories[typeof(TSet)] as IRepository<TSet>;
var repository = new Repository<TSet, C>(_ctx);
_repositories.Add(typeof(TSet), repository);
return repository;
}
/// <summary>
/// Start Transaction
/// </summary>
/// <returns></returns>
public DbTransaction BeginTransaction()
{
if (null == _transaction)
{
if (_ctx.Connection.State != ConnectionState.Open)
{
_ctx.Connection.Open();
}
this._transaction = _ctx.Connection.BeginTransaction();
}
return _transaction;
}
public int Save()
{
return _ctx.SaveChanges();
}
#region IDisposable Members
public void Dispose()
{
if (null != _transaction)
{
_transaction.Dispose();
}
if (null != _ctx)
{
_ctx.Dispose();
}
}
#endregion
}
Repository 是一种将业务层与数据访问连接起来的**中介**。因此，您的**业务层**应该了解这个存储库类。现在，在我的 BLLRoleManagement class 中，假设我有一个删除 User 的方法。它看起来会是这样的：
/// <summary>
/// Delete User
/// </summary>
/// <param name="userID">User ID</param>
/// <returns>True Or False</return>
public static bool DeleteUser(
string UserID)
{
try
{
var unitOfWork = new UnitOfWork<ProjectCodeEntities>();
var userRepository = unitOfWork.GetRepository<User>();
using (unitOfWork)
{
using (var transaction = unitOfWork.BeginTransaction())
{
User UserTobeRemoved = userRepository.SelectByKey(UserID);
if (UserTobeRemoved == null)
return false;
userRepository.DeleteRelatedEntries(UserTobeRemoved);
userRepository.Delete(UserTobeRemoved);
if (unitOfWork.Save() >= 0)
{
transaction.Commit();
return true;
}
}
}
}
catch (Exception ex)
{
throw ErrorHandler.WrapException(ex, ErrorCodes.DB_DeleteUser_Error_Code);
}
return false;
}
这里，它将初始化一个 ObjectContext 实例，该实例将在您的整个操作过程/工作流中使用。为此，我在Unit of Work 中提供了一个工厂方法，该方法将使用该 ObjectContext 为您创建一个存储库。删除与 User 相关的所有实体，然后删除 User。为了在此 delete 过程中共享相同的 context，我将这样调用此方法：
new BLLRoleManagement().DeleteUser(userID);
当然，它还有很多可以改进的地方。我在这里使用了一些接口，这些接口可以与依赖注入一起使用，以使您的代码与 EF 解耦。希望有所帮助。所以，这就是我对使用 Entity framework 实现存储库模式的讨论结束。祝您好运！
参考文献
历史
- 2009年6月10日：初始版本