Allow naming a property FieldInterceptor when an entity has lazy properties (#1444)

fredericDelaporte · hazzik · commit 1e00feff5af1 · 2017-11-19T10:58:08.000+13:00
Fixes #1442
diff --git a/src/NHibernate.Test/Async/LazyProperty/LazyPropertyFixture.cs b/src/NHibernate.Test/Async/LazyProperty/LazyPropertyFixture.cs
@@ -9,6 +9,7 @@
 
 
 using System.Collections;
+using NHibernate.Intercept;
 using NHibernate.Tuple.Entity;
 using NUnit.Framework;
 
@@ -42,14 +43,20 @@ protected override DebugSessionFactory BuildSessionFactory()
 
 		protected override void OnSetUp()
 		{
+			Assert.That(
+				nameof(Book.FieldInterceptor),
+				Is.EqualTo(nameof(IFieldInterceptorAccessor.FieldInterceptor)),
+				$"Test pre-condition not met: entity property {nameof(Book.FieldInterceptor)} should have the same " +
+				$"name than {nameof(IFieldInterceptorAccessor)}.{nameof(IFieldInterceptorAccessor.FieldInterceptor)}");
 			using (var s = OpenSession())
 			using (var tx = s.BeginTransaction())
 			{
 				s.Persist(new Book
 				{
 					Name = "some name",
 					Id = 1,
-					ALotOfText = "a lot of text ..."
+					ALotOfText = "a lot of text ...",
+					FieldInterceptor = "Why not that name?"
 				});
 				tx.Commit();
 			}
@@ -76,12 +83,14 @@ public async Task PropertyLoadedNotInitializedAsync()
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.False);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.False);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.False);
 
 				await (NHibernateUtil.InitializeAsync(book));
 
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);
 			}
 		}
 
@@ -95,6 +104,7 @@ public async Task PropertyLoadedNotInitializedWhenUsingGetAsync()
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);
 			}
 		}
 
@@ -118,6 +128,7 @@ public async Task CanGetValueForNonLazyPropertyAsync()
 				var book = await (s.GetAsync<Book>(1));
 
 				Assert.That(book.Name, Is.EqualTo("some name"));
+				Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?"));
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
 			}
 		}
@@ -137,7 +148,6 @@ public async Task CanLoadAndSaveObjectInDifferentSessionsAsync()
 			}
 		}
 
-
 		[Test]
 		public async Task CanUpdateNonLazyWithoutLoadingLazyPropertyAsync()
 		{
@@ -147,17 +157,19 @@ public async Task CanUpdateNonLazyWithoutLoadingLazyPropertyAsync()
 			{
 				book = await (s.GetAsync<Book>(1));
 				book.Name += "updated";
+				book.FieldInterceptor += "updated";
 
-				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "Before flush and commit");
 				await (trans.CommitAsync());
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "After flush and commit");
 			}
 
-
 			using (ISession s = OpenSession())
 			{
 				book = await (s.GetAsync<Book>(1));
 				Assert.That(book.Name, Is.EqualTo("some nameupdated"));
+				Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?updated"));
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/LazyProperty/Book.cs b/src/NHibernate.Test/LazyProperty/Book.cs
@@ -12,5 +12,7 @@ public virtual string ALotOfText
 			get { return _aLotOfText; }
 			set { _aLotOfText = value; }
 		}
+
+		public virtual string FieldInterceptor { get; set; }
 	}
-}
+}
diff --git a/src/NHibernate.Test/LazyProperty/LazyPropertyFixture.cs b/src/NHibernate.Test/LazyProperty/LazyPropertyFixture.cs
@@ -1,4 +1,5 @@
 ﻿using System.Collections;
+using NHibernate.Intercept;
 using NHibernate.Tuple.Entity;
 using NUnit.Framework;
 
@@ -31,14 +32,20 @@ protected override DebugSessionFactory BuildSessionFactory()
 
 		protected override void OnSetUp()
 		{
+			Assert.That(
+				nameof(Book.FieldInterceptor),
+				Is.EqualTo(nameof(IFieldInterceptorAccessor.FieldInterceptor)),
+				$"Test pre-condition not met: entity property {nameof(Book.FieldInterceptor)} should have the same " +
+				$"name than {nameof(IFieldInterceptorAccessor)}.{nameof(IFieldInterceptorAccessor.FieldInterceptor)}");
 			using (var s = OpenSession())
 			using (var tx = s.BeginTransaction())
 			{
 				s.Persist(new Book
 				{
 					Name = "some name",
 					Id = 1,
-					ALotOfText = "a lot of text ..."
+					ALotOfText = "a lot of text ...",
+					FieldInterceptor = "Why not that name?"
 				});
 				tx.Commit();
 			}
@@ -65,12 +72,14 @@ public void PropertyLoadedNotInitialized()
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.False);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.False);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.False);
 
 				NHibernateUtil.Initialize(book);
 
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);
 			}
 		}
 
@@ -90,6 +99,7 @@ public void PropertyLoadedNotInitializedWhenUsingGet()
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);
 			}
 		}
 
@@ -113,6 +123,7 @@ public void CanGetValueForNonLazyProperty()
 				var book = s.Get<Book>(1);
 
 				Assert.That(book.Name, Is.EqualTo("some name"));
+				Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?"));
 				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
 			}
 		}
@@ -132,7 +143,6 @@ public void CanLoadAndSaveObjectInDifferentSessions()
 			}
 		}
 
-
 		[Test]
 		public void CanUpdateNonLazyWithoutLoadingLazyProperty()
 		{
@@ -142,17 +152,19 @@ public void CanUpdateNonLazyWithoutLoadingLazyProperty()
 			{
 				book = s.Get<Book>(1);
 				book.Name += "updated";
+				book.FieldInterceptor += "updated";
 
-				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "Before flush and commit");
 				trans.Commit();
+				Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "After flush and commit");
 			}
 
-
 			using (ISession s = OpenSession())
 			{
 				book = s.Get<Book>(1);
 				Assert.That(book.Name, Is.EqualTo("some nameupdated"));
+				Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?updated"));
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/LazyProperty/Mappings.hbm.xml b/src/NHibernate.Test/LazyProperty/Mappings.hbm.xml
@@ -9,6 +9,7 @@
 		</id>
 		<property name="Name" />
 		<property name="ALotOfText" lazy="true" />
+		<property name="FieldInterceptor" />
 	</class>
 
 </hibernate-mapping>
diff --git a/src/NHibernate/Intercept/DefaultDynamicLazyFieldInterceptor.cs b/src/NHibernate/Intercept/DefaultDynamicLazyFieldInterceptor.cs
@@ -17,7 +17,7 @@ public object Intercept(InvocationInfo info)
 			{
 				if (ReflectHelper.IsPropertyGet(info.TargetMethod))
 				{
-					if("get_FieldInterceptor".Equals(methodName))
+					if (IsGetFieldInterceptorCall(methodName, info.TargetMethod))
 					{
 						return FieldInterceptor;
 					}
@@ -33,7 +33,7 @@ public object Intercept(InvocationInfo info)
 				}
 				else if (ReflectHelper.IsPropertySet(info.TargetMethod))
 				{
-					if ("set_FieldInterceptor".Equals(methodName))
+					if (IsSetFieldInterceptorCall(methodName, info.TargetMethod))
 					{
 						FieldInterceptor = (IFieldInterceptor)info.Arguments[0];
 						return null;
@@ -44,7 +44,7 @@ public object Intercept(InvocationInfo info)
 			}
 			else
 			{
-				if ("set_FieldInterceptor".Equals(methodName))
+				if (IsSetFieldInterceptorCall(methodName, info.TargetMethod))
 				{
 					FieldInterceptor = (IFieldInterceptor)info.Arguments[0];
 					return null;
@@ -53,5 +53,15 @@ public object Intercept(InvocationInfo info)
 
 			return info.InvokeMethodOnTarget();
 		}
+
+		private static bool IsGetFieldInterceptorCall(string methodName, MethodInfo targetMethod)
+		{
+			return "get_FieldInterceptor".Equals(methodName) && targetMethod.DeclaringType == typeof(IFieldInterceptorAccessor);
+		}
+
+		private static bool IsSetFieldInterceptorCall(string methodName, MethodInfo targetMethod)
+		{
+			return "set_FieldInterceptor".Equals(methodName) && targetMethod.DeclaringType == typeof(IFieldInterceptorAccessor);
+		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`
`10`	`10`
`11`	`11`	`using System.Collections;`
	`12`	`+using NHibernate.Intercept;`
`12`	`13`	`using NHibernate.Tuple.Entity;`
`13`	`14`	`using NUnit.Framework;`
`14`	`15`
`@@ -42,14 +43,20 @@ protected override DebugSessionFactory BuildSessionFactory()`
`42`	`43`
`43`	`44`	`protected override void OnSetUp()`
`44`	`45`	`{`
	`46`	`+ Assert.That(`
	`47`	`+ nameof(Book.FieldInterceptor),`
	`48`	`+ Is.EqualTo(nameof(IFieldInterceptorAccessor.FieldInterceptor)),`
	`49`	`+ $"Test pre-condition not met: entity property {nameof(Book.FieldInterceptor)} should have the same " +`
	`50`	`+ $"name than {nameof(IFieldInterceptorAccessor)}.{nameof(IFieldInterceptorAccessor.FieldInterceptor)}");`
`45`	`51`	`using (var s = OpenSession())`
`46`	`52`	`using (var tx = s.BeginTransaction())`
`47`	`53`	`{`
`48`	`54`	`s.Persist(new Book`
`49`	`55`	`{`
`50`	`56`	`Name = "some name",`
`51`	`57`	`Id = 1,`
`52`		`- ALotOfText = "a lot of text ..."`
	`58`	`+ ALotOfText = "a lot of text ...",`
	`59`	`+ FieldInterceptor = "Why not that name?"`
`53`	`60`	`});`
`54`	`61`	`tx.Commit();`
`55`	`62`	`}`
`@@ -76,12 +83,14 @@ public async Task PropertyLoadedNotInitializedAsync()`
`76`	`83`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.False);`
`77`	`84`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.False);`
`78`	`85`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`86`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.False);`
`79`	`87`
`80`	`88`	`await (NHibernateUtil.InitializeAsync(book));`
`81`	`89`
`82`	`90`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);`
`83`	`91`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);`
`84`	`92`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`93`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);`
`85`	`94`	`}`
`86`	`95`	`}`
`87`	`96`
`@@ -95,6 +104,7 @@ public async Task PropertyLoadedNotInitializedWhenUsingGetAsync()`
`95`	`104`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);`
`96`	`105`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);`
`97`	`106`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`107`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);`
`98`	`108`	`}`
`99`	`109`	`}`
`100`	`110`
`@@ -118,6 +128,7 @@ public async Task CanGetValueForNonLazyPropertyAsync()`
`118`	`128`	`var book = await (s.GetAsync<Book>(1));`
`119`	`129`
`120`	`130`	`Assert.That(book.Name, Is.EqualTo("some name"));`
	`131`	`+ Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?"));`
`121`	`132`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
`122`	`133`	`}`
`123`	`134`	`}`
`@@ -137,7 +148,6 @@ public async Task CanLoadAndSaveObjectInDifferentSessionsAsync()`
`137`	`148`	`}`
`138`	`149`	`}`
`139`	`150`
`140`		`-`
`141`	`151`	`[Test]`
`142`	`152`	`public async Task CanUpdateNonLazyWithoutLoadingLazyPropertyAsync()`
`143`	`153`	`{`
`@@ -147,17 +157,19 @@ public async Task CanUpdateNonLazyWithoutLoadingLazyPropertyAsync()`
`147`	`157`	`{`
`148`	`158`	`book = await (s.GetAsync<Book>(1));`
`149`	`159`	`book.Name += "updated";`
	`160`	`+ book.FieldInterceptor += "updated";`
`150`	`161`
`151`		`- Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`162`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "Before flush and commit");`
`152`	`163`	`await (trans.CommitAsync());`
	`164`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "After flush and commit");`
`153`	`165`	`}`
`154`	`166`
`155`		`-`
`156`	`167`	`using (ISession s = OpenSession())`
`157`	`168`	`{`
`158`	`169`	`book = await (s.GetAsync<Book>(1));`
`159`	`170`	`Assert.That(book.Name, Is.EqualTo("some nameupdated"));`
	`171`	`+ Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?updated"));`
`160`	`172`	`}`
`161`	`173`	`}`
`162`	`174`	`}`
`163`		`-}`
	`175`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -12,5 +12,7 @@ public virtual string ALotOfText`
`12`	`12`	`get { return _aLotOfText; }`
`13`	`13`	`set { _aLotOfText = value; }`
`14`	`14`	`}`
	`15`	`+`
	`16`	`+ public virtual string FieldInterceptor { get; set; }`
`15`	`17`	`}`
`16`		`-}`
	`18`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using System.Collections;`
	`2`	`+using NHibernate.Intercept;`
`2`	`3`	`using NHibernate.Tuple.Entity;`
`3`	`4`	`using NUnit.Framework;`
`4`	`5`
`@@ -31,14 +32,20 @@ protected override DebugSessionFactory BuildSessionFactory()`
`31`	`32`
`32`	`33`	`protected override void OnSetUp()`
`33`	`34`	`{`
	`35`	`+ Assert.That(`
	`36`	`+ nameof(Book.FieldInterceptor),`
	`37`	`+ Is.EqualTo(nameof(IFieldInterceptorAccessor.FieldInterceptor)),`
	`38`	`+ $"Test pre-condition not met: entity property {nameof(Book.FieldInterceptor)} should have the same " +`
	`39`	`+ $"name than {nameof(IFieldInterceptorAccessor)}.{nameof(IFieldInterceptorAccessor.FieldInterceptor)}");`
`34`	`40`	`using (var s = OpenSession())`
`35`	`41`	`using (var tx = s.BeginTransaction())`
`36`	`42`	`{`
`37`	`43`	`s.Persist(new Book`
`38`	`44`	`{`
`39`	`45`	`Name = "some name",`
`40`	`46`	`Id = 1,`
`41`		`- ALotOfText = "a lot of text ..."`
	`47`	`+ ALotOfText = "a lot of text ...",`
	`48`	`+ FieldInterceptor = "Why not that name?"`
`42`	`49`	`});`
`43`	`50`	`tx.Commit();`
`44`	`51`	`}`
`@@ -65,12 +72,14 @@ public void PropertyLoadedNotInitialized()`
`65`	`72`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.False);`
`66`	`73`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.False);`
`67`	`74`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`75`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.False);`
`68`	`76`
`69`	`77`	`NHibernateUtil.Initialize(book);`
`70`	`78`
`71`	`79`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);`
`72`	`80`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);`
`73`	`81`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`82`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);`
`74`	`83`	`}`
`75`	`84`	`}`
`76`	`85`
`@@ -90,6 +99,7 @@ public void PropertyLoadedNotInitializedWhenUsingGet()`
`90`	`99`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Id"), Is.True);`
`91`	`100`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Name"), Is.True);`
`92`	`101`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`102`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, nameof(Book.FieldInterceptor)), Is.True);`
`93`	`103`	`}`
`94`	`104`	`}`
`95`	`105`
`@@ -113,6 +123,7 @@ public void CanGetValueForNonLazyProperty()`
`113`	`123`	`var book = s.Get<Book>(1);`
`114`	`124`
`115`	`125`	`Assert.That(book.Name, Is.EqualTo("some name"));`
	`126`	`+ Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?"));`
`116`	`127`	`Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
`117`	`128`	`}`
`118`	`129`	`}`
`@@ -132,7 +143,6 @@ public void CanLoadAndSaveObjectInDifferentSessions()`
`132`	`143`	`}`
`133`	`144`	`}`
`134`	`145`
`135`		`-`
`136`	`146`	`[Test]`
`137`	`147`	`public void CanUpdateNonLazyWithoutLoadingLazyProperty()`
`138`	`148`	`{`
`@@ -142,17 +152,19 @@ public void CanUpdateNonLazyWithoutLoadingLazyProperty()`
`142`	`152`	`{`
`143`	`153`	`book = s.Get<Book>(1);`
`144`	`154`	`book.Name += "updated";`
	`155`	`+ book.FieldInterceptor += "updated";`
`145`	`156`
`146`		`- Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False);`
	`157`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "Before flush and commit");`
`147`	`158`	`trans.Commit();`
	`159`	`+ Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.False, "After flush and commit");`
`148`	`160`	`}`
`149`	`161`
`150`		`-`
`151`	`162`	`using (ISession s = OpenSession())`
`152`	`163`	`{`
`153`	`164`	`book = s.Get<Book>(1);`
`154`	`165`	`Assert.That(book.Name, Is.EqualTo("some nameupdated"));`
	`166`	`+ Assert.That(book.FieldInterceptor, Is.EqualTo("Why not that name?updated"));`
`155`	`167`	`}`
`156`	`168`	`}`
`157`	`169`	`}`
`158`		`-}`
	`170`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public object Intercept(InvocationInfo info)`
`17`	`17`	`{`
`18`	`18`	`if (ReflectHelper.IsPropertyGet(info.TargetMethod))`
`19`	`19`	`{`
`20`		`- if("get_FieldInterceptor".Equals(methodName))`
	`20`	`+ if (IsGetFieldInterceptorCall(methodName, info.TargetMethod))`
`21`	`21`	`{`
`22`	`22`	`return FieldInterceptor;`
`23`	`23`	`}`
`@@ -33,7 +33,7 @@ public object Intercept(InvocationInfo info)`
`33`	`33`	`}`
`34`	`34`	`else if (ReflectHelper.IsPropertySet(info.TargetMethod))`
`35`	`35`	`{`
`36`		`- if ("set_FieldInterceptor".Equals(methodName))`
	`36`	`+ if (IsSetFieldInterceptorCall(methodName, info.TargetMethod))`
`37`	`37`	`{`
`38`	`38`	`FieldInterceptor = (IFieldInterceptor)info.Arguments[0];`
`39`	`39`	`return null;`
`@@ -44,7 +44,7 @@ public object Intercept(InvocationInfo info)`
`44`	`44`	`}`
`45`	`45`	`else`
`46`	`46`	`{`
`47`		`- if ("set_FieldInterceptor".Equals(methodName))`
	`47`	`+ if (IsSetFieldInterceptorCall(methodName, info.TargetMethod))`
`48`	`48`	`{`
`49`	`49`	`FieldInterceptor = (IFieldInterceptor)info.Arguments[0];`
`50`	`50`	`return null;`
`@@ -53,5 +53,15 @@ public object Intercept(InvocationInfo info)`
`53`	`53`
`54`	`54`	`return info.InvokeMethodOnTarget();`
`55`	`55`	`}`
	`56`	`+`
	`57`	`+ private static bool IsGetFieldInterceptorCall(string methodName, MethodInfo targetMethod)`
	`58`	`+ {`
	`59`	`+ return "get_FieldInterceptor".Equals(methodName) && targetMethod.DeclaringType == typeof(IFieldInterceptorAccessor);`
	`60`	`+ }`
	`61`	`+`
	`62`	`+ private static bool IsSetFieldInterceptorCall(string methodName, MethodInfo targetMethod)`
	`63`	`+ {`
	`64`	`+ return "set_FieldInterceptor".Equals(methodName) && targetMethod.DeclaringType == typeof(IFieldInterceptorAccessor);`
	`65`	`+ }`
`56`	`66`	`}`
`57`	`67`	`}`