blocks|key|3093103|text|我推荐1号，但有几点需要注意。第二个似乎是最常见的，但在我的经验中，存储库最终只是一个混乱的查询垃圾场。如果你使用一个通用的存储库(2)，它只是一个围绕DBContext的薄薄的包装器，真的有点无意义，除非你计划改变ORM(坏主意)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3093104|但是，当我直接访问DBContext时，我更喜欢使用管道和过滤器模式，这样您就可以重用通用逻辑，例如|3093105|items+=+DBContext.Clients
++++.ByPhoneNumber('1234%25')
++++.ByOrganisation(134);|code-block|syntax|javascript|3093106|ByPhoneNumber和By+Organisation只是扩展方法。|3093107|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would recommend number 1, with some caveats. Number 2 is what seems to be most common but in my experience the repository just ends up a messy dumping ground for queries. If you use a generic repository (2) it is just a thin wrapper around the DBContext, a bit pointless really unless you are planning on changing ORM's (bad idea). 

But when I access DBContext directly I prefer to use a Pipes and Filters pattern so you can reuse common logic, something like

<pre><code>items = DBContext.Clients
 .ByPhoneNumber('1234%')
 .ByOrganisation(134);
</code></pre>

The ByPhoneNumber and By Organisation are just extension methods.

blocks|key|3093152|text|我使用了#2和#3的混合，但如果可能的话，我更喜欢严格的通用存储库(甚至比#3的链接中建议的还要严格)。#1并不好，因为它在单元测试中表现不佳。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3093153|如果你有一个较小的域，或者需要限制你的域允许查询的实体，我认为#2或#3定义了实体特定的存储库接口，它们本身实现了通用存储库-是有意义的。然而，我发现为我想要查询的每个实体编写一个接口和一个具体的实现是很费力的，也是没有必要的。public+interface+IFooRepository+:+IRepository<Foo>有什么好处(再说一次，除非我需要限制开发人员使用一组允许的聚合根)？|offset|length|style|CODE|3093154|我只是使用Add、Remove、Get、GetDeferred、Count和Find方法来定义我的通用存储库接口(Find返回一个允许LINQ的IQueryable接口)，创建一个具体的通用实现，然后调用它。我在很大程度上依赖于Find，因此也就依赖于LINQ。如果我需要多次使用一个特定的查询，我会使用扩展方法，并使用LINQ编写查询。|3093155|这就满足了我95%25的持久化需求。如果我需要执行一些一般不能完成的持久化操作，我会使用自己开发的ICommand应用程序接口。例如，假设我正在使用NHibernate，并且我需要作为域的一部分执行一个复杂的查询，或者我可能需要执行一个批量命令。API大致如下所示：|3093156|//+marker+interface,+mainly+used+as+a+generic+constraint
public+interface+ICommand
{
}

//+commands+that+return+no+result,+or+a+non-query
public+interface+ICommandNoResult+:+ICommand
{
+++void+Execute();
}

//+commands+that+return+a+result,+either+a+scalar+value+or+record+set
public+interface+ICommandWithResult<TResult>+:+ICommand
{
+++TResult+Execute();
}

//+a+query+command+that+executes+a+record+set+and+returns+the+resulting+entities+as+an+enumeration.
public+interface+IQuery<TEntity>+:+ICommandWithResult<IEnumerable<TEntity>>
{
++++int+Count();
}

//+used+to+create+commands+at+runtime,+looking+up+registered+commands+in+an+IoC+container+or+service+locator
public+interface+ICommandFactory
{
+++TCommand+Create<TCommand>()+where+TCommand+:+ICommand;
}|code-block|syntax|javascript|3093157|现在，我可以创建一个接口来表示特定的命令。|3093158|public+interface+IAccountsWithBalanceQuery+:+IQuery<AccountWithBalance>
{
++++Decimal+MinimumBalance+{+get;+set;+}
}|3093159|我可以创建一个具体的实现，使用原始的SQL、NHibernate+HQL等等，并将其注册到我的服务定位器中。|3093160|现在，在我的业务逻辑中，我可以这样做：|3093161|var+query+=+factory.Create<IAccountsWithBalanceQuery>();
query.MinimumBalance+=+100.0;

var+overdueAccounts+=+query.Execute();|3093162|您还可以将规范模式与IQuery结合使用来构建有意义的、用户输入驱动的查询，而不是拥有一个具有大量令人困惑的属性的接口，但前提是您不会发现规范模式本身就令人困惑;)。|3093163|最后一个难题是，您的存储库何时需要执行特定的pre-和-post存储库操作。现在，您可以非常容易地为特定实体创建通用存储库的实现，然后覆盖相关方法并执行您需要做的事情，并更新IoC或服务定位器注册并使用它。|3093164|然而，有时这种逻辑是横切的，并且很难通过覆盖存储库方法来实现。所以我创建了IRepositoryBehavior，它基本上是一个事件接收器。(下面只是我脑海中的一个粗略的定义)|3093165|public+interface+IRepositoryBehavior
{
++++void+OnAdding(CancellableBehaviorContext+context);
++++void+OnAdd(BehaviorContext+context);

++++void+OnGetting(CancellableBehaviorContext+context);
++++void+OnGet(BehaviorContext+context);

++++void+OnRemoving(CancellableBehaviorContext+context);
++++void+OnRemove(BehaviorContext+context);

++++void+OnFinding(CancellableBehaviorContext+context);
++++void+OnFind(BehaviorContext+context);

++++bool+AppliesToEntityType(Type+entityType);
}|3093166|现在，这些行为可以是任何东西。审核、安全检查、软删除、执行域约束、验证等。我创建了一个行为，将其注册到IoC或服务定位器中，并修改我的通用存储库以获取已注册的IRepositoryBehavior的集合，根据当前存储库类型检查每个行为，并将操作包装在每个适用行为的前/后处理程序中。|3093167|这是一个软删除行为的例子(软删除意味着当有人请求删除一个实体时，我们只是将它标记为已删除，这样它就不会再次被返回，但实际上永远不会被物理删除)。|3093168|public+SoftDeleteBehavior+:+IRepositoryBehavior
{
+++//+omitted

+++public+bool+AppliesToEntityType(Type+entityType)
+++{
+++++++//+check+to+see+if+type+supports+soft+deleting
+++++++return+true;
+++}

+++public+void+OnRemoving(CancellableBehaviorContext+context)
+++{
++++++++var+entity+=+context.Entity+as+ISoftDeletable;
++++++++entity.Deleted+=+true;+//+when+the+NHibernate+session+is+flushed,+the+Deleted+column+will+be+updated

++++++++context.Cancel+=+true;+//+set+this+to+true+to+make+sure+the+repository+doesn't+physically+delete+the+entity.
+++}
}|3093169|是的，这基本上是NHibernate事件侦听器的简化和抽象实现，但这就是我喜欢它的原因。A)我可以在不引入NHibernate的情况下对行为进行单元测试B)我可以在NHibernate之外使用这些行为(假设存储库是包装REST服务调用的客户端实现)+C)+NH的事件侦听器可能是一个真正的麻烦;)|3093170|entityMap^0|0|36|1E|0|5|3|9|6|G|3|K|B|W|5|12|4|20|A|36|4|0|1B|8|0|0|0|0|0|0|0|A|6|0|0|11|J|0|0|27|J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1M|8|@$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]|$D|1V|E|1W|F|G]|$D|1X|E|1Y|F|G]|$D|1Z|E|20|F|G]|$D|21|E|22|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|23|8|@$D|24|E|25|F|G]]|9|@]|A|$]]|$1|L|3|M|5|N|7|26|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|27|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|28|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|29|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|N|7|2B|8|@]|9|@]|A|$O|P]]|$1|10|3|11|5|6|7|2C|8|@$D|2D|E|2E|F|G]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2F|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2G|8|@$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|16|3|17|5|N|7|2J|8|@]|9|@]|A|$O|P]]|$1|18|3|19|5|6|7|2K|8|@$D|2L|E|2M|F|G]]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|N|7|2O|8|@]|9|@]|A|$O|P]]|$1|1E|3|1F|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|1H|$]]

I have used a blend of #2 and #3, but I prefer a strict generic repository if possible (stricter than even suggested in the link for #3). #1 is no good because it plays poorly with unit testing. 

If you have a smaller domain or need to constrict which entities that your domain allows to be queried, I suppose #2- or #3 that defines entity specific repository interfaces that themselves implement a generic repository- makes sense. However, I find it to be exhausting and unnecessary to write an interface and a concrete implementation for every entity I want to query. What good is <code>public interface IFooRepository : IRepository&lt;Foo&gt;</code> (again, unless I need to constrain developers to a set of allowed aggregate roots)?

I just define my generic repository interface, with <code>Add</code>, <code>Remove</code>, <code>Get</code>, <code>GetDeferred</code>, <code>Count</code>, and <code>Find</code> methods (Find returns an <code>IQueryable</code> interface allowing LINQ), create a concrete generic implementation, and call it a day. I rely heavily on <code>Find</code> and thus LINQ. If I need to use a specific query more than once, I use extension methods and write the query using LINQ.

This covers 95% of my persistence needs. If I need to perform some sort of persistence action that can't be done generically, I use a home-grown <code>ICommand</code> API. For example, say I'm working with NHibernate and I need to perform a complex query as part of my domain, or perhaps I need to do a bulk command. The API looks roughly like this:

<pre><code>// marker interface, mainly used as a generic constraint
public interface ICommand
{
}

// commands that return no result, or a non-query
public interface ICommandNoResult : ICommand
{
 void Execute();
}

// commands that return a result, either a scalar value or record set
public interface ICommandWithResult&lt;TResult&gt; : ICommand
{
 TResult Execute();
}

// a query command that executes a record set and returns the resulting entities as an enumeration.
public interface IQuery&lt;TEntity&gt; : ICommandWithResult&lt;IEnumerable&lt;TEntity&gt;&gt;
{
 int Count();
}

// used to create commands at runtime, looking up registered commands in an IoC container or service locator
public interface ICommandFactory
{
 TCommand Create&lt;TCommand&gt;() where TCommand : ICommand;
}
</code></pre>

Now I can create an interface to represent a specific command.

<pre><code>public interface IAccountsWithBalanceQuery : IQuery&lt;AccountWithBalance&gt;
{
 Decimal MinimumBalance { get; set; }
}
</code></pre>

I can create a concrete implementation and use raw SQL, NHibernate HQL, whatever, and register it with my service locator.

Now in my business logic I can do something like this:

<pre><code>var query = factory.Create&lt;IAccountsWithBalanceQuery&gt;();
query.MinimumBalance = 100.0;

var overdueAccounts = query.Execute();
</code></pre>

You can also use a Specification pattern with <code>IQuery</code> to build meaningful, user-input-driven queries, rather than having an interface with million confusing properties, but that assumes you don't find the specification pattern confusing in its own right ;).

One last piece of the puzzle is when your repository needs to do specific pre- and -post repository operation. Now, you can very easily create an implementation of your generic repository for a specific entity, then override the relevant method(s) and do what you need to do, and update your IoC or service locator registration and be done with it.

However, sometimes this logic is cross-cutting and awkward to implement by overriding a repository method. So I created <code>IRepositoryBehavior</code>, which is basically an event sink. (Below is just a rough definition off the top of my head)

<pre><code>public interface IRepositoryBehavior
{
 void OnAdding(CancellableBehaviorContext context);
 void OnAdd(BehaviorContext context);

 void OnGetting(CancellableBehaviorContext context);
 void OnGet(BehaviorContext context);

 void OnRemoving(CancellableBehaviorContext context);
 void OnRemove(BehaviorContext context);

 void OnFinding(CancellableBehaviorContext context);
 void OnFind(BehaviorContext context);

 bool AppliesToEntityType(Type entityType);
}
</code></pre>

Now, these behaviors can be anything. Auditing, security checking, soft-delete, enforcing domain constraints, validation, etc. I create a behavior, register it with the IoC or service locator, and modify my generic repository to take in a collection of registered <code>IRepositoryBehavior</code>s, and check each behavior against the current repository type and wrap the operation in the pre/post handlers for each applicable behavior.

Here's an example soft-delete behavior (soft-delete means that when someone asks to delete an entity, we just mark it as deleted so it can't be returned again, but is never actually physically removed).

<pre><code>public SoftDeleteBehavior : IRepositoryBehavior
{
 // omitted

 public bool AppliesToEntityType(Type entityType)
 {
 // check to see if type supports soft deleting
 return true;
 }

 public void OnRemoving(CancellableBehaviorContext context)
 {
 var entity = context.Entity as ISoftDeletable;
 entity.Deleted = true; // when the NHibernate session is flushed, the Deleted column will be updated

 context.Cancel = true; // set this to true to make sure the repository doesn't physically delete the entity.
 }
}
</code></pre>

Yes, this is basically a simplified and abstracted implementation of NHibernate's event listeners, but that's why I like it. A) I can unit test a behavior without bringing NHibernate into the picture B) I can use these behaviors outside of NHibernate (say the repository is client implementation that wraps REST service calls) C) NH's event listeners can be a real pain in the ass ;)

blocks|key|3093210|text|在URF+-+Unit+of+Work+&+(extensible/generic)+Repositories+Framework上有一个现成的解决方案。这会为你节省很多时间。他们实现了一个通用存储库(还有一个异步存储库)。为了扩展任何存储库，他们使用了这样的扩展：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3093211|+++++public+static+decimal+GetCustomerOrderTotalByYear(this+IRepository<Customer>+repository,+string+customerId,+int+year)
++++{
++++++++return+repository
++++++++++++.Queryable()
++++++++++++.Where(c+=>+c.CustomerID+==+customerId)
++++++++++++.SelectMany(c+=>+c.Orders.Where(o+=>+o.OrderDate+!=+null+&&+o.OrderDate.Value.Year+==+year))
++++++++++++.SelectMany(c+=>+c.OrderDetails)
++++++++++++.Select(c+=>+c.Quantity*c.UnitPrice)
++++++++++++.Sum();
++++}|code-block|syntax|javascript|3093212|一些像QueryObject这样的类可能会超负荷工作，这取决于您的项目，但总的来说，它是一个很好的解决方案，可以帮助您开始运行。|3093213|entityMap|0|LINK|mutability|MUTABLE|url|https://genericunitofworkandrepositories.codeplex.com/^0|1|1S|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

There is a ready to use solution at <a href="https://genericunitofworkandrepositories.codeplex.com/" rel="nofollow noreferrer">URF - Unit of Work &amp; (extensible/generic) Repositories Framework</a>. It will save you a lot of time.
They implemented a generic repository (also there is an async repository). For extending any repository they have used extensions like this:

<pre><code> public static decimal GetCustomerOrderTotalByYear(this IRepository&lt;Customer&gt; repository, string customerId, int year)
 {
 return repository
 .Queryable()
 .Where(c =&gt; c.CustomerID == customerId)
 .SelectMany(c =&gt; c.Orders.Where(o =&gt; o.OrderDate != null &amp;&amp; o.OrderDate.Value.Year == year))
 .SelectMany(c =&gt; c.OrderDetails)
 .Select(c =&gt; c.Quantity*c.UnitPrice)
 .Sum();
 }
</code></pre>

Some classes like QueryObject may be an overwork depending on your project but overally it is good solution to help you get up and running.

blocks|key|222447|text|在这里我们来评选Asp.Net+MVC中的最佳存储库模式：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|222448|Repository模式在应用程序的数据层和域层之间添加了一个分离层。它还使应用程序的数据访问部分具有更好的可测试性。|222449|数据库工厂(IDatabaseFactory.cs):|222450|public+interface+IDatabaseFactory+:+IDisposable
{
++++Database_DBEntities+Get();
}|code-block|syntax|javascript|222451|数据库工厂实现(DatabaseFactory.cs):|222452|public+class+DatabaseFactory+:+Disposable,+IDatabaseFactory
{
++++private+Database_DBEntities+dataContext;
++++public+Database_DBEntities+Get()
++++{
++++++++return+dataContext+??+(dataContext+=+new+Database_DBEntities());
++++}

++++protected+override+void+DisposeCore()
++++{
++++++++if+(dataContext+!=+null)
++++++++++++dataContext.Dispose();
++++}
}|222453|基本接口(IRepository.cs):|222454|public+interface+IRepository<T>+where+T+:+class
{
++++void+Add(T+entity);
++++void+Update(T+entity);
++++void+Detach(T+entity);
++++void+Delete(T+entity);
++++T+GetById(long+Id);
++++T+GetById(string+Id);
++++T+Get(Expression<Func<T,+bool>>+where);
++++IEnumerable<T>+GetAll();
++++IEnumerable<T>+GetMany(Expression<Func<T,+bool>>+where);
++++void+Commit();
}|222455|抽象类(Repository.cs):|222456|public+abstract+class+Repository<T>+:+IRepository<T>+where+T+:+class
{
++++private+Database_DBEntities+dataContext;
++++private+readonly+IDbSet<T>+dbset;
++++protected+Repository(IDatabaseFactory+databaseFactory)
++++{
++++++++DatabaseFactory+=+databaseFactory;
++++++++dbset+=+DataContext.Set<T>();
++++}

++++///+<summary>
++++///+Property+for+the+databasefactory+instance
++++///+</summary>
++++protected+IDatabaseFactory+DatabaseFactory
++++{
++++++++get;
++++++++private+set;
++++}

++++///+<summary>
++++///+Property+for+the+datacontext+instance
++++///+</summary>
++++protected+Database_DBEntities+DataContext
++++{
++++++++get+{+return+dataContext+??+(dataContext+=+DatabaseFactory.Get());+}
++++}

++++///+<summary>
++++///+For+adding+entity
++++///+</summary>
++++///+<param+name="entity"></param>
++++public+virtual+void+Add(T+entity)
++++{
++++++++try
++++++++{
++++++++++++dbset.Add(entity);
++++++++++++//++dbset.Attach(entity);
++++++++++++dataContext.Entry(entity).State+=+EntityState.Added;
++++++++++++int+iresult+=+dataContext.SaveChanges();
++++++++}
++++++++catch+(UpdateException+ex)
++++++++{
++++++++}
++++++++catch+(DbUpdateException+ex)+//DbContext
++++++++{
++++++++}
++++++++catch+(Exception+ex)
++++++++{
++++++++++++throw+ex;
++++++++}
++++}

++++///+<summary>
++++///+For+updating+entity
++++///+</summary>
++++///+<param+name="entity"></param>
++++public+virtual+void+Update(T+entity)
++++{
++++++++try
++++++++{
++++++++++++//+dbset.Attach(entity);
++++++++++++dbset.Add(entity);
++++++++++++dataContext.Entry(entity).State+=+EntityState.Modified;
++++++++++++int+iresult+=+dataContext.SaveChanges();
++++++++}
++++++++catch+(UpdateException+ex)
++++++++{
++++++++++++throw+new+ApplicationException(Database_ResourceFile.DuplicateMessage,+ex);
++++++++}
++++++++catch+(DbUpdateException+ex)+//DbContext
++++++++{
++++++++++++throw+new+ApplicationException(Database_ResourceFile.DuplicateMessage,+ex);
++++++++}
++++++++catch+(Exception+ex)+{
++++++++++++throw+ex;
++++++++}
++++}

++++///+<summary>
++++///+for+deleting+entity+with+class+
++++///+</summary>
++++///+<param+name="entity"></param>
++++public+virtual+void+Delete(T+entity)
++++{
++++++++dbset.Remove(entity);
++++++++int+iresult+=+dataContext.SaveChanges();
++++}

++++//To+commit+save+changes
++++public+void+Commit()
++++{
++++++++//still+needs+modification+accordingly
++++++++DataContext.SaveChanges();
++++}

++++///+<summary>
++++///+Fetches+values+as+per+the+int64+id+value
++++///+</summary>
++++///+<param+name="id"></param>
++++///+<returns></returns>
++++public+virtual+T+GetById(long+id)
++++{
++++++++return+dbset.Find(id);
++++}

++++///+<summary>
++++///+Fetches+values+as+per+the+string+id+input
++++///+</summary>
++++///+<param+name="id"></param>
++++///+<returns></returns>
++++public+virtual+T+GetById(string+id)
++++{
++++++++return+dbset.Find(id);
++++}

++++///+<summary>
++++///+fetches+all+the+records+
++++///+</summary>
++++///+<returns></returns>
++++public+virtual+IEnumerable<T>+GetAll()
++++{
++++++++return+dbset.AsNoTracking().ToList();
++++}

++++///+<summary>
++++///+Fetches+records+as+per+the+predicate+condition
++++///+</summary>
++++///+<param+name="where"></param>
++++///+<returns></returns>
++++public+virtual+IEnumerable<T>+GetMany(Expression<Func<T,+bool>>+where)
++++{
++++++++return+dbset.Where(where).ToList();
++++}

++++///+<summary>
++++///+
++++///+</summary>
++++///+<param+name="entity"></param>
++++public+void+Detach(T+entity)
++++{
++++++++dataContext.Entry(entity).State+=+EntityState.Detached;
++++}

++++///+<summary>
++++///+fetches+single+records+as+per+the+predicate+condition
++++///+</summary>
++++///+<param+name="where"></param>
++++///+<returns></returns>
++++public+T+Get(Expression<Func<T,+bool>>+where)
++++{
++++++++return+dbset.Where(where).FirstOrDefault<T>();
++++}
}|222457|如何在控制器中访问此存储库模式：|222458|1.你有一个用户模型:|222459|public+partial+class+User
{
++++public+int+Id+{+get;+set;+}
++++public+string+Name+{+get;+set;+}
}|222460|2.现在您必须创建UserModel的存储库类|222461|public+class+UserRepository+:+Repository<User>,+IUserRepository
{
++++private+Database_DBEntities+dataContext;

++++protected+IDatabaseFactory+DatabaseFactory
++++{
++++++++get;
++++++++private+set;
++++}

++++public+UserRepository(IDatabaseFactory+databaseFactory)
++++++++:+base(databaseFactory)
++++{
++++++++DatabaseFactory+=+databaseFactory;
++++}

++++protected+Database_DBEntities+DataContext
++++{
++++++++get+{+return+dataContext+??+(dataContext+=+DatabaseFactory.Get());+}
++++}

++++public+interface+IUserRepository+:+IRepository<User>
++++{+
++++}
}|222462|3.现在您必须使用所有CRUD方法创建UserService接口(IUserService.cs)：|222463|public+interface+IUserService
{
++++#region+User+Details+
++++List<User>+GetAllUsers();
++++int+SaveUserDetails(User+Usermodel);
++++int+UpdateUserDetails(User+Usermodel);
++++int+DeleteUserDetails(int+Id);
++++#endregion
}|222464|4.现在您必须使用所有CRUD方法创建UserService接口(UserService.cs)：|222465|public+class+UserService+:+IUserService
{
++++IUserRepository+_userRepository;
++++public+UserService()+{+}
++++public+UserService(IUserRepository+userRepository)
++++{
++++++++this._userRepository+=+userRepository;
++++}

++++public+List<User>+GetAllUsers()
++++{
++++++++try
++++++++{
++++++++++++IEnumerable<User>+liUser+=+_userRepository.GetAll();
++++++++++++return+liUser.ToList();
++++++++}
++++++++catch+(Exception+ex)
++++++++{
++++++++++++throw+ex;
++++++++}
++++}

++++///+<summary>
++++///+Saves+the+User+details.
++++///+</summary>
++++///+<param+name="User">The+deptmodel.</param>
++++///+<returns></returns>
++++public+int+SaveUserDetails(User+Usermodel)
++++{
++++++++try
++++++++{
++++++++++++if+(Usermodel+!=+null)
++++++++++++{
++++++++++++++++_userRepository.Add(Usermodel);
++++++++++++++++return+1;
++++++++++++}
++++++++++++else
++++++++++++++++return+0;
++++++++}
++++++++catch
++++++++{
++++++++++++throw;
++++++++}
+++}

+++///+<summary>
+++///+Updates+the+User+details.
+++///+</summary>
+++///+<param+name="User">The+deptmodel.</param>
+++///+<returns></returns>
+++public+int+UpdateUserDetails(User+Usermodel)
+++{
+++++++try
+++++++{
+++++++++++if+(Usermodel+!=+null)
+++++++++++{
+++++++++++++++_userRepository.Update(Usermodel);
+++++++++++++++return+1;
+++++++++++}
+++++++++++else
+++++++++++++++return+0;
+++++++}
+++++++catch
+++++++{
+++++++++++throw;
+++++++}
+++}

+++///+<summary>
+++///+Deletes+the+User+details.
+++///+</summary>
+++///+<param+name="Id">The+code+identifier.</param>
+++///+<returns></returns>
+++public+int+DeleteUserDetails(int+Id)
+++{
+++++++try
+++++++{
+++++++++++User+Usermodel+=+_userRepository.GetById(Id);
+++++++++++if+(Usermodel+!=+null)
+++++++++++{
+++++++++++++++_userRepository.Delete(Usermodel);
+++++++++++++++return+1;
+++++++++++}
+++++++++++else
+++++++++++++++return+0;
+++++++}
+++++++catch
+++++++{
+++++++++++throw;
+++++++}
+++}
}|222466|现在，您已经为存储库模式进行了所有设置，并且可以访问User+：中的所有数据|222467|//Here+is+the+User+Controller+
public+class+UserProfileController+:+Controller
{
++++IUserService+_userservice;
++++public+CustomerProfileController(IUserService+userservice)
++++{
++++++++this._userservice+=+userservice;
++++}

++++[HttpPost]
++++public+ActionResult+GetAllUsers(int+id)
++++{
++++++++User+objUser=new+User();

++++++++objUser+=+_userservice.GetAllUsers().Where(x+=>+x.Id+==+id).FirstOrDefault();
++++}
}|222468|entityMap^0|0|T|0|0|0|R|0|0|0|S|0|0|0|L|0|0|0|J|0|0|0|G|0|0|B|0|0|0|I|0|0|0|1E|0|0|0|1D|0|0|V|1|0|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1R|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1Z|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|U|3|V|5|L|7|23|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|L|7|27|8|@]|D|@]|E|$M|N]]|$1|10|3|11|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|14|3|15|5|L|7|2E|8|@]|D|@]|E|$M|N]]|$1|16|3|17|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|18|3|19|5|L|7|2I|8|@]|D|@]|E|$M|N]]|$1|1A|3|1B|5|6|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|L|7|2M|8|@]|D|@]|E|$M|N]]|$1|1E|3|1F|5|6|7|2N|8|@$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|1G|3|1H|5|L|7|2Q|8|@]|D|@]|E|$M|N]]|$1|1I|3|1J|5|6|7|2R|8|@$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|1K|3|1L|5|L|7|2U|8|@]|D|@]|E|$M|N]]|$1|1M|3|-4|5|6|7|2V|8|@]|D|@]|E|$]]]|1N|$]]

Here we go for Best Repository Pattern in Asp.Net MVC: 

The Repository pattern adds a separation layer between the data and domain layers of an application. It also makes the data access parts of an application better testable.



Database Factory (IDatabaseFactory.cs): 

<pre><code>public interface IDatabaseFactory : IDisposable
{
 Database_DBEntities Get();
}
</code></pre>

Database Factory Implementations (DatabaseFactory.cs): 

<pre><code>public class DatabaseFactory : Disposable, IDatabaseFactory
{
 private Database_DBEntities dataContext;
 public Database_DBEntities Get()
 {
 return dataContext ?? (dataContext = new Database_DBEntities());
 }

 protected override void DisposeCore()
 {
 if (dataContext != null)
 dataContext.Dispose();
 }
}
</code></pre>

Base Interface (IRepository.cs): 

<pre><code>public interface IRepository&lt;T&gt; where T : class
{
 void Add(T entity);
 void Update(T entity);
 void Detach(T entity);
 void Delete(T entity);
 T GetById(long Id);
 T GetById(string Id);
 T Get(Expression&lt;Func&lt;T, bool&gt;&gt; where);
 IEnumerable&lt;T&gt; GetAll();
 IEnumerable&lt;T&gt; GetMany(Expression&lt;Func&lt;T, bool&gt;&gt; where);
 void Commit();
}
</code></pre>

Abstract Class (Repository.cs):

<pre><code>public abstract class Repository&lt;T&gt; : IRepository&lt;T&gt; where T : class
{
 private Database_DBEntities dataContext;
 private readonly IDbSet&lt;T&gt; dbset;
 protected Repository(IDatabaseFactory databaseFactory)
 {
 DatabaseFactory = databaseFactory;
 dbset = DataContext.Set&lt;T&gt;();
 }

 /// &lt;summary&gt;
 /// Property for the databasefactory instance
 /// &lt;/summary&gt;
 protected IDatabaseFactory DatabaseFactory
 {
 get;
 private set;
 }

 /// &lt;summary&gt;
 /// Property for the datacontext instance
 /// &lt;/summary&gt;
 protected Database_DBEntities DataContext
 {
 get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
 }

 /// &lt;summary&gt;
 /// For adding entity
 /// &lt;/summary&gt;
 /// &lt;param name="entity"&gt;&lt;/param&gt;
 public virtual void Add(T entity)
 {
 try
 {
 dbset.Add(entity);
 // dbset.Attach(entity);
 dataContext.Entry(entity).State = EntityState.Added;
 int iresult = dataContext.SaveChanges();
 }
 catch (UpdateException ex)
 {
 }
 catch (DbUpdateException ex) //DbContext
 {
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }

 /// &lt;summary&gt;
 /// For updating entity
 /// &lt;/summary&gt;
 /// &lt;param name="entity"&gt;&lt;/param&gt;
 public virtual void Update(T entity)
 {
 try
 {
 // dbset.Attach(entity);
 dbset.Add(entity);
 dataContext.Entry(entity).State = EntityState.Modified;
 int iresult = dataContext.SaveChanges();
 }
 catch (UpdateException ex)
 {
 throw new ApplicationException(Database_ResourceFile.DuplicateMessage, ex);
 }
 catch (DbUpdateException ex) //DbContext
 {
 throw new ApplicationException(Database_ResourceFile.DuplicateMessage, ex);
 }
 catch (Exception ex) {
 throw ex;
 }
 }

 /// &lt;summary&gt;
 /// for deleting entity with class 
 /// &lt;/summary&gt;
 /// &lt;param name="entity"&gt;&lt;/param&gt;
 public virtual void Delete(T entity)
 {
 dbset.Remove(entity);
 int iresult = dataContext.SaveChanges();
 }

 //To commit save changes
 public void Commit()
 {
 //still needs modification accordingly
 DataContext.SaveChanges();
 }

 /// &lt;summary&gt;
 /// Fetches values as per the int64 id value
 /// &lt;/summary&gt;
 /// &lt;param name="id"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public virtual T GetById(long id)
 {
 return dbset.Find(id);
 }

 /// &lt;summary&gt;
 /// Fetches values as per the string id input
 /// &lt;/summary&gt;
 /// &lt;param name="id"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public virtual T GetById(string id)
 {
 return dbset.Find(id);
 }

 /// &lt;summary&gt;
 /// fetches all the records 
 /// &lt;/summary&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public virtual IEnumerable&lt;T&gt; GetAll()
 {
 return dbset.AsNoTracking().ToList();
 }

 /// &lt;summary&gt;
 /// Fetches records as per the predicate condition
 /// &lt;/summary&gt;
 /// &lt;param name="where"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public virtual IEnumerable&lt;T&gt; GetMany(Expression&lt;Func&lt;T, bool&gt;&gt; where)
 {
 return dbset.Where(where).ToList();
 }

 /// &lt;summary&gt;
 /// 
 /// &lt;/summary&gt;
 /// &lt;param name="entity"&gt;&lt;/param&gt;
 public void Detach(T entity)
 {
 dataContext.Entry(entity).State = EntityState.Detached;
 }

 /// &lt;summary&gt;
 /// fetches single records as per the predicate condition
 /// &lt;/summary&gt;
 /// &lt;param name="where"&gt;&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public T Get(Expression&lt;Func&lt;T, bool&gt;&gt; where)
 {
 return dbset.Where(where).FirstOrDefault&lt;T&gt;();
 }
}
</code></pre>

How to access this repository pattern in controller:

1. You have User Model :

<pre><code>public partial class User
{
 public int Id { get; set; }
 public string Name { get; set; }
}
</code></pre>

2. Now you have to create Repository Class of your UserModel

<pre><code>public class UserRepository : Repository&lt;User&gt;, IUserRepository
{
 private Database_DBEntities dataContext;

 protected IDatabaseFactory DatabaseFactory
 {
 get;
 private set;
 }

 public UserRepository(IDatabaseFactory databaseFactory)
 : base(databaseFactory)
 {
 DatabaseFactory = databaseFactory;
 }

 protected Database_DBEntities DataContext
 {
 get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
 }

 public interface IUserRepository : IRepository&lt;User&gt;
 { 
 }
}
</code></pre>

3. Now you have to create UserService Interface (IUserService.cs) with all CRUD Methods:

<pre><code>public interface IUserService
{
 #region User Details 
 List&lt;User&gt; GetAllUsers();
 int SaveUserDetails(User Usermodel);
 int UpdateUserDetails(User Usermodel);
 int DeleteUserDetails(int Id);
 #endregion
}
</code></pre>

4. Now you have to create UserService Interface (UserService.cs) with all CRUD Methods:

<pre><code>public class UserService : IUserService
{
 IUserRepository _userRepository;
 public UserService() { }
 public UserService(IUserRepository userRepository)
 {
 this._userRepository = userRepository;
 }

 public List&lt;User&gt; GetAllUsers()
 {
 try
 {
 IEnumerable&lt;User&gt; liUser = _userRepository.GetAll();
 return liUser.ToList();
 }
 catch (Exception ex)
 {
 throw ex;
 }
 }

 /// &lt;summary&gt;
 /// Saves the User details.
 /// &lt;/summary&gt;
 /// &lt;param name="User"&gt;The deptmodel.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public int SaveUserDetails(User Usermodel)
 {
 try
 {
 if (Usermodel != null)
 {
 _userRepository.Add(Usermodel);
 return 1;
 }
 else
 return 0;
 }
 catch
 {
 throw;
 }
 }

 /// &lt;summary&gt;
 /// Updates the User details.
 /// &lt;/summary&gt;
 /// &lt;param name="User"&gt;The deptmodel.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public int UpdateUserDetails(User Usermodel)
 {
 try
 {
 if (Usermodel != null)
 {
 _userRepository.Update(Usermodel);
 return 1;
 }
 else
 return 0;
 }
 catch
 {
 throw;
 }
 }

 /// &lt;summary&gt;
 /// Deletes the User details.
 /// &lt;/summary&gt;
 /// &lt;param name="Id"&gt;The code identifier.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public int DeleteUserDetails(int Id)
 {
 try
 {
 User Usermodel = _userRepository.GetById(Id);
 if (Usermodel != null)
 {
 _userRepository.Delete(Usermodel);
 return 1;
 }
 else
 return 0;
 }
 catch
 {
 throw;
 }
 }
}
</code></pre>

5. Now you All set for your Repository Pattern and you can access all data in User Controller:

<pre><code>//Here is the User Controller 
public class UserProfileController : Controller
{
 IUserService _userservice;
 public CustomerProfileController(IUserService userservice)
 {
 this._userservice = userservice;
 }

 [HttpPost]
 public ActionResult GetAllUsers(int id)
 {
 User objUser=new User();

 objUser = _userservice.GetAllUsers().Where(x =&gt; x.Id == id).FirstOrDefault();
 }
}
</code></pre>

I recently learned ASP.NET MVC (I love it). I'm working with a company that uses dependency injection to load a Repository instance in each request, and I'm familiar with using that repository.

But now I'm writing a couple of MVC applications of my own. I don't fully understand the hows and whys of the repository my company uses, and I'm trying to decide the best approach to implement data access.

I am using C# and Entity Framework (with all the latest versions).

I see three general approaches for handling data access.

<ol>
<li>Regular DB context within a using statement each time I access data. This is simple and it works okay. However, if two locations need to read the same data within one request, the data must be read twice. (With a single repository per request, the same instance would be used in both places and I understand the second read would simply return the data from the first read.)</li>
<li>A typical <a href="http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application">repository pattern</a>. For reasons I don't understand, this typical pattern involves creating a wrapper class for every table used from the database. That seems wrong to me. In fact, since they are implemented also as interfaces, I'd technically be creating two wrapper classes for each table. EF creates tables for me. I don't believe this approach makes sense.</li>
<li>There is also a <a href="http://www.tugberkugurlu.com/archive/generic-repository-pattern-entity-framework-asp-net-mvc-and-unit-testing-triangle">generic repository pattern</a> where a single repository class is created to serve all entity objects. This makes much more sense to me. But does it make sense to others? Is the link above the best approach?</li>
</ol>

I'd love to get some input from others on this topic. Are you writing your own repository, using one of those above, or doing something different altogether. Please share.

Best Repository Pattern for ASP.NET MVC

单元测试

数据库

我最近学习了ASP.NET MVC (我喜欢它)。我正在与一家公司合作，该公司使用依赖注入在每个请求中加载一个repository实例，我熟悉使用该存储库。但现在我正在编写自己的几个MVC应用程序。我不完全了解我的公司使用存储库的方式和原因，我正在尝试确定实现数据访问的最佳方法。我使用的是C#和实体框架(所有最新版本)...

问ASP.NET MVC的最佳存储库模式
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ASP.NET MVC的最佳存储库模式EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ASP.NET MVC的最佳存储库模式
EN