jeffward01
commented
1 year ago Hello!
Any thoughts on: EntityFrameworkQueryableExtensions.AsNoTrackingWithIdentityResolution also?
My implementation thought process:
I very much like your libraries and you have a very similar development thought process to my own in your libraries. I have my own 'Repository' implementation which I have been refactoring for a while, recently I added many of the Fluxera libraries to my own projects.
The only reason why I created my own implementation at this point was so that I could have more verbose methods, projections, pagination via Gridify rather than IQueryOptions<>, and a few other differences.
Code Snippets on implementation
My AsNoTracking implementation comes from a PR I made here: EasyRepository.EfCore
The owner of the Repo made had some opinions on how he made projections in his library which were a major limitation for me. So I forked it and have been expanding the feature set.
Below are snippets of how I implemented AsNoTracking, AsTracking and AsNoTrackingWithIdentityResolution in my similar library.
This is taken from the equivalent of your RepositoryBase class:
/// <inheritdoc />
async Task<PagedResponse<TProjected>> IAeonicCanFind<TEntity>.FindManyAsync<TProjected>(
EfTrackingOptions asNoTracking,
IPaginatedRequest filter,
Expression<Func<TEntity, TProjected>> projectExpression,
CancellationToken cancellationToken)
{
return await this._innerRepository.FindManyAsync(asNoTracking, filter, projectExpression, cancellationToken);
}
/// <inheritdoc />
async Task<PagedResponse<TEntity>> IAeonicCanFind<TEntity>.FindManyAsync(
EfTrackingOptions asNoTracking,
IPaginatedRequest filter,
Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> includeExpression,
CancellationToken cancellationToken)
{
return await this._innerRepository.FindManyAsync(asNoTracking, filter, includeExpression, cancellationToken);
}
/// <inheritdoc />
async Task<PagedResponse<TEntity>> IAeonicCanFind<TEntity>.FindManyAsync(
EfTrackingOptions asNoTracking,
IPaginatedRequest filter,
CancellationToken cancellationToken)
{
return await this._innerRepository.FindManyAsync(asNoTracking, filter, cancellationToken);
}
/// <inheritdoc />
IEnumerable<TProjected> IAeonicCanFind<TEntity>.FindMany<TProjected>(
EfTrackingOptions asNoTracking,
Expression<Func<TEntity, TProjected>> projectExpression)
{
return this._innerRepository.FindMany(asNoTracking, projectExpression);
}
/// <inheritdoc />
IEnumerable<TProjected> IAeonicCanFind<TEntity>.FindMany<TProjected>(
EfTrackingOptions asNoTracking,
Expression<Func<TEntity, bool>> whereExpression,
Expression<Func<TEntity, TProjected>> projectExpression)
{
return this._innerRepository.FindMany(asNoTracking, whereExpression, projectExpression);
}I have an enum called EfTrackingOptions that is:
/// <summary>
/// Sets EntityFramework queries to
/// <see cref="AsNoTracking" />, <see cref="AsNoTrackingWithIdentityResolution"/> or <see cref="WithTracking" />
/// </summary>
public enum EfTrackingOptions
{
/// <summary>
/// Disables EfCore change tracking
/// <remarks>The fastest option, however I your query returns 4 books and their authors,
/// you’ll get 8 instances in total even if 2 books have the same author. </remarks>
/// </summary>
AsNoTracking,
/// <summary>
/// Enables EfCore Change Tracking
/// <remarks>Slowest option - however entities utilize full change tracking</remarks>
/// </summary>
WithTracking,
/// <summary>
/// Disables EfCore change tracking - Will still perform identity resolution
/// to eliminate duplicate instances of objects.
/// <remarks><see cref="AsNoTrackingWithIdentityResolution"/> is a little slower than
/// the fastest option using <see cref="AsNoTracking"/></remarks>
/// </summary>
AsNoTrackingWithIdentityResolution
}
Then I have an extension class similar to your QueryableExtensions that has the method:
/// <summary>
/// Applies change tracking to the <see cref="IQueryable{T}"/>
/// </summary>
/// <param name="queryable">The target <see cref="IQueryable{T}"/></param>
/// <param name="trackingOptions">Tracking options.
/// Default: <see cref="EfTrackingOptions.WithTracking"/></param>
/// <typeparam name="T"></typeparam>
/// <returns>Returns the <see cref="IQueryable{T}"/> with configured change tracking
/// based on <see cref="EfTrackingOptions"/></returns>
public static IQueryable<T> Apply<T>(
this IQueryable<T> queryable,
EfTrackingOptions? trackingOptions)
where T : class
{
Guard.Against.Null(queryable, nameof(queryable));
if (trackingOptions == null)
{
return queryable.AsTracking();
}
return _configureChangeTracking();
IQueryable<T> _configureChangeTracking()
{
return trackingOptions switch
{
EfTrackingOptions.WithTracking => queryable.AsTracking(),
EfTrackingOptions.AsNoTrackingWithIdentityResolution => queryable.AsNoTrackingWithIdentityResolution(),
_ => queryable.AsNoTracking()
};
} Then I can do this (this snippet is from the equivalent of LinqRepositoryBase
/// <inheritdoc />
protected sealed override IAsyncEnumerable<TProjected> FindManyAsync<TProjected>(
EfTrackingOptions asNoTracking,
IAeonicSpecification<TEntity> specification,
Expression<Func<TEntity, TProjected>> projectExpression,
CancellationToken cancellationToken = default)
{
var queryable = this.Queryable.Apply(asNoTracking)
.Apply(specification)
.ToProjection(projectExpression);
return this.ToListAsync(queryable, cancellationToken);
}
/// <inheritdoc />
protected sealed override IAsyncEnumerable<TEntity> FindManyAsync(
EfTrackingOptions asNoTracking,
CancellationToken cancellationToken = default)
{
var queryable = this.Queryable.Apply(asNoTracking);
return this.ToListAsync(queryable, cancellationToken);
}
/// <inheritdoc />
protected sealed override IAsyncEnumerable<TEntity> FindManyAsync(
EfTrackingOptions asNoTracking,
Expression<Func<TEntity, bool>> whereExpression,
CancellationToken cancellationToken = default)
{
var queryable = this.Queryable.Apply(asNoTracking)
.Apply(whereExpression);
return this.ToListAsync(queryable, cancellationToken);
}
mgernand
If we use AsNoTracking as default for EFCore queries we throw some exceptions because the attaching does not work with StronglyTypedIds somehow. Need to look into it.