efcor增加nolock查询扩展

Masuit.Tools.Abstractions/Masuit.Tools.Abstractions.csproj

@@ -3,7 +3,7 @@
         <TargetFrameworks>netstandard2.0;netstandard2.1;net461;net5;net6;net7</TargetFrameworks>
         <LangVersion>latest</LangVersion>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-        <Version>2.5.9.6</Version>
+        <Version>2.5.9.7</Version>
         <Authors>懒得勤快</Authors>
         <Description>Masuit.Tools基础公共库，包含一些常用的操作类，大都是静态类，加密解密，反射操作，Excel简单导出，权重随机筛选算法，分布式短id，表达式树，linq扩展，文件压缩，多线程下载和FTP客户端，硬件信息，字符串扩展方法，日期时间扩展操作，中国农历，大文件拷贝，图像裁剪，验证码，断点续传，集合扩展等常用封装。</Description>
         <Copyright>懒得勤快，长空X</Copyright>

Masuit.Tools.Abstractions/Systems/ConcurrentHashSet.cs

@@ -99,6 +99,22 @@ public void Add(T item)
         }
     }
 
+    public bool TryAdd(T item)
+    {
+        _lock.EnterWriteLock();
+        try
+        {
+            return _hashSet.Add(item);
+        }
+        finally
+        {
+            if (_lock.IsWriteLockHeld)
+            {
+                _lock.ExitWriteLock();
+            }
+        }
+    }
+
     public void UnionWith(IEnumerable<T> other)
     {
         _lock.EnterWriteLock();

Masuit.Tools.AspNetCore/Extensions/QueryWithNoLockDbCommandInterceptor.cs

@@ -0,0 +1,78 @@
+using System.Data.Common;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+
+namespace Masuit.Tools.Core;
+
+public class QueryWithNoLockDbCommandInterceptor : DbCommandInterceptor
+{
+    private static readonly Regex TableAliasRegex = new Regex(@"(?<tableAlias>AS \[[a-zA-Z]\w*\](?! WITH \(NOLOCK\)))", RegexOptions.Multiline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+    public override InterceptionResult<object> ScalarExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<object> result)
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return base.ScalarExecuting(command, eventData, result);
+    }
+
+#if NETCOREAPP3_1
+
+    public override Task<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<object> result,
+CancellationToken cancellationToken = new CancellationToken())
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return base.ScalarExecutingAsync(command, eventData, result, cancellationToken);
+    }
+
+#else
+    public override ValueTask<InterceptionResult<object>> ScalarExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<object> result,
+CancellationToken cancellationToken = new CancellationToken())
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return base.ScalarExecutingAsync(command, eventData, result, cancellationToken);
+    }
+#endif
+
+    public override InterceptionResult<DbDataReader> ReaderExecuting(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return result;
+    }
+
+#if NETCOREAPP3_1
+
+    public override Task<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result,
+CancellationToken cancellationToken = new CancellationToken())
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return base.ReaderExecutingAsync(command, eventData, result, cancellationToken);
+    }
+
+#else
+    public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result,
+CancellationToken cancellationToken = new CancellationToken())
+    {
+        command.CommandText = TableAliasRegex.Replace(
+            command.CommandText,
+            "${tableAlias} WITH (NOLOCK)"
+        );
+        return base.ReaderExecutingAsync(command, eventData, result, cancellationToken);
+    }
+#endif
+}

Masuit.Tools.AspNetCore/Masuit.Tools.AspNetCore.csproj

@@ -17,7 +17,7 @@
         <Product>Masuit.Tools.AspNetCore</Product>
         <PackageId>Masuit.Tools.AspNetCore</PackageId>
         <LangVersion>latest</LangVersion>
-        <Version>1.1.9.6</Version>
+        <Version>1.1.9.7</Version>
         <RepositoryType></RepositoryType>
         <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
         <FileVersion>1.1.9</FileVersion>
@@ -45,5 +45,17 @@
     <ItemGroup>
         <ProjectReference Include="..\Masuit.Tools.Core\Masuit.Tools.Core.csproj" />
     </ItemGroup>
-
+
+    <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1'">
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="3.1.9" />
+    </ItemGroup>
+    <ItemGroup Condition=" '$(TargetFramework)' == 'net5'">
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="5.0.11" />
+    </ItemGroup>
+    <ItemGroup Condition=" '$(TargetFramework)' == 'net6'">
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="6.0.10" />
+    </ItemGroup>
+    <ItemGroup Condition=" '$(TargetFramework)' == 'net7'">
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="7.0.5" />
+    </ItemGroup>
 </Project>

Masuit.Tools.Core/Database/ChangeEntry.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Masuit.Tools.Core;
+
+public class ChangeEntry
+{
+    /// <summary>
+    /// 所属实体
+    /// </summary>
+    public object Entity { get; set; }
+
+    /// <summary>
+    /// 实体类型
+    /// </summary>
+    public Type EntityType { get; set; }
+
+    /// <summary>
+    /// 变更类型
+    /// </summary>
+    public EntityState EntityState { get; set; }
+
+    /// <summary>
+    /// 字段变更信息
+    /// </summary>
+    public List<ChangePropertyInfo> ChangeProperties { get; set; }
+}

Masuit.Tools.Core/Database/ChangePropertyInfo.cs

@@ -0,0 +1,31 @@
+using System.Reflection;
+
+namespace Masuit.Tools.Core;
+
+public class ChangePropertyInfo
+{
+    /// <summary>
+    /// 属性
+    /// </summary>
+    public PropertyInfo PropertyInfo { get; set; }
+
+    /// <summary>
+    /// 原始值
+    /// </summary>
+    public object OriginalValue { get; set; }
+
+    /// <summary>
+    /// 新值
+    /// </summary>
+    public object CurrentValue { get; set; }
+
+    /// <summary>
+    /// 是否是主键
+    /// </summary>
+    public bool IsPrimaryKey { get; set; }
+
+    /// <summary>
+    /// 是否是外键
+    /// </summary>
+    public bool IsForeignKey { get; set; }
+}

Masuit.Tools.Core/Database/DbContextExt.cs

@@ -4,8 +4,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Reflection;
 using System.Text;
+using System.Transactions;
 
 namespace Masuit.Tools.Core
 {
@@ -195,8 +195,7 @@ public static IEnumerable<ChangeEntry> GetAllChanges(this DbContext db)
             return GetChanges(db).Union(GetAdded(db)).Union(GetRemoved(db));
         }
 
-        public static IQueryable<TEntity> IncludeRecursive<TEntity>(this IQueryable<TEntity> source,
-          int levelIndex, Expression<Func<TEntity, ICollection<TEntity>>> expression) where TEntity : class
+        public static IQueryable<TEntity> IncludeRecursive<TEntity>(this IQueryable<TEntity> source, int levelIndex, Expression<Func<TEntity, ICollection<TEntity>>> expression) where TEntity : class
         {
             if (levelIndex < 0)
                 throw new ArgumentOutOfRangeException(nameof(levelIndex));
@@ -209,58 +208,118 @@ public static IQueryable<TEntity> IncludeRecursive<TEntity>(this IQueryable<TEnt
                     sb.Append(Type.Delimiter);
                 sb.Append(property);
             }
+
             return source.Include(sb.ToString());
         }
-    }
 
-    public class ChangePropertyInfo
-    {
-        /// <summary>
-        /// 属性
-        /// </summary>
-        public PropertyInfo PropertyInfo { get; set; }
+        public static async Task<List<T>> ToListWithNoLockAsync<T>(this IQueryable<T> query, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.ToListAsync(cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-        /// <summary>
-        /// 原始值
-        /// </summary>
-        public object OriginalValue { get; set; }
+        public static async Task<int> CountWithNoLockAsync<T>(this IQueryable<T> query, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.CountAsync(cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-        /// <summary>
-        /// 新值
-        /// </summary>
-        public object CurrentValue { get; set; }
+        public static async Task<int> CountWithNoLockAsync<T>(this IQueryable<T> query, Expression<Func<T, bool>> where, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.CountAsync(where, cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-        /// <summary>
-        /// 是否是主键
-        /// </summary>
-        public bool IsPrimaryKey { get; set; }
+        public static async Task<bool> AnyWithNoLockAsync<T>(this IQueryable<T> query, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.AnyAsync(cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-        /// <summary>
-        /// 是否是外键
-        /// </summary>
-        public bool IsForeignKey { get; set; }
-    }
+        public static async Task<bool> AnyWithNoLockAsync<T>(this IQueryable<T> query, Expression<Func<T, bool>> where, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.AnyAsync(where, cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-    public class ChangeEntry
-    {
-        /// <summary>
-        /// 所属实体
-        /// </summary>
-        public object Entity { get; set; }
+        public static async Task<bool> AllWithNoLockAsync<T>(this IQueryable<T> query, Expression<Func<T, bool>> where, CancellationToken cancellationToken = default)
+        {
+            using var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
+            {
+                IsolationLevel = IsolationLevel.ReadUncommitted
+            }, TransactionScopeAsyncFlowOption.Enabled);
+            var result = await query.AllAsync(where, cancellationToken);
+            scope.Complete();
+            return result;
+        }
 
-        /// <summary>
-        /// 实体类型
-        /// </summary>
-        public Type EntityType { get; set; }
+        public static T NoLock<T, TDbContext>(this TDbContext dbContext, Func<TDbContext, T> func) where TDbContext : DbContext
+        {
+            var strategy = dbContext.Database.CreateExecutionStrategy();
+            return strategy.Execute(() =>
+            {
+                var transactionOptions = new TransactionOptions
+                {
+                    IsolationLevel = IsolationLevel.ReadUncommitted
+                };
+                using var scope = new TransactionScope(TransactionScopeOption.Required, transactionOptions);
+                var result = func(dbContext);
+                scope.Complete();
+                return result;
+            });
+        }
 
-        /// <summary>
-        /// 变更类型
-        /// </summary>
-        public EntityState EntityState { get; set; }
+        public static Task<T> NoLock<T, TDbContext>(this TDbContext dbContext, Func<TDbContext, Task<T>> func) where TDbContext : DbContext
+        {
+            var strategy = dbContext.Database.CreateExecutionStrategy();
+            return strategy.ExecuteAsync(async () =>
+            {
+                var transactionOptions = new TransactionOptions
+                {
+                    IsolationLevel = IsolationLevel.ReadUncommitted
+                };
+                using var scope = new TransactionScope(TransactionScopeOption.Required, transactionOptions);
+                var result = await func(dbContext);
+                scope.Complete();
+                return result;
+            });
+        }
 
-        /// <summary>
-        /// 字段变更信息
-        /// </summary>
-        public List<ChangePropertyInfo> ChangeProperties { get; set; }
+        public static T ExecutionStrategy<T, TDbContext>(this TDbContext dbContext, Func<TDbContext, T> func) where TDbContext : DbContext
+        {
+            var strategy = dbContext.Database.CreateExecutionStrategy();
+            return strategy.Execute(() => func(dbContext));
+        }
+
+        public static Task<T> ExecutionStrategy<T, TDbContext>(this TDbContext dbContext, Func<TDbContext, Task<T>> func) where TDbContext : DbContext
+        {
+            var strategy = dbContext.Database.CreateExecutionStrategy();
+            return strategy.ExecuteAsync(() => func(dbContext));
+        }
     }
 }

Masuit.Tools.Core/Masuit.Tools.Core.csproj

@@ -6,7 +6,7 @@
 官网教程：https://ldqk.org/55
 github：https://github.com/ldqk/Masuit.Tools
         </Description>
-        <Version>2.5.9.6</Version>
+        <Version>2.5.9.7</Version>
         <Copyright>Copyright © 懒得勤快</Copyright>
         <PackageProjectUrl>https://github.com/ldqk/Masuit.Tools</PackageProjectUrl>
         <PackageTags>Masuit.Tools,工具库,Utility,Crypt,Extensions</PackageTags>

Masuit.Tools.Net45/package.nuspec

@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>Masuit.Tools.Net45</id>
-    <version>2.5.9.6</version>
+    <version>2.5.9.7</version>
     <title>Masuit.Tools</title>
     <authors>懒得勤快</authors>
     <owners>masuit.com</owners>