Backport interceptors to v2 (#271)

* Added possibility to define default interceptors for Linq2Db. (#259)

* Added possibility to define default interceptors for Linq2Db.

* CR fixes

* changed the way of Linq2Db Interceptors registration. Made it possible to use interceptors registered for EF core also.

* improved existing interceptors checking logic. Naming changes inside interceptor tests.

* cr fix: removed duplicated interceptors check

* cr fixes

* Update Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.ContextExtensions.cs

Co-authored-by: Svyatoslav Danyliv <sdanyliv@gmail.com>

* Update Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.ContextExtensions.cs

Co-authored-by: Svyatoslav Danyliv <sdanyliv@gmail.com>

* cosmetics

* Make traversing EF core interceptors configurable and disabled by default.

* Update Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.cs

Co-authored-by: Svyatoslav Danyliv <sdanyliv@gmail.com>

* Update Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.ContextExtensions.cs

Co-authored-by: Svyatoslav Danyliv <sdanyliv@gmail.com>

* changed the name of method for using ef core registered interceptors to UseEfCoreRegisteredInterceptorsIfPossible.

* removed UseEfCoreRegisteredInterceptorsIfPossible support and added possibility to create extension having same functionality.

Added sample implementation of such extension method in tests.

* updated README.md

* cosmetic naming change

Co-authored-by: Svyatoslav Danyliv <sdanyliv@gmail.com>
(cherry picked from commit df56f7f)
(cherry picked from commit 5176487)

* v3 changes

(cherry picked from commit 7a83d51)

* remove non-existing efcore interceptors support

Co-authored-by: Przemysław Łukawski <przemyslaw.luk@gmail.com>

Author: MaceWindu

README.md

@@ -39,6 +39,17 @@ LinqToDBForEFTools.Initialize();
 
 After that you can just call DbContext and IQueryable extension methods, provided by `LINQ To DB`.
 
+You can also register additional options (like interceptors) for LinqToDB during EF context registration, here is an example:
+
+```cs
+var optionsBuilder = new DbContextOptionsBuilder<MyDbContext>();
+optionsBuilder.UseSqlite();
+optionsBuilder.UseLinqToDb(builder => 
+{
+    builder.AddInterceptor(new MyCommandInterceptor());
+});
+```
+
 There are many extensions for CRUD Operations missing in vanilla EF ([watch our video](https://www.youtube.com/watch?v=m--oX73EGeQ)):
 
 ```cs

Source/LinqToDB.EntityFrameworkCore/Internal/LinqToDBOptionsExtension.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace LinqToDB.EntityFrameworkCore.Internal
+{
+	using Interceptors;
+
+	/// <summary>
+	/// Model containing LinqToDB related context options
+	/// </summary>
+	public class LinqToDBOptionsExtension : IDbContextOptionsExtension
+	{
+		private string? _logFragment;
+
+		private IList<IInterceptor>? _interceptors;
+
+		/// <summary>
+		/// List of registered LinqToDB interceptors
+		/// </summary>
+		public virtual IList<IInterceptor> Interceptors => _interceptors ??= new List<IInterceptor>();
+
+		/// <inheritdoc cref="IDbContextOptionsExtension.LogFragment"/>
+		public string LogFragment
+		{
+			get
+			{
+				if (_logFragment == null)
+				{
+					string logFragment = string.Empty;
+
+					if (_interceptors?.Count > 0)
+					{
+						_logFragment = $"Interceptors count: {_interceptors.Count}";
+					}
+					else
+					{
+						_logFragment = string.Empty;
+					}
+				}
+
+				return _logFragment;
+			}
+		}
+
+		/// <summary>
+		/// .ctor
+		/// </summary>
+		public LinqToDBOptionsExtension()
+		{
+		}
+
+		/// <summary>
+		/// .ctor
+		/// </summary>
+		/// <param name="copyFrom"></param>
+		protected LinqToDBOptionsExtension(LinqToDBOptionsExtension copyFrom)
+		{
+			_interceptors = copyFrom._interceptors;
+		}
+
+		/// <inheritdoc cref="IDbContextOptionsExtension.ApplyServices(IServiceCollection)"/>
+		public bool ApplyServices(IServiceCollection services) => false;
+
+		/// <summary>
+		/// Gives the extension a chance to validate that all options in the extension are
+		/// valid. Most extensions do not have invalid combinations and so this will be a
+		/// no-op. If options are invalid, then an exception should be thrown.
+		/// </summary>
+		/// <param name="options"></param>
+		public void Validate(IDbContextOptions options)
+		{
+		}
+
+		/// <inheritdoc cref="IDbContextOptionsExtension.GetServiceProviderHashCode()"/>
+		public long GetServiceProviderHashCode() => 0;
+	}
+}

Source/LinqToDB.EntityFrameworkCore/LinqToDBContextOptionsBuilder.cs

@@ -0,0 +1,41 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace LinqToDB.EntityFrameworkCore
+{
+	using Internal;
+	using Interceptors;
+
+	/// <summary>
+	/// LinqToDB context options builder
+	/// </summary>
+	public class LinqToDBContextOptionsBuilder 
+	{
+		private readonly LinqToDBOptionsExtension _extension;
+
+		/// <summary>
+		/// Db context options
+		/// </summary>
+		public DbContextOptions DbContextOptions { get; private set; }
+
+		/// <summary>
+		/// .ctor
+		/// </summary>
+		/// <param name="optionsBuilder"></param>
+		public LinqToDBContextOptionsBuilder(DbContextOptionsBuilder optionsBuilder)
+		{
+			_extension = optionsBuilder.Options.FindExtension<LinqToDBOptionsExtension>();
+			DbContextOptions = optionsBuilder.Options;
+		}
+
+		/// <summary>
+		/// Registers LinqToDb interceptor
+		/// </summary>
+		/// <param name="interceptor">The interceptor instance to register</param>
+		/// <returns></returns>
+		public LinqToDBContextOptionsBuilder AddInterceptor(IInterceptor interceptor)
+		{
+			_extension.Interceptors.Add(interceptor);
+			return this;
+		}
+	}
+}

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.ContextExtensions.cs

@@ -3,6 +3,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
 
 using JetBrains.Annotations;
 
@@ -11,6 +12,8 @@ namespace LinqToDB.EntityFrameworkCore
 	extern alias interactive_async;
 	using Data;
 	using Linq;
+	using Internal;
+	using Interceptors;
 
 	public static partial class LinqToDBForEFTools
 	{
@@ -188,7 +191,44 @@ public static ITable<T> GetTable<T>(this DbContext context)
 
 			return context.CreateLinqToDbContext().GetTable<T>();
 		}
-		
+
+		#endregion
+
+		#region Interceptors
+
+		/// <summary>
+		/// Returns list of registered Linq2Db interceptors from EF Context
+		/// </summary>
+		/// <returns>Db context object</returns>
+		public static IList<IInterceptor>? GetLinq2DbInterceptors(this DbContext context)
+
+		{
+			if (context == null) throw new ArgumentNullException(nameof(context));
+
+			var contextOptions = ((IInfrastructure<IServiceProvider>)context.Database)?
+				.Instance?.GetService(typeof(IDbContextOptions)) as IDbContextOptions;
+
+			return contextOptions?.GetLinq2DbInterceptors();
+		}
+
+		/// <summary>
+		/// Returns list of registered Linq2Db interceptors from EF Context options
+		/// </summary>
+		/// <returns>Db context options</returns>
+		public static IList<IInterceptor> GetLinq2DbInterceptors(this IDbContextOptions contextOptions)
+		{
+			if (contextOptions == null) throw new ArgumentNullException(nameof(contextOptions));
+
+			var linq2DbExtension = contextOptions?.FindExtension<LinqToDBOptionsExtension>();
+			List<IInterceptor> interceptors = new List<IInterceptor>();
+			if (linq2DbExtension?.Interceptors != null)
+			{
+				interceptors.AddRange(linq2DbExtension.Interceptors);
+			}
+
+			return interceptors;
+		}
+
 		#endregion
 	}
 }

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.ContextOptionsBuilderExtensions.cs

@@ -0,0 +1,33 @@
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+
+namespace LinqToDB.EntityFrameworkCore
+{
+	using Internal;
+
+	public static partial class LinqToDBForEFTools
+	{
+		/// <summary>
+		/// Registers custom options related to LinqToDB provider
+		/// </summary>
+		/// <param name="optionsBuilder"></param>
+		/// <param name="linq2DbOptionsAction">Custom options action</param>
+		/// <returns></returns>
+		public static DbContextOptionsBuilder UseLinqToDb(
+			this DbContextOptionsBuilder optionsBuilder,
+			Action<LinqToDBContextOptionsBuilder>? linq2DbOptionsAction = null)
+		{
+			((IDbContextOptionsBuilderInfrastructure)optionsBuilder)
+				.AddOrUpdateExtension(GetOrCreateExtension(optionsBuilder));
+
+			linq2DbOptionsAction?.Invoke(new LinqToDBContextOptionsBuilder(optionsBuilder));
+
+			return optionsBuilder;
+		}
+
+		private static LinqToDBOptionsExtension GetOrCreateExtension(DbContextOptionsBuilder options)
+			=> options.Options.FindExtension<LinqToDBOptionsExtension>()
+				?? new LinqToDBOptionsExtension();
+	}
+}

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.cs

@@ -288,6 +288,8 @@ public static DataConnection CreateLinqToDbConnection(this DbContext context,
 			if (mappingSchema != null)
 				dc.AddMappingSchema(mappingSchema);
 
+			AddInterceptorsToDataContext(context, dc);
+
 			return dc;
 		}
 
@@ -372,6 +374,8 @@ public static IDataContext CreateLinqToDbContext(this DbContext context,
 				EnableTracing(dc, logger);
 			}
 
+			AddInterceptorsToDataContext(context, dc);
+
 			return dc;
 		}
 
@@ -497,6 +501,8 @@ public static DataConnection CreateLinqToDbConnection(this DbContextOptions opti
 					dc.AddMappingSchema(mappingSchema);
 			}
 
+			AddInterceptorsToDataContext(options, dc);
+
 			return dc;
 		}
 
@@ -513,6 +519,7 @@ public static IQueryable<T> ToLinqToDB<T>(this IQueryable<T> query, IDataContext
 			if (context == null)
 				throw new LinqToDBForEFToolsException("Can not evaluate current context from query");
 
+			AddInterceptorsToDataContext(context, dc);
 			return new LinqToDBForEFQueryProvider<T>(dc, query.Expression);
 		}
 
@@ -558,5 +565,28 @@ public static bool EnableChangeTracker
 			set => Implementation.EnableChangeTracker = value;
 		}
 
+		private static void AddInterceptorsToDataContext(DbContext efContext, IDataContext dc)
+		{
+			var contextOptions = ((IInfrastructure<IServiceProvider>)efContext.Database)?
+				.Instance?.GetService(typeof(IDbContextOptions)) as IDbContextOptions;
+			
+			AddInterceptorsToDataContext(contextOptions, dc);
+		}
+
+		private static void AddInterceptorsToDataContext(IDbContextOptions? contextOptions,
+			IDataContext dc)
+		{
+			var registeredInterceptors = contextOptions?.GetLinq2DbInterceptors();
+
+			if (registeredInterceptors != null
+
+				&& dc != null )
+			{
+				foreach (var interceptor in registeredInterceptors)
+				{
+					dc.AddInterceptor(interceptor);
+				}
+			}
+		}
 	}
 }

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFToolsImplDefault.cs

@@ -1180,6 +1180,5 @@ public virtual void LogConnectionTrace(TraceInfo info, ILogger logger)
 		/// Entities will be attached only if AsNoTracking() is not used in query and DbContext is configured to track entities. 
 		/// </summary>
 		public virtual bool EnableChangeTracker { get; set; } = true;
-
 	}
 }

Tests/LinqToDB.EntityFrameworkCore.BaseTests/Interceptors/TestCommandInterceptor.cs

@@ -0,0 +1,70 @@
+using System.Data;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+using LinqToDB.Common;
+using LinqToDB.Interceptors;
+
+namespace LinqToDB.EntityFrameworkCore.BaseTests.Interceptors
+{
+	public class TestCommandInterceptor : TestInterceptor, ICommandInterceptor
+	{
+		public void AfterExecuteReader(CommandEventData eventData, DbCommand command, CommandBehavior commandBehavior, DbDataReader dataReader)
+		{
+			HasInterceptorBeenInvoked = true;
+		}
+
+		public void BeforeReaderDispose(CommandEventData eventData, DbCommand? command, DbDataReader dataReader)
+		{
+			HasInterceptorBeenInvoked = true;
+		}
+
+		public Task BeforeReaderDisposeAsync(CommandEventData eventData, DbCommand? command, DbDataReader dataReader)
+		{
+			HasInterceptorBeenInvoked = true;
+			return Task.CompletedTask;
+		}
+
+		public DbCommand CommandInitialized(CommandEventData eventData, DbCommand command)
+		{
+			HasInterceptorBeenInvoked = true;
+			return command;
+		}
+
+		public Option<int> ExecuteNonQuery(CommandEventData eventData, DbCommand command, Option<int> result)
+		{
+			HasInterceptorBeenInvoked = true;
+			return result;
+		}
+
+		public Task<Option<int>> ExecuteNonQueryAsync(CommandEventData eventData, DbCommand command, Option<int> result, CancellationToken cancellationToken)
+		{
+			HasInterceptorBeenInvoked = true;
+			return Task.FromResult(result);
+		}
+
+		public Option<DbDataReader> ExecuteReader(CommandEventData eventData, DbCommand command, CommandBehavior commandBehavior, Option<DbDataReader> result)
+		{
+			HasInterceptorBeenInvoked = true;
+			return result;
+		}
+
+		public Task<Option<DbDataReader>> ExecuteReaderAsync(CommandEventData eventData, DbCommand command, CommandBehavior commandBehavior, Option<DbDataReader> result, CancellationToken cancellationToken)
+		{
+			HasInterceptorBeenInvoked = true;
+			return Task.FromResult(result);
+		}
+
+		public Option<object?> ExecuteScalar(CommandEventData eventData, DbCommand command, Option<object?> result)
+		{
+			HasInterceptorBeenInvoked = true;
+			return result;
+		}
+
+		public Task<Option<object?>> ExecuteScalarAsync(CommandEventData eventData, DbCommand command, Option<object?> result, CancellationToken cancellationToken)
+		{
+			HasInterceptorBeenInvoked = true;
+			return Task.FromResult(result);
+		}
+	}
+}