generic-repo | Downloadable public artifacts/files from myjeeva.com

We had a project which we had dapper generic repository but after project evolved we have ditched the generic repository to use the real power of dapper.

I would recommend to use Dapper as direct without generic CRUD operations.

To demonstrate what we had i will provide a sample code which is not production ready will give you an idea to implement your own generic repo.

Expanding on suggestions from comments, you can instantiate the context in your code and invoke all EF model inspection APIs as outlined in Ivan's answer like so:

Notice that the methods have async also have await. In those methods you wait for the to execute to obtain the result, meanwhile in those methods without await you don't care when they will be executed

Generic repositories are an anti-pattern with Entity Framework. They're honestly not worth the hassle.

However, to map a ProductID column in the entity:

You could declare 4 stages, each one with the second parameter already set (meaning not part of your parameters), and called using the parallel syntax

That way:

• you don't have to deal with an "extended choice parameter"
• you can differentiate each stage
• you can run them in parallel

Regarding the first approach (using EF Core metadata services):

First, EF Core is ORM (Object Relational Mapper), with most important here is Mapper.

Second, it uses the so called code based model, which means all the mappings are provided by code and not the actual database (even though the model is created by reverse engineering of an existing database).

In simple words, EF Core creates at runtime a memory data structure containing the information (metadata) about classes and properties, and their mappings to database tables, columns and relationships. All that information is based on pure code model - the entity classes, conventions, data annotations and fluent configuration.

All EF Core runtime behaviors are based on that metadata model. EF Core uses it internally when building queries, mapping the query results to objects, linking navigation properties, generating create/update/delete commands and their order of execution, updating temporary FK property values after getting the real autogenerated principal key values etc.

Hence the metadata model and discovering services (methods) use optimized data structures and are (has to be) quite efficient. And again, no database operations are involved.

So the first approach is quite efficient. The performance impact of obtaining the PK property name via metadata service is negligible compared to actual query building, execution and materialization.

Also the performance of the first approach is similar to EF Core Find method which you are using in another method. Note that when calling Find method you just pass the PK value(s) and not the properties. So the method implementation should somehow know how to build the Where expression, right? And what it does internally is very similar to the suggested snippet.

Regarding the second approach:

It's simply not comparable because it doesn't work. It's possible to use base class/interface, but only if the actual property name is mapped - like all classes have Id property, and it's mapped to different column name in the database tables using [Column] data annotation or HasColumnName fluent API.

In your example, the Id property is [NotMapped] (ignored). Which means EF Core cannot map to the table column. The fact that your are mapping it to another property via code (property getter/setter) doesn't matter. EF Core is not a (de)compiler, it can't see your code, hence cannot translate a LINQ query using such properties to SQL.

Which in EF Core 2.x leads to either client evaluation (very inefficient, reading to whole table and applying the filter in memory), or exception if client evaluation is configured to do so. And in EF Core 3.0+ it will always be an exception.

So in case you don't remove properties like PropertyId and map the property Id (which would be hard with "database first" models), the second "approach" should be avoided. And even if you can map the actual Id property, all you'll save would be a few milliseconds. And again, when using Find you don't bother about performance, why bother with methods that uses the same (or similar) approach.

Your include path only has a single hop from UserEntity to UserRoleEntity (via the UserRoles property. You need to include the next step to ensure you also capture the RoleEntity. To do this, change your path to UserRoles.RoleEntity, for example: