From 023e1589a3e26de20bfd8f41ccdf72471363e41f Mon Sep 17 00:00:00 2001
From: damon <zhaorong@outlook.com>
Date: Wed, 17 Jan 2024 22:11:00 +0800
Subject: [PATCH 1/2] Refactoring repository.

---
 .../EfCoreRepository.cs                       | 337 +++++++------
 .../MongoRepository.cs                        | 296 ++++++------
 .../Abstracts/IRepository.cs                  | 443 +++++++++++-------
 Source/Euonia.Repository/Core/Repository.cs   | 124 ++---
 4 files changed, 640 insertions(+), 560 deletions(-)

diff --git a/Source/Euonia.Repository.EfCore/EfCoreRepository.cs b/Source/Euonia.Repository.EfCore/EfCoreRepository.cs
index 100cbc9..362c905 100644
--- a/Source/Euonia.Repository.EfCore/EfCoreRepository.cs
+++ b/Source/Euonia.Repository.EfCore/EfCoreRepository.cs
@@ -1,6 +1,5 @@
 using System.Linq.Expressions;
 using Microsoft.EntityFrameworkCore;
-using Nerosoft.Euonia.Collections;
 using Nerosoft.Euonia.Domain;
 using Nerosoft.Euonia.Linq;
 
@@ -8,183 +7,163 @@ namespace Nerosoft.Euonia.Repository.EfCore;
 
 /// <inheritdoc />
 public class EfCoreRepository<TContext, TEntity, TKey> : Repository<TContext, TEntity, TKey>
-    where TKey : IEquatable<TKey>
-    where TEntity : class, IEntity<TKey>
-    where TContext : DbContext, IRepositoryContext
+	where TKey : IEquatable<TKey>
+	where TEntity : class, IEntity<TKey>
+	where TContext : DbContext, IRepositoryContext
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="EfCoreRepository{TContext, TEntity, TKey}"/> class.
-    /// </summary>
-    /// <param name="provider">The repository context.</param>
-    public EfCoreRepository(IContextProvider provider)
-        : base(provider)
-    {
-    }
-
-    /// <inheritdoc />
-    protected override void Dispose(bool disposing)
-    {
-        //Context?.Dispose();
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Queryable()
-    {
-        var query = Context.Set<TEntity>().AsQueryable();
-        if (Actions.Count > 0)
-        {
-            query = Actions.Aggregate(query, (current, action) => action(current));
-        }
-
-        return query;
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default)
-    {
-        return await Context.FindAsync<TEntity>(key);
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        return await Context.Set<TEntity>().FirstOrDefaultAsync(predicate, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate)
-    {
-        return Queryable().Where(predicate);
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order)
-    {
-        var orderable = new Orderable<TEntity>(Fetch(predicate));
-        order(orderable);
-        return orderable.Queryable;
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order)
-    {
-        var query = Queryable().Where(predicate);
-        query = order(query);
-
-        return query;
-    }
-
-    /// <inheritdoc />
-    public override async Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default)
-    {
-        var pageIndex = page ?? 1;
-        var pageSize = size ?? int.MaxValue;
-
-        var handler = new QueryHandler<TEntity>(Queryable());
-
-        handler.AddCriteria(predicate);
-        var count = handler.GetCount();
-
-        handler.SetPage(pageIndex).SetSize(pageSize);
-
-        handler.SetCollator(order);
-
-        var list = await handler.QueryAsync(async query => await query.ToListAsync(cancellationToken));
-
-        return new PageableCollection<TEntity>(list) { TotalCount = count, PageNumber = pageIndex, PageSize = pageSize };
-    }
-
-    /// <inheritdoc />
-    public override async Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default)
-    {
-        var pageIndex = page ?? 1;
-        var pageSize = size ?? int.MaxValue;
-
-        var handler = new QueryHandler<TEntity>(Queryable());
-
-        handler.AddCriteria(predicate);
-        var count = await handler.GetCountAsync(async query => await query.CountAsync(cancellationToken));
-
-        handler.SetPage(pageIndex).SetSize(pageSize);
-
-        handler.SetCollator(order);
-
-        var list = await handler.QueryAsync(async query => await query.ToListAsync(cancellationToken));
-
-        return new PageableCollection<TEntity>(list) { TotalCount = count, PageNumber = pageIndex, PageSize = pageSize };
-    }
-
-    /// <inheritdoc />
-    public override async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        return await Context.Set<TEntity>().CountAsync(predicate, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        return await Context.Set<TEntity>().LongCountAsync(predicate, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        var entry = await Context.AddAsync(entity, cancellationToken);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-
-        return entry.Entity;
-    }
-
-    /// <inheritdoc />
-    public override async Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        await Context.AddRangeAsync(entities, cancellationToken);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-    }
-
-    /// <inheritdoc />
-    public override async Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        var _ = Context.Update(entity);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-    }
-
-    /// <inheritdoc />
-    public override async Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        Context.UpdateRange(entities);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-    }
-
-    /// <inheritdoc />
-    public override async Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        var _ = Context.Remove(entity);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-    }
-
-    /// <inheritdoc />
-    public override async Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        Context.RemoveRange(entities);
-        if (autoSave)
-        {
-            await SaveChangesAsync(cancellationToken);
-        }
-    }
+	/// <summary>
+	/// Initializes a new instance of the <see cref="EfCoreRepository{TContext, TEntity, TKey}"/> class.
+	/// </summary>
+	/// <param name="provider">The repository context.</param>
+	public EfCoreRepository(IContextProvider provider)
+		: base(provider)
+	{
+	}
+
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing)
+	{
+		//Context?.Dispose();
+	}
+
+	/// <inheritdoc />
+	public override IQueryable<TEntity> Queryable()
+	{
+		var query = Context.Set<TEntity>().AsQueryable();
+		if (Actions.Count > 0)
+		{
+			query = Actions.Aggregate(query, (current, action) => action(current));
+		}
+
+		return query;
+	}
+
+	/// <inheritdoc />
+	public override IQueryable<TEntity> BuildQuery(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle)
+	{
+		ArgumentNullException.ThrowIfNull(predicate);
+		var query = Context.Set<TEntity>().AsQueryable();
+		if (handle != null)
+		{
+			query = handle(query);
+		}
+		return query.Where(predicate);
+	}
+
+	/// <inheritdoc />
+	public override async Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(key);
+		return await Context.FindAsync<TEntity>(key);
+	}
+
+	/// <inheritdoc />
+	public override Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).FirstOrDefaultAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).ToListAsync(cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, int offset, int count, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).Skip(offset).Take(count).ToListAsync(cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).CountAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).LongCountAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).AnyAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return BuildQuery(predicate, handle).AllAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entity);
+		var entry = await Context.AddAsync(entity, cancellationToken);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+
+		return entry.Entity;
+	}
+
+	/// <inheritdoc />
+	public override async Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entities);
+		await Context.AddRangeAsync(entities, cancellationToken);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+	}
+
+	/// <inheritdoc />
+	public override async Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entity);
+		var _ = Context.Update(entity);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+	}
+
+	/// <inheritdoc />
+	public override async Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entities);
+		Context.UpdateRange(entities);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+	}
+
+	/// <inheritdoc />
+	public override async Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entity);
+		var _ = Context.Remove(entity);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+	}
+
+	/// <inheritdoc />
+	public override async Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(entities);
+		Context.RemoveRange(entities);
+		if (autoSave)
+		{
+			await SaveChangesAsync(cancellationToken);
+		}
+	}
 }
\ No newline at end of file
diff --git a/Source/Euonia.Repository.Mongo/MongoRepository.cs b/Source/Euonia.Repository.Mongo/MongoRepository.cs
index 2305c8c..65cf576 100644
--- a/Source/Euonia.Repository.Mongo/MongoRepository.cs
+++ b/Source/Euonia.Repository.Mongo/MongoRepository.cs
@@ -2,7 +2,6 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
 using MongoDB.Driver.Linq;
-using Nerosoft.Euonia.Collections;
 using Nerosoft.Euonia.Domain;
 using Nerosoft.Euonia.Linq;
 
@@ -15,165 +14,140 @@ namespace Nerosoft.Euonia.Repository.Mongo;
 /// <typeparam name="TEntity"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 public class MongoRepository<TContext, TEntity, TKey> : Repository<TContext, TEntity, TKey>
-    where TKey : IEquatable<TKey>
-    where TEntity : class, IEntity<TKey>
-    where TContext : MongoDbContext, IRepositoryContext
+	where TKey : IEquatable<TKey>
+	where TEntity : class, IEntity<TKey>
+	where TContext : MongoDbContext, IRepositoryContext
 {
-    /// <summary>
-    /// Initialize a new instance of <see cref="MongoRepository{TContext, TEntity, TKey}"/> with context.
-    /// </summary>
-    /// <param name="provider"></param>
-    public MongoRepository(IContextProvider provider)
-        : base(provider)
-    {
-    }
-
-    /// <inheritdoc />
-    protected override void Dispose(bool disposing)
-    {
-        // ignore.
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Queryable()
-    {
-        IQueryable<TEntity> query = Context.Collection<TEntity>().AsQueryable();
-        if (Actions.Count > 0)
-        {
-            query = Actions.Aggregate(query, (current, action) => action(current));
-        }
-
-        return query;
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default)
-    {
-        var id = MongoDB.Bson.ObjectId.Parse(key.ToString());
-        return await Context.FindAsync<TEntity>(id, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        var options = new FindOptions<TEntity> { Limit = 1 };
-        var query = await Context.FindAsync(predicate, options, cancellationToken);
-        return await query.FirstOrDefaultAsync(cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate)
-    {
-        return System.Linq.Queryable.Where(Context.Collection<TEntity>().AsQueryable(), predicate);
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order)
-    {
-        var orderable = new Orderable<TEntity>(Fetch(predicate));
-        order(orderable);
-        return orderable.Queryable;
-    }
-
-    /// <inheritdoc />
-    public override IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order)
-    {
-        var query = Queryable().Where(predicate);
-        query = order(query);
-        return query;
-    }
-
-    /// <inheritdoc />
-    public override async Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default)
-    {
-        var pageIndex = page ?? 1;
-        var pageSize = size ?? int.MaxValue;
-
-        var handler = new QueryHandler<TEntity>(Queryable());
-
-        handler.AddCriteria(predicate);
-        var count = handler.GetCount();
-
-        handler.SetPage(pageIndex).SetSize(pageSize);
-
-        handler.SetCollator(order);
-
-        var list = await handler.QueryAsync(async query => await ((IMongoQueryable<TEntity>)query).ToListAsync(cancellationToken));
-
-        return new PageableCollection<TEntity>(list) { TotalCount = count, PageNumber = pageIndex, PageSize = pageSize };
-    }
-
-    /// <inheritdoc />
-    public override async Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default)
-    {
-        var pageIndex = page ?? 1;
-        var pageSize = size ?? int.MaxValue;
-
-        var handler = new QueryHandler<TEntity>(Queryable());
-
-        handler.AddCriteria(predicate);
-        var count = await handler.GetCountAsync(async query => await ((IMongoQueryable<TEntity>)query).CountAsync(cancellationToken));
-
-        handler.SetPage(pageIndex).SetSize(pageSize);
-
-        handler.SetCollator(order);
-
-        var list = await handler.QueryAsync(async query => await ((IMongoQueryable<TEntity>)query).ToListAsync(cancellationToken));
-
-        return new PageableCollection<TEntity>(list) { TotalCount = count, PageNumber = pageIndex, PageSize = pageSize };
-    }
-
-    /// <inheritdoc />
-    public override async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        var result = await Context.Collection<TEntity>().CountDocumentsAsync(predicate, null, cancellationToken);
-        return (int)result;
-    }
-
-    /// <inheritdoc />
-    public override async Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
-    {
-        var result = await Context.Collection<TEntity>().CountDocumentsAsync(predicate, null, cancellationToken);
-        return result;
-    }
-
-    /// <inheritdoc />
-    public override async Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        var document = await Context.InsertAsync(entity, cancellationToken);
-        //var id = document["_id"];
-        var result = BsonSerializer.Deserialize<TEntity>(document);
-        return result;
-    }
-
-    /// <inheritdoc />
-    public override async Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        await Context.InsertAsync(entities, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        await Context.UpdateAsync(MongoDB.Bson.ObjectId.Parse(entity.Id.ToString()), entity, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        await Context.UpdateAsync(entities, t => t.Id, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        await Context.DeleteAsync<TEntity>(MongoDB.Bson.ObjectId.Parse(entity.Id.ToString()), cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public override async Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
-    {
-        var keys = entities.Select(t => t.Id);
-        await Context.DeleteAsync<TEntity>(t => keys.Contains(t.Id), cancellationToken);
-    }
+	/// <summary>
+	/// Initialize a new instance of <see cref="MongoRepository{TContext, TEntity, TKey}"/> with context.
+	/// </summary>
+	/// <param name="provider"></param>
+	public MongoRepository(IContextProvider provider)
+		: base(provider)
+	{
+	}
+
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing)
+	{
+		// ignore.
+	}
+
+	/// <inheritdoc />
+	public override IQueryable<TEntity> Queryable()
+	{
+		IQueryable<TEntity> query = Context.Collection<TEntity>().AsQueryable();
+		if (Actions.Count > 0)
+		{
+			query = Actions.Aggregate(query, (current, action) => action(current));
+		}
+
+		return query;
+	}
+
+	/// <inheritdoc />
+	public override IQueryable<TEntity> BuildQuery(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle)
+	{
+		ArgumentNullException.ThrowIfNull(predicate);
+		IQueryable<TEntity> query = Context.Collection<TEntity>().AsQueryable();
+		if (handle != null)
+		{
+			query = handle(query);
+		}
+		return query.Where(predicate);
+	}
+
+	/// <inheritdoc />
+	public override async Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default)
+	{
+		var id = MongoDB.Bson.ObjectId.Parse(key.ToString());
+		return await Context.FindAsync<TEntity>(id, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(predicate);
+		var options = new FindOptions<TEntity> { Limit = 1 };
+		var query = await Context.FindAsync(predicate, options, cancellationToken);
+		return await query.FirstOrDefaultAsync(cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return ((IMongoQueryable<TEntity>)BuildQuery(predicate, handle)).ToListAsync(cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, int offset, int count, CancellationToken cancellationToken = default)
+	{
+		return ((IMongoQueryable<TEntity>)BuildQuery(predicate, handle)).Skip(offset).Take(count).ToListAsync(cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		var result = await Context.Collection<TEntity>().CountDocumentsAsync(predicate, null, cancellationToken);
+		return (int)result;
+	}
+
+	/// <inheritdoc />
+	public override async Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		var result = await Context.Collection<TEntity>().CountDocumentsAsync(predicate, null, cancellationToken);
+		return result;
+	}
+
+	/// <inheritdoc />
+	public override Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return ((IMongoQueryable<TEntity>)BuildQuery(predicate, handle)).AnyAsync(predicate, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		return AnyAsync(predicate, handle, cancellationToken).ContinueWith(task => !task.Result, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		var document = await Context.InsertAsync(entity, cancellationToken);
+		//var id = document["_id"];
+		var result = BsonSerializer.Deserialize<TEntity>(document);
+		return result;
+	}
+
+	/// <inheritdoc />
+	public override async Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		await Context.InsertAsync(entities, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		await Context.UpdateAsync(MongoDB.Bson.ObjectId.Parse(entity.Id.ToString()), entity, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		await Context.UpdateAsync(entities, t => t.Id, cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		await Context.DeleteAsync<TEntity>(MongoDB.Bson.ObjectId.Parse(entity.Id.ToString()), cancellationToken);
+	}
+
+	/// <inheritdoc />
+	public override async Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default)
+	{
+		var keys = entities.Select(t => t.Id);
+		await Context.DeleteAsync<TEntity>(t => keys.Contains(t.Id), cancellationToken);
+	}
 }
\ No newline at end of file
diff --git a/Source/Euonia.Repository/Abstracts/IRepository.cs b/Source/Euonia.Repository/Abstracts/IRepository.cs
index cecf1bb..cbfc201 100644
--- a/Source/Euonia.Repository/Abstracts/IRepository.cs
+++ b/Source/Euonia.Repository/Abstracts/IRepository.cs
@@ -10,148 +10,231 @@ namespace Nerosoft.Euonia.Repository;
 /// </summary>
 /// <typeparam name="TEntity"></typeparam>
 public interface IRepository<TEntity> : IDisposable
-    where TEntity : class
+	where TEntity : class
 {
-    /// <summary>
-    /// Gets the actions to be executed before query.
-    /// </summary>
-    List<Func<IQueryable<TEntity>, IQueryable<TEntity>>> Actions { get; }
-
-    /// <summary>
-    /// Queryable this instance.
-    /// </summary>
-    /// <returns>The all.</returns>
-    IQueryable<TEntity> Queryable();
-
-    /// <summary>
-    /// Gets an entity with the given primary key value asynchronously.
-    /// </summary>
-    /// <param name="predicate"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Gets entities matches the specified predicate.
-    /// </summary>
-    /// <returns>The fetch.</returns>
-    /// <param name="predicate">Predicate.</param>
-    IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate);
-
-    /// <summary>
-    /// Gets entities matches the specified predicate.
-    /// </summary>
-    /// <returns>The fetch.</returns>
-    /// <param name="predicate">Predicate.</param>
-    /// <param name="order">Order.</param>
-    IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order);
-
-    /// <summary>
-    /// Gets entities matches the specified predicate.
-    /// </summary>
-    /// <returns>The fetch.</returns>
-    /// <param name="predicate">Predicate.</param>
-    /// <param name="order">Order.</param>
-    IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order);
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="predicate"></param>
-    /// <param name="order"></param>
-    /// <param name="page"></param>
-    /// <param name="size"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="predicate"></param>
-    /// <param name="order"></param>
-    /// <param name="page"></param>
-    /// <param name="size"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="predicate"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="predicate"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Insert a new entity asynchronously.
-    /// </summary>
-    /// <param name="entity"></param>
-    /// <param name="autoSave"></param>
-    /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
-    /// <returns></returns>
-    Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Insert multiple new entities asynchronously.
-    /// </summary>
-    /// <param name="entities"></param>
-    /// <param name="autoSave"></param>
-    /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
-    /// <returns></returns>
-    Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Update an exists entity asynchronously.
-    /// </summary>
-    /// <param name="entity">The entity.</param>
-    /// <param name="autoSave">A <see cref="bool"/> value indicate that whether the <see cref="SaveChangesAsync" /> will called automatically.</param>
-    /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
-    /// <returns></returns>
-    Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Update multiple exists entities asynchronously.
-    /// </summary>
-    /// <param name="entities"></param>
-    /// <param name="autoSave">A <see cref="bool"/> value indicate that whether the <see cref="SaveChangesAsync" /> will called automatically.</param>
-    /// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
-    /// <returns></returns>
-    Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// DeleteAsync the specified entity.
-    /// </summary>
-    /// <param name="entity"></param>
-    /// <param name="autoSave"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// DeleteAsync the specified entities.
-    /// </summary>
-    /// <param name="entities"></param>
-    /// <param name="autoSave"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Saves the changes async.
-    /// </summary>
-    /// <returns>The changes async.</returns>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
+	/// <summary>
+	/// Gets the actions to be executed before query.
+	/// </summary>
+	List<Func<IQueryable<TEntity>, IQueryable<TEntity>>> Actions { get; }
+
+	/// <summary>
+	/// Queryable this instance.
+	/// </summary>
+	/// <returns>The all.</returns>
+	IQueryable<TEntity> Queryable();
+
+	/// <summary>
+	/// Builds query.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <returns></returns>
+	IQueryable<TEntity> BuildQuery(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle);
+
+	/// <summary>
+	/// Gets single element that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return GetAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Gets single element that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Finds elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return FindAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Finds elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Finds elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="offset"></param>
+	/// <param name="count"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, int offset, int count, CancellationToken cancellationToken = default)
+	{
+		return FindAsync(predicate, null, offset, count, cancellationToken);
+	}
+
+	/// <summary>
+	/// Finds elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="offset"></param>
+	/// <param name="count"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, int offset, int count, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Gets number of elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return CountAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Gets number of elements in a sequence that satisfy a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Gets number of elements in a sequence that satisfy a condition asynchronously and returns an <see cref="long"/> value.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return LongCountAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Gets number of elements in a sequence that satisfy a condition asynchronously and returns an <see cref="long"/> value.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Determines whether any element of a sequence satisfies a condition asynchronously.
+	/// </summary>
+	/// <param name="predicate">The condition.</param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return AnyAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Asynchronously determines whether any element of a sequence satisfies a condition.
+	/// </summary>
+	/// <param name="predicate">The condition.</param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Asynchronously determines whether all the elements of a sequence satisfy a condition.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+	{
+		return AllAsync(predicate, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Asynchronously determines whether all the elements of a sequence satisfy a condition.
+	/// </summary>
+	/// <param name="predicate"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Insert a new entity asynchronously.
+	/// </summary>
+	/// <param name="entity"></param>
+	/// <param name="autoSave"></param>
+	/// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+	/// <returns></returns>
+	Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Insert multiple new entities asynchronously.
+	/// </summary>
+	/// <param name="entities"></param>
+	/// <param name="autoSave"></param>
+	/// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+	/// <returns></returns>
+	Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Update an exists entity asynchronously.
+	/// </summary>
+	/// <param name="entity">The entity.</param>
+	/// <param name="autoSave">A <see cref="bool"/> value indicate that whether the <see cref="SaveChangesAsync" /> will called automatically.</param>
+	/// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+	/// <returns></returns>
+	Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Update multiple exists entities asynchronously.
+	/// </summary>
+	/// <param name="entities"></param>
+	/// <param name="autoSave">A <see cref="bool"/> value indicate that whether the <see cref="SaveChangesAsync" /> will called automatically.</param>
+	/// <param name="cancellationToken">A <see cref="CancellationToken" /> to observe while waiting for the task to complete.</param>
+	/// <returns></returns>
+	Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// DeleteAsync the specified entity.
+	/// </summary>
+	/// <param name="entity"></param>
+	/// <param name="autoSave"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// DeleteAsync the specified entities.
+	/// </summary>
+	/// <param name="entities"></param>
+	/// <param name="autoSave"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+
+	/// <summary>
+	/// Saves the changes async.
+	/// </summary>
+	/// <returns>The changes async.</returns>
+	/// <param name="cancellationToken">Cancellation token.</param>
+	Task<int> SaveChangesAsync(CancellationToken cancellationToken = default);
 }
 
 /// <summary>
@@ -160,16 +243,60 @@ public interface IRepository<TEntity> : IDisposable
 /// <typeparam name="TEntity"></typeparam>
 /// <typeparam name="TKey"></typeparam>
 public interface IRepository<TEntity, in TKey> : IRepository<TEntity>
-    where TKey : IEquatable<TKey>
-    where TEntity : class, IEntity<TKey>
+	where TKey : IEquatable<TKey>
+	where TEntity : class, IEntity<TKey>
 {
-    /// <summary>
-    /// Gets an entity with the given primary key value asynchronously.
-    /// </summary>
-    /// <param name="key">The key of entity.</param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default);
+	/// <summary>
+	/// Gets an entity with the given primary key value asynchronously.
+	/// </summary>
+	/// <param name="key">The key of entity.</param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default)
+	{
+		return GetAsync(key, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Gets an entity with the given primary key value asynchronously.
+	/// </summary>
+	/// <param name="key"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<TEntity> GetAsync(TKey key, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(key);
+		return GetAsync(PredicateBuilder.PropertyEqual<TEntity, TKey>(nameof(IEntity<TKey>.Id), key), handle, cancellationToken);
+	}
+
+	/// <summary>
+	/// Finds elemets in a sequence with the given primary key values asynchronously.
+	/// </summary>
+	/// <param name="keys"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(IEnumerable<TKey> keys, CancellationToken cancellationToken = default)
+	{
+		return FindAsync(keys, null, cancellationToken);
+	}
+
+	/// <summary>
+	/// Finds elemets in a sequence with the given primary key values asynchronously.
+	/// </summary>
+	/// <param name="keys"></param>
+	/// <param name="handle"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	Task<List<TEntity>> FindAsync(IEnumerable<TKey> keys, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default)
+	{
+		ArgumentNullException.ThrowIfNull(keys);
+		if (!keys.Any())
+		{
+			return Task.FromResult(new List<TEntity>());
+		}
+		return FindAsync(PredicateBuilder.PropertyInRange<TEntity, TKey>(nameof(IEntity<TKey>.Id), keys.ToArray()), handle, cancellationToken);
+	}
 }
 
 /// <summary>
@@ -179,13 +306,13 @@ public interface IRepository<TEntity, in TKey> : IRepository<TEntity>
 /// <typeparam name="TKey">The type of entity identifier.</typeparam>
 /// <typeparam name="TContext">The type of context.</typeparam>
 public interface IRepository<out TContext, TEntity, in TKey> : IRepository<TEntity, TKey>
-    where TKey : IEquatable<TKey>
-    where TEntity : class, IEntity<TKey>
-    where TContext : class, IRepositoryContext
+	where TKey : IEquatable<TKey>
+	where TEntity : class, IEntity<TKey>
+	where TContext : class, IRepositoryContext
 {
-    /// <summary>
-    /// Gets the context.
-    /// </summary>
-    /// <value>The context.</value>
-    TContext Context { get; }
+	/// <summary>
+	/// Gets the context.
+	/// </summary>
+	/// <value>The context.</value>
+	TContext Context { get; }
 }
\ No newline at end of file
diff --git a/Source/Euonia.Repository/Core/Repository.cs b/Source/Euonia.Repository/Core/Repository.cs
index 235a073..0506f0a 100644
--- a/Source/Euonia.Repository/Core/Repository.cs
+++ b/Source/Euonia.Repository/Core/Repository.cs
@@ -12,87 +12,87 @@ namespace Nerosoft.Euonia.Repository;
 /// <typeparam name="TKey">The type of the entity key.</typeparam>
 /// <typeparam name="TContext"></typeparam>
 public abstract class Repository<TContext, TEntity, TKey> : DisposableObject, IRepository<TContext, TEntity, TKey>
-    where TKey : IEquatable<TKey>
-    where TEntity : class, IEntity<TKey>
-    where TContext : class, IRepositoryContext
+	where TKey : IEquatable<TKey>
+	where TEntity : class, IEntity<TKey>
+	where TContext : class, IRepositoryContext
 {
-    private readonly IContextProvider _provider;
+	private readonly IContextProvider _provider;
 
-    /// <summary>
-    /// Initialize a new instance of <see cref="Repository{TContext, TEntity, TKey}"/> with context.
-    /// </summary>
-    /// <param name="provider"></param>
-    protected Repository(IContextProvider provider)
-    {
-        _provider = provider;
-    }
+	/// <summary>
+	/// Initialize a new instance of <see cref="Repository{TContext, TEntity, TKey}"/> with context.
+	/// </summary>
+	/// <param name="provider"></param>
+	protected Repository(IContextProvider provider)
+	{
+		_provider = provider;
+	}
 
-    /// <summary>
-    /// Gets the data persistent context.
-    /// </summary>
-    public TContext Context => _provider.GetContext<TContext>();
+	/// <summary>
+	/// Gets the data persistent context.
+	/// </summary>
+	public TContext Context => _provider.GetContext<TContext>();
 
-    /// <inheritdoc />
-    public List<Func<IQueryable<TEntity>, IQueryable<TEntity>>> Actions { get; } = new();
+	/// <inheritdoc />
+	public List<Func<IQueryable<TEntity>, IQueryable<TEntity>>> Actions { get; } = new();
 
-    /// <summary>
-    /// Gets all entities.
-    /// </summary>
-    /// <returns></returns>
-    public abstract IQueryable<TEntity> Queryable();
+	/// <summary>
+	/// Gets all entities.
+	/// </summary>
+	/// <returns></returns>
+	public abstract IQueryable<TEntity> Queryable();
 
-    /// <inherited/>
-    public abstract Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default);
+	/// <inheritdoc />
+	public abstract IQueryable<TEntity> BuildQuery(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle);
 
-    /// <inherited/>
-    public abstract Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task<TEntity> GetAsync(TKey key, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate);
+	/// <inherited/>
+	public abstract Task<TEntity> GetAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order);
+	/// <inherited/>
+	public abstract Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract IQueryable<TEntity> Fetch(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order);
+	/// <inherited/>
+	public abstract Task<List<TEntity>> FindAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, int offset, int count, CancellationToken cancellationToken = default);
 
-    /// <inheritdoc />
-    public abstract Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Action<Orderable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default);
+	/// <inheritdoc />
+	public abstract Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inheritdoc />
-    public abstract Task<PageableCollection<TEntity>> FetchAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> order, int? page, int? size, CancellationToken cancellationToken = default);
+	/// <inheritdoc />
+	public abstract Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inheritdoc />
-    public abstract Task<int> CountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+	/// <inheritdoc />
+	public abstract Task<bool> AnyAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inheritdoc />
-    public abstract Task<long> LongCountAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
+	/// <inheritdoc/>
+	public abstract Task<bool> AllAsync(Expression<Func<TEntity, bool>> predicate, Func<IQueryable<TEntity>, IQueryable<TEntity>> handle, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task<TEntity> InsertAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task InsertAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task UpdateAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task UpdateAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task DeleteAsync(TEntity entity, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <inherited/>
-    public abstract Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
+	/// <inherited/>
+	public abstract Task DeleteAsync(IEnumerable<TEntity> entities, bool autoSave = true, CancellationToken cancellationToken = default);
 
-    /// <summary>
-    /// Commit changes asynchronously.
-    /// </summary>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns></returns>
-    public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
-    {
-        return await Context.SaveChangesAsync(cancellationToken);
-    }
+	/// <summary>
+	/// Commit changes asynchronously.
+	/// </summary>
+	/// <param name="cancellationToken">The cancellation token.</param>
+	/// <returns></returns>
+	public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
+	{
+		return await Context.SaveChangesAsync(cancellationToken);
+	}
 }
\ No newline at end of file

From 9903fa9ae169d9ee610f257f4055eb75afea5643 Mon Sep 17 00:00:00 2001
From: damon <zhaorong@outlook.com>
Date: Wed, 17 Jan 2024 22:11:40 +0800
Subject: [PATCH 2/2] Upgrade version to 8.1.19

---
 project.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.props b/project.props
index 3189a41..54d7d86 100644
--- a/project.props
+++ b/project.props
@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <Version>8.1.18</Version>
+        <Version>8.1.19</Version>
         <Authors>damon</Authors>
         <Company>Nerosoft Ltd.</Company>
         <Product>Euonia</Product>