Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to achieve the Repository pattern". In the daily operation, I believe many people have doubts about how to achieve the Repository pattern. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to achieve the Repository pattern"! Next, please follow the editor to study!

Demand

Friends who often write CRUD programs may have experienced the scenarios of defining a lot of Repository interfaces, doing corresponding implementations, dependency injection and use. Sometimes we will find that the logic of many distributed XXXXRepository is basically the same, so we begin to think about whether these operations can be abstracted out, of course, and the abstracted part can be directly introduced and used in any future project with this requirement without change.

So the requirement of this article is: how to implement a reusable Repository module.

Long text early warning, including a lot of code.

target

Implement the generic Repository schema and validate it.

Principles and ideas

The basis of generality is abstraction, and the granularity of abstraction determines the degree of generality, but also determines the complexity of use. For their own project, the most appropriate level of abstraction, the need to weigh, maybe later I will decide to implement a complete Repository library to provide (in fact, many people have done so, we can even download Nuget package to use, but their own to achieve the process can make you better understand the principles, but also understand how to develop a general class library. )

The general idea is to define the relevant interfaces in Application and implement the functions of the base class in Infrastructure.

Implement a general Repository implementation

There are actually a lot of aspects involved in how to design a general-purpose Repository library, especially when getting data. And according to everyone's habits, the way to implement is quite different, especially with regard to what methods generic interfaces need to provide, everyone has their own understanding. Here I will only demonstrate the basic ideas and keep it as simple as possible. For more complex and comprehensive implementations, there are many libraries that have been written on GIthub to learn and refer to, which I will list below:

Obviously, the first step is to add a definition of IRepository in Application/Common/Interfaces to apply to different types of entities, and then create a base class RepositoryBase in Infrastructure/Persistence/Repositories to implement this interface, and there is a way to provide consistent external method signatures.

IRepository.cs

Namespace TodoList.Application.Common.Interfaces;public interface IRepository where T: class {}

RepositoryBase.cs

Using Microsoft.EntityFrameworkCore;using TodoList.Application.Common.Interfaces;namespace TodoList.Infrastructure.Persistence.Repositories;public class RepositoryBase: IRepository where T: class {private readonly TodoListDbContext _ dbContext; public RepositoryBase (TodoListDbContext dbContext) = > _ dbContext = dbContext;}

Before you actually define IRepository, consider what happens to database operations:

New entity (Create)

The logic of the new entity at the Repository level is simple. Just pass in an entity object and save it to the database. There are no other special requirements.

IRepository.cs

/ / other Create-related API Task AddAsync (T entity, CancellationToken cancellationToken = default) is omitted.

RepositoryBase.cs

/ / omit other... public async Task AddAsync (T entity, CancellationToken cancellationToken = default) {await _ dbContext.Set (). AddAsync (entity, cancellationToken); await _ dbContext.SaveChangesAsync (cancellationToken); return entity;}

Update entity (Update)

It is similar to the new entity, but it is usually operated by a single entity object when updating.

IRepository.cs

/ / other Update-related API Task UpdateAsync (T entity, CancellationToken cancellationToken = default) is omitted.

RepositoryBase.cs

/ / omit other... public async Task UpdateAsync (T entity, CancellationToken cancellationToken = default) {/ / for general updates, all Attach to the entity, just set the entity's State to Modified. State = EntityState.Modified; await _ dbContext.SaveChangesAsync (cancellationToken);}

Delete entity (Delete)

For deleting entities, two situations can occur: delete an entity, or delete a group of entities.

IRepository.cs

/ / other... / Delete-related APIs are omitted. Here, according to the key API for deleting objects, you need to use a method to obtain objects: ValueTask GetAsync (object key); Task DeleteAsync (object key); Task DeleteAsync (T entity, CancellationToken cancellationToken = default); Task DeleteRangeAsync (IEnumerable entities, CancellationToken cancellationToken = default).

RepositoryBase.cs

/ omit other... public virtual ValueTask GetAsync (object key) = > _ dbContext.Set (). FindAsync (key); public async Task DeleteAsync (object key) {var entity = await GetAsync (key); if (entity is not null) {await DeleteAsync (entity);}} public async Task DeleteAsync (T entity, CancellationToken cancellationToken = default) {_ dbContext.Set (). Remove (entity); await _ dbContext.SaveChangesAsync (cancellationToken) } public async Task DeleteRangeAsync (IEnumerable entities, CancellationToken cancellationToken = default) {_ dbContext.Set () .RemoveRange (entities); await _ dbContext.SaveChangesAsync (cancellationToken);}

Get entity (Retrieve)

It is the most complex part of how to get the entity. We need to consider not only how to obtain which data, but also whether there are any special requirements for the obtained data, such as sorting, paging, conversion of data object types and so on.

Specifically, for example, the following is a typical LINQ query:

Var results = await _ context.A.Join (_ context.B, a = > a.Id, b = > b.aId, (a B) = > new {/ /...}) .Where (ab = > ab.Name = = "name" & & ab.Date = = DateTime.Now) .Select (ab = > new {/ /...}) .OrderBy (o = > o.Date) .Skip (20 * 1) .Take (20) .ToListAsync ()

The entire query structure can be divided into the following components, and each part is basically expressed in the form of lambda expressions, which can be represented by Expression-related objects when modeling:

1. The query dataset preparation process, in which keywords such as Include/Join/GroupJoin/GroupBy may appear, are used to build a dataset for the next query.

2.Where clause, which is used to filter the query collection.

The 3.Select clause, which is used to convert the original data type to the desired result type.

The 4.Order clause, which is used to sort the result set, may contain keywords like: OrderBy/OrderByDescending/ThenBy/ThenByDescending.

The 5.Paging clause, which is used for back-end paging returns to the result set, is usually used together with Skip/Take.

6. Most of the other clauses are conditional controls, such as AsNoTracking/SplitQuery and so on.

In order to keep our presentation from being too complicated, I will make some choices. For the implementation here, I refer to the relevant implementation in Edi.Wang 's Moonglade. Interested partners can also find a more complete implementation: Ardalis.Specification.

First, define a simple ISpecification to represent the various conditions of the query:

Using System.Linq.Expressions;using Microsoft.EntityFrameworkCore.Query;namespace TodoList.Application.Common.Interfaces;public interface ISpecification {/ / query conditional clause Expression Criteria {get;} / / Include clause Func Include {get;} / / OrderBy clause Expression OrderBy {get;} / / OrderByDescending clause Expression OrderByDescending {get;} / / paging related attributes int Take {get;} int Skip {get;} bool IsPagingEnabled {get }}

And implement this generic interface in Application/Common:

Using System.Linq.Expressions;using Microsoft.EntityFrameworkCore.Query;using TodoList.Application.Common.Interfaces;namespace TodoList.Application.Common;public abstract class SpecificationBase: ISpecification {protected SpecificationBase () {} protected SpecificationBase (Expression criteria) = > Criteria = criteria; public Expression Criteria {get; private set;} public Func Include {get; private set;} public List IncludeStrings {get;} = new (); public Expression OrderBy {get; private set;} public Expression OrderByDescending {get; private set } public int Take {get; private set;} public int Skip {get; private set;} public bool IsPagingEnabled {get; private set;} public void AddCriteria (Expression criteria) = > Criteria = Criteria is not null? Criteria.AndAlso (criteria): criteria; protected virtual void AddInclude (Func includeExpression) = > Include = includeExpression; protected virtual void AddInclude (string includeString) = > IncludeStrings.Add (includeString); protected virtual void ApplyPaging (int skip, int take) {Skip = skip; Take = take; IsPagingEnabled = true;} protected virtual void ApplyOrderBy (Expression orderByExpression) = > OrderBy = orderByExpression; protected virtual void ApplyOrderByDescending (Expression orderByDescendingExpression) = > OrderByDescending = orderByDescendingExpression } / / https://stackoverflow.com/questions/457316/combining-two-expressions-expressionfunct-boolpublic static class ExpressionExtensions {public static Expression AndAlso (this Expression expr1, Expression expr2) {var parameter = Expression.Parameter (typeof (T)); var leftVisitor = new ReplaceExpressionVisitor (expr1.Parameters [0], parameter); var left = leftVisitor.Visit (expr1.Body); var rightVisitor = new ReplaceExpressionVisitor (expr2.Parameters [0], parameter) Var right = rightVisitor.Visit (expr2.Body); return Expression.Lambda (Expression.AndAlso (left??) Throw new InvalidOperationException (), right? Throw new InvalidOperationException (), parameter);} private class ReplaceExpressionVisitor: ExpressionVisitor {private readonly Expression _ oldValue; private readonly Expression _ newValue; public ReplaceExpressionVisitor (Expression oldValue, Expression newValue) {_ oldValue = oldValue; _ newValue = newValue;} public override ExpressionVisit (Expression node) = > node = = _ oldValue? _ newValue: base.Visit (node);}}

In order to string all the Spcification together in RepositoryBase to form a query clause, we also need to define a SpecificationEvaluator class for organizing the Specification:

Using TodoList.Application.Common.Interfaces;namespace TodoList.Application.Common;public class SpecificationEvaluator where T: class {public static IQueryable GetQuery (IQueryable inputQuery, ISpecification? Specification) {var query = inputQuery; if (specification?.Criteria is not null) {query = query.Where (specification.Criteria);} if (specification?.Include is not null) {query = specification.Include (query);} if (specification?.OrderBy is not null) {query = query.OrderBy (specification.OrderBy) } else if (specification?.OrderByDescending is not null) {query = query.OrderByDescending (specification.OrderByDescending);} if (specification?.IsPagingEnabled! = false) {query = query.Skip. Take (specification.Take);} return query;}}

Adding query-related APIs to IRepository can be divided into the following types of APIs, and synchronous and asynchronous APIs may exist in each category:

IRepository.cs

/ / omit the others. / / 1. Query the basic operation interface IQueryable GetAsQueryable (); IQueryable GetAsQueryable (ISpecification spec); / / 2. Query quantity-related API int Count (ISpecification? Spec = null); int Count (Expression condition); Task CountAsync (ISpecification? Spec) / / 3. Query existence-related API bool Any (ISpecification? Spec); bool Any (Expression? Condition = null); / / 4. Access to the original entity type data related interface Task GetAsync (Expression condition); Task GetAsync (); Task GetAsync (ISpecification? Spec); / / 5. Get mapping entity type data-related interfaces according to conditions, including operations related to Group. Use selector to pass in the mapping expression TResult? SelectFirstOrDefault (ISpecification? Spec, Expression selector); Task SelectFirstOrDefaultAsync (ISpecification? Spec, Expression selector); Task SelectAsync (Expression selector); Task SelectAsync (ISpecification? Spec, Expression selector); Task SelectAsync (Expression groupExpression, Expression selector, ISpecification? Spec = null)

With these basics in place, we can implement the rest of the code for the query part of the RepositoryBase class in Infrastructure/Persistence/Repositories:

RepositoryBase.cs

/ / omit the others. / / 1. Query basic operation interface public IQueryable GetAsQueryable () = > _ dbContext.Set (); public IQueryable GetAsQueryable (ISpecification spec) = > ApplySpecification (spec); / / 2. Query quantity-related API public int Count (Expression condition) = > _ dbContext.Set (). Count (condition); public int Count (ISpecification? Spec = null) = > null! = spec? ApplySpecification (spec) .Count (): _ dbContext.Set () .Count (); public Task CountAsync (ISpecification? Spec) = > ApplySpecification (spec). CountAsync (); / / 3. Query existence-related interfaces to implement public bool Any (ISpecification? Spec) = > ApplySpecification (spec). Any (); public bool Any (Expression? Condition = null) = > null! = condition? _ dbContext.Set (). Any (condition): _ dbContext.Set (). Any (); / / 4. Implement public async Task GetAsync (Expression condition) = > await _ dbContext.Set (). FirstOrDefaultAsync (condition); public async Task GetAsync () = > await _ dbContext.Set (). AsNoTracking (). ToListAsync (); public async Task GetAsync (ISpecification? Spec) = > await ApplySpecification (spec). AsNoTracking (). ToListAsync (); / / 5. According to the condition to obtain the mapping entity type data related interface to implement public TResult? SelectFirstOrDefault (ISpecification? Spec, Expression selector) = > ApplySpecification (spec). AsNoTracking (). Select (selector). FirstOrDefault (); public Task SelectFirstOrDefaultAsync (ISpecification? Spec, Expression selector) = > ApplySpecification (spec). AsNoTracking (). Select (selector). FirstOrDefaultAsync (); public async Task SelectAsync (Expression selector) = > await _ dbContext.Set (). AsNoTracking (). Select (selector). ToListAsync (); public async Task SelectAsync (ISpecification? Spec, Expression selector) = > await ApplySpecification (spec). AsNoTracking (). Select (selector). ToListAsync (); public async Task SelectAsync (Expression groupExpression, Expression selector, ISpecification? Spec = null) = > null! = spec? Await ApplySpecification (spec) .AsNoTracking () .GroupBy (groupExpression) .Select (selector) .ToListAsync (): await _ dbContext.Set () .AsNoTracking () .GroupBy (groupExpression) .Select (selector) .ToListAsync (); / / the helper method used to concatenate all Specification, receiving a `Queryable` object (usually a data collection) and a Specification object defined by the current entity, and returning a `IQueryable` object as the result of clause execution. Private IQueryable ApplySpecification (ISpecification? Spec) = > SpecificationEvaluator.GetQuery (_ dbContext.Set () .AsQueryable (), spec)

To verify the use of generic Repsitory, we can first do dependency injection in Infrastructure/DependencyInjection.cs:

/ / in AddInfrastructure, omit other services.AddScoped (typeof (IRepository), typeof (RepositoryBase)); verify

For preliminary verification (mainly query interface), we create a new folder TodoItems/Specs in the Application project and create a TodoItemSpec class:

Using TodoList.Application.Common;using TodoList.Domain.Entities;using TodoList.Domain.Enums;namespace TodoList.Application.TodoItems.Specs;public sealed class TodoItemSpec: SpecificationBase {public TodoItemSpec (bool done, PriorityLevel priority): base (t = > t.Done = = done & & t.Priority = = priority) {}}

Then we temporarily use the sample interface WetherForecastController to check the correctness of the query through the log.

Private readonly IRepository _ repository;private readonly ILogger _ logger;// to verify, temporarily inject the IRepository object here, and undo the modified public WeatherForecastController (IRepository repository, ILogger logger) {_ repository = repository; _ logger = logger;} after verification

Add this logic to the Get method to observe the log output:

/ / log _ logger.LogInformation ($"maybe this log is provided by Serilog..."); var spec = new TodoItemSpec (true, PriorityLevel.High); var items = _ repository.GetAsync (spec) .result; foreach (var item in items) {_ logger.LogInformation ($"item: {item.Id}-{item.Title}-{item.Priority}");}

Start the Api project, then request the sample interface, and observe the console output:

# the above omitted, the Controller log begins. [16:49:59 INF] maybe this log is provided by Serilog... [16:49:59 INF] EntityFrameworkCore 6.0.1 initialized 'TodoListDbContext' using provider' Microsoft.EntityFrameworkCore.SqlServer:6.0.1' with options: MigrationsAssembly=TodoList.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null [16:49:59 INF] Executed DbCommand (51ms) [Parameters= [@ _ done_0='?'] (DbType = Boolean), @ _ _ priority_1='?' (DbType = Int32)], CommandType='Text', CommandTimeout='30'] SELECT [t]. [Id], [t]. [Created], [t]. [CreatedBy], [t]. [Done], [t]. [LastModified], [t]. [LastModifiedBy], [t]. [ListId], [t]. [t]. [Title] FROM [TodoItems] AS [t] WHERE ([t]. [Done] = @ _ _ done_0) AND ([t]. [Priority] = @ _ _ priority_1) # the following sentence is the seed data from our previous initialization database You can refer to the verification screenshot at the end of the previous article. [16:49:59 INF] item: 87f1ddf1-e6cd-4113-74ed-08d9c5112f6b-Apples-High [16:49:59 INF] Executing ObjectResult, writing value of type 'TodoList.Api.WeatherForecast []'. [16:49:59 INF] Executed action TodoList.Api.Controllers.WeatherForecastController.Get (TodoList.Api) in 160.5517ms, this is the end of the study on "how to implement the Repository pattern", hoping to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.