Fix EnableChangeTracker and AsNoTracking support (#57)

* Add failing tests

* Fix EnableChangeTracker property

* Fixed AsNoTracking issue.

Co-authored-by: Svyatoslav Danyliv <[email protected]>

Author: Shane32

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFTools.cs

@@ -93,13 +93,13 @@ public static ILinqToDBForEFTools Implementation
 			{
 				_implementation = value ?? throw new ArgumentNullException(nameof(value));
 				_metadataReaders.Clear();
-				_defaultMeadataReader = new Lazy<IMetadataReader>(() => Implementation.CreateMetadataReader(null, null, null));
+				_defaultMetadataReader = new Lazy<IMetadataReader>(() => Implementation.CreateMetadataReader(null, null, null));
 			}
 		}
 
 		static readonly ConcurrentDictionary<IModel, IMetadataReader> _metadataReaders = new ConcurrentDictionary<IModel, IMetadataReader>();
 
-		static Lazy<IMetadataReader> _defaultMeadataReader;
+		static Lazy<IMetadataReader> _defaultMetadataReader;
 
 		/// <summary>
 		/// Clears internal caches
@@ -129,7 +129,7 @@ public static IMetadataReader GetMetadataReader([JetBrains.Annotations.CanBeNull
 			RelationalSqlTranslatingExpressionVisitorDependencies dependencies, IRelationalTypeMappingSource mappingSource)
 		{
 			if (model == null)
-				return _defaultMeadataReader.Value;
+				return _defaultMetadataReader.Value;
 
 			return _metadataReaders.GetOrAdd(model, m => Implementation.CreateMetadataReader(model, dependencies, mappingSource));
 		}
@@ -517,7 +517,7 @@ public static DbContext GetCurrentContext(IQueryable query)
 		public static bool EnableChangeTracker 
 		{ 
 			get => Implementation.EnableChangeTracker;
-			set => Implementation.EnableChangeTracker = true;
+			set => Implementation.EnableChangeTracker = value;
 		}
 
 	}

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFToolsDataConnection.cs

@@ -22,13 +22,13 @@ public class LinqToDBForEFToolsDataConnection : DataConnection, IExpressionPrepr
 		readonly IModel _model;
 		readonly Func<Expression, IDataContext, DbContext, IModel, Expression> _transformFunc;
 
-		private IEntityType _lastEntityType;
-		private Type        _lastType;
+		private IEntityType   _lastEntityType;
+		private Type          _lastType;
 		private IStateManager _stateManager;
 
-		public bool         Tracking { get; set; }
+		public bool      Tracking { get; set; }
 
-		public DbContext Context { get; }
+		public DbContext Context  { get; }
 
 		public LinqToDBForEFToolsDataConnection(
 			[CanBeNull] DbContext     context,

Source/LinqToDB.EntityFrameworkCore/LinqToDBForEFToolsImplDefault.cs

@@ -534,6 +534,9 @@ static readonly MethodInfo
 		static readonly MethodInfo L2DBFromSqlMethodInfo = 
 			MemberHelper.MethodOfGeneric<IDataContext>(dc => dc.FromSql<object>(new Common.RawSqlString()));
 
+		static readonly MethodInfo L2DBRemoveOrderByMethodInfo = 
+			MemberHelper.MethodOfGeneric<IQueryable<object>>(q => q.RemoveOrderBy());
+
 		static readonly ConstructorInfo RawSqlStringConstructor = MemberHelper.ConstructorOf(() => new Common.RawSqlString(""));
 
 		static readonly ConstructorInfo DataParameterConstructor = MemberHelper.ConstructorOf(() => new DataParameter("", "", DataType.Undefined, ""));
@@ -700,7 +703,8 @@ static List<Expression> CompactTree(List<Expression> items, ExpressionType nodeT
 		public virtual Expression TransformExpression(Expression expression, IDataContext dc, DbContext ctx, IModel model)
 		{
 			var ignoreQueryFilters = false;
-			var tracking = true;
+			var tracking           = true;
+			var ignoreTracking     = false;
 
 			Expression LocalTransform(Expression e)
 			{
@@ -795,6 +799,12 @@ Expression LocalTransform(Expression e)
 										methodCall.Arguments.Select(a => a.Transform(l => LocalTransform(l)))
 											.ToArray());
 								}
+								else if (generic == L2DBRemoveOrderByMethodInfo)
+								{
+									// This is workaround. EagerLoading runs query again with RemoveOrderBy method.
+									// it is only one possible way now how to detect nested query. 
+									ignoreTracking = true;
+								}
 
 								if (isTunnel)
 									return methodCall.Arguments[0].Transform(l => LocalTransform(l));
@@ -848,7 +858,7 @@ Expression LocalTransform(Expression e)
 					newExpression, Expression.NewArrayInit(typeof(Type)));
 			}
 
-			if (dc is LinqToDBForEFToolsDataConnection dataConnection)
+			if (!ignoreTracking && dc is LinqToDBForEFToolsDataConnection dataConnection)
 			{
 				// ReSharper disable once ConditionIsAlwaysTrueOrFalse
 				dataConnection.Tracking = tracking;

Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/ToolsTests.cs

@@ -568,6 +568,61 @@ public async Task TestChangeTracker([Values(true, false)] bool enableFilter)
 			}
 		}
 
+		[Test]
+		public async Task TestChangeTrackerDisabled1([Values(true, false)] bool enableFilter)
+		{
+			using (var ctx = CreateContext(enableFilter))
+			{
+				var query = ctx.Orders
+					.Include(o => o.OrderDetails)
+					.ThenInclude(d => d.Product)
+					.ThenInclude(p => p.OrderDetails)
+					.AsNoTracking();
+
+				// var efResult = await query.ToArrayAsync();
+				var result = await query.ToLinqToDB().ToArrayAsync();
+
+				var orderDetail = result[0].OrderDetails.First();
+				orderDetail.UnitPrice = orderDetail.UnitPrice * 1.1m;
+
+				ctx.ChangeTracker.DetectChanges();
+				var changedEntry = ctx.ChangeTracker.Entries().Where(e => e.State == EntityState.Modified).SingleOrDefault();
+				Assert.AreEqual(changedEntry, null);
+				ctx.SaveChanges();
+			}
+		}
+
+		[Test]
+		public async Task TestChangeTrackerDisabled2([Values(true, false)] bool enableFilter)
+		{
+			LinqToDBForEFTools.EnableChangeTracker = false;
+			try
+			{
+				using (var ctx = CreateContext(enableFilter))
+				{
+					var query = ctx.Orders
+						.Include(o => o.OrderDetails)
+						.ThenInclude(d => d.Product)
+						.ThenInclude(p => p.OrderDetails);
+
+					// var efResult = await query.ToArrayAsync();
+					var result = await query.ToLinqToDB().ToArrayAsync();
+
+					var orderDetail = result[0].OrderDetails.First();
+					orderDetail.UnitPrice = orderDetail.UnitPrice * 1.1m;
+
+					ctx.ChangeTracker.DetectChanges();
+					var changedEntry = ctx.ChangeTracker.Entries().Where(e => e.State == EntityState.Modified).SingleOrDefault();
+					Assert.AreEqual(changedEntry, null);
+					ctx.SaveChanges();
+				}
+			}
+			finally
+			{
+				LinqToDBForEFTools.EnableChangeTracker = true;
+			}
+		}
+
 		[Test]
 		public async Task TestSetUpdate([Values(true, false)] bool enableFilter)
 		{