Skip initialization of lazy properties when setting one

src/NHibernate.Test/Async/GhostProperty/GhostPropertyFixture.cs

@@ -167,6 +167,21 @@ public async Task WhenGetThenLoadOnlyNoLazyPlainPropertiesAsync()
 				}
 				Assert.That(NHibernateUtil.IsPropertyInitialized(order, "ALazyProperty"), Is.True);
 			}
-		} 
+		}
+
+		[Test]
+		public async Task AcceptPropertySetWithTransientObjectAsync()
+		{
+			Order order;
+			using (var s = OpenSession())
+			{
+				order = await (s.GetAsync<Order>(1));
+			}
+
+			var newPayment = new WireTransfer();
+			order.Payment = newPayment;
+
+			Assert.That(order.Payment, Is.EqualTo(newPayment));
+		}
 	}
 }

src/NHibernate.Test/Async/LazyProperty/LazyPropertyFixture.cs

@@ -10,14 +10,17 @@
 
 using System.Collections;
 using System.Linq;
+using NHibernate.Cfg;
 using NHibernate.Intercept;
 using NHibernate.Tuple.Entity;
 using NUnit.Framework;
+using NUnit.Framework.Constraints;
 using NHibernate.Linq;
 
 namespace NHibernate.Test.LazyProperty
 {
 	using System.Threading.Tasks;
+	using System.Threading;
 	[TestFixture]
 	public class LazyPropertyFixtureAsync : TestCase
 	{
@@ -43,6 +46,11 @@ protected override DebugSessionFactory BuildSessionFactory()
 			}
 		}
 
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.GenerateStatistics, "true");
+		}
+
 		protected override void OnSetUp()
 		{
 			Assert.That(
@@ -58,6 +66,7 @@ protected override void OnSetUp()
 					Name = "some name",
 					Id = 1,
 					ALotOfText = "a lot of text ...",
+					Image = new byte[10],
 					FieldInterceptor = "Why not that name?"
 				});
 				tx.Commit();
@@ -122,6 +131,94 @@ public async Task CanGetValueForLazyPropertyAsync()
 			}
 		}
 
+		[Test]
+		public async Task CanSetValueForLazyPropertyAsync()
+		{
+			Book book;
+			using (ISession s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(1));
+			}
+
+			book.ALotOfText = "text";
+
+			Assert.That(book.ALotOfText, Is.EqualTo("text"));
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+		}
+
+		[TestCase(false)]
+		[TestCase(true)]
+		public async Task CanUpdateValueForLazyPropertyAsync(bool initializeAfterSet, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			Book book;
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book = await (s.GetAsync<Book>(1, cancellationToken));
+				book.ALotOfText = "update-text";
+				if (initializeAfterSet)
+				{
+					var image = book.Image;
+				}
+
+				await (tx.CommitAsync(cancellationToken));
+			}
+
+			using (var s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(1, cancellationToken));
+				var text = book.ALotOfText;
+			}
+
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Image"), Is.True);
+			Assert.That(book.ALotOfText, Is.EqualTo("update-text"));
+			Assert.That(book.Image, Has.Length.EqualTo(10));
+		}
+
+		[TestCase(false)]
+		[TestCase(true)]
+		public async Task UpdateValueForLazyPropertyToSameValueAsync(bool initializeAfterSet, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			Book book;
+			string text;
+
+			using (var s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(1, cancellationToken));
+				text = book.ALotOfText;
+			}
+
+			Sfi.Statistics.Clear();
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book = await (s.GetAsync<Book>(1, cancellationToken));
+				book.ALotOfText = text;
+				if (initializeAfterSet)
+				{
+					var image = book.Image;
+				}
+
+				await (tx.CommitAsync(cancellationToken));
+			}
+
+			Assert.That(Sfi.Statistics.EntityUpdateCount, Is.EqualTo(initializeAfterSet ? 0 : 1));
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Image"), initializeAfterSet ? (Constraint) Is.True : Is.False);
+			Assert.That(book.ALotOfText, Is.EqualTo(text));
+
+			using (var s = OpenSession())
+			{
+				book = await (s.GetAsync<Book>(1, cancellationToken));
+				text = book.ALotOfText;
+			}
+
+			Assert.That(book.Image, Has.Length.EqualTo(10));
+			Assert.That(book.ALotOfText, Is.EqualTo(text));
+		}
+
 		[Test]
 		public async Task CanGetValueForNonLazyPropertyAsync()
 		{

src/NHibernate.Test/GhostProperty/GhostPropertyFixture.cs

@@ -162,6 +162,21 @@ public void WhenGetThenLoadOnlyNoLazyPlainProperties()
 				}
 				Assert.That(NHibernateUtil.IsPropertyInitialized(order, "ALazyProperty"), Is.True);
 			}
-		} 
+		}
+
+		[Test]
+		public void AcceptPropertySetWithTransientObject()
+		{
+			Order order;
+			using (var s = OpenSession())
+			{
+				order = s.Get<Order>(1);
+			}
+
+			var newPayment = new WireTransfer();
+			order.Payment = newPayment;
+
+			Assert.That(order.Payment, Is.EqualTo(newPayment));
+		}
 	}
 }

src/NHibernate.Test/LazyProperty/Book.cs

@@ -13,6 +13,8 @@ public virtual string ALotOfText
 			set { _aLotOfText = value; }
 		}
 
+		public virtual byte[] Image { get; set; }
+
 		public virtual string FieldInterceptor { get; set; }
 	}
 }

src/NHibernate.Test/LazyProperty/LazyPropertyFixture.cs

@@ -1,8 +1,10 @@
 using System.Collections;
 using System.Linq;
+using NHibernate.Cfg;
 using NHibernate.Intercept;
 using NHibernate.Tuple.Entity;
 using NUnit.Framework;
+using NUnit.Framework.Constraints;
 
 namespace NHibernate.Test.LazyProperty
 {
@@ -31,6 +33,11 @@ protected override DebugSessionFactory BuildSessionFactory()
 			}
 		}
 
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.GenerateStatistics, "true");
+		}
+
 		protected override void OnSetUp()
 		{
 			Assert.That(
@@ -46,6 +53,7 @@ protected override void OnSetUp()
 					Name = "some name",
 					Id = 1,
 					ALotOfText = "a lot of text ...",
+					Image = new byte[10],
 					FieldInterceptor = "Why not that name?"
 				});
 				tx.Commit();
@@ -116,6 +124,94 @@ public void CanGetValueForLazyProperty()
 			}
 		}
 
+		[Test]
+		public void CanSetValueForLazyProperty()
+		{
+			Book book;
+			using (ISession s = OpenSession())
+			{
+				book = s.Get<Book>(1);
+			}
+
+			book.ALotOfText = "text";
+
+			Assert.That(book.ALotOfText, Is.EqualTo("text"));
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+		}
+
+		[TestCase(false)]
+		[TestCase(true)]
+		public void CanUpdateValueForLazyProperty(bool initializeAfterSet)
+		{
+			Book book;
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book = s.Get<Book>(1);
+				book.ALotOfText = "update-text";
+				if (initializeAfterSet)
+				{
+					var image = book.Image;
+				}
+
+				tx.Commit();
+			}
+
+			using (var s = OpenSession())
+			{
+				book = s.Get<Book>(1);
+				var text = book.ALotOfText;
+			}
+
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Image"), Is.True);
+			Assert.That(book.ALotOfText, Is.EqualTo("update-text"));
+			Assert.That(book.Image, Has.Length.EqualTo(10));
+		}
+
+		[TestCase(false)]
+		[TestCase(true)]
+		public void UpdateValueForLazyPropertyToSameValue(bool initializeAfterSet)
+		{
+			Book book;
+			string text;
+
+			using (var s = OpenSession())
+			{
+				book = s.Get<Book>(1);
+				text = book.ALotOfText;
+			}
+
+			Sfi.Statistics.Clear();
+
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				book = s.Get<Book>(1);
+				book.ALotOfText = text;
+				if (initializeAfterSet)
+				{
+					var image = book.Image;
+				}
+
+				tx.Commit();
+			}
+
+			Assert.That(Sfi.Statistics.EntityUpdateCount, Is.EqualTo(initializeAfterSet ? 0 : 1));
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "ALotOfText"), Is.True);
+			Assert.That(NHibernateUtil.IsPropertyInitialized(book, "Image"), initializeAfterSet ? (Constraint) Is.True : Is.False);
+			Assert.That(book.ALotOfText, Is.EqualTo(text));
+
+			using (var s = OpenSession())
+			{
+				book = s.Get<Book>(1);
+				text = book.ALotOfText;
+			}
+
+			Assert.That(book.Image, Has.Length.EqualTo(10));
+			Assert.That(book.ALotOfText, Is.EqualTo(text));
+		}
+
 		[Test]
 		public void CanGetValueForNonLazyProperty()
 		{

src/NHibernate.Test/LazyProperty/Mappings.hbm.xml

@@ -9,6 +9,7 @@
 		</id>
 		<property name="Name" />
 		<property name="ALotOfText" lazy="true" />
+		<property name="Image" lazy="true" />
 		<property name="FieldInterceptor" />
 	</class>
 

src/NHibernate/Async/Engine/Cascade.cs

@@ -60,12 +60,12 @@ public async Task CascadeOnAsync(IEntityPersister persister, object parent, obje
 
 				IType[] types = persister.PropertyTypes;
 				CascadeStyle[] cascadeStyles = persister.PropertyCascadeStyles;
-				bool hasUninitializedLazyProperties = persister.HasUninitializedLazyProperties(parent);
+				var uninitializedLazyProperties = persister.GetUninitializedLazyProperties(parent);
 				for (int i = 0; i < types.Length; i++)
 				{
 					CascadeStyle style = cascadeStyles[i];
 					string propertyName = persister.PropertyNames[i];
-					if (hasUninitializedLazyProperties && persister.PropertyLaziness[i] && !action.PerformOnLazyProperty)
+					if (uninitializedLazyProperties.Contains(propertyName) && persister.PropertyLaziness[i] && !action.PerformOnLazyProperty)
 					{
 						//do nothing to avoid a lazy property initialization
 						continue;

src/NHibernate/Async/Persister/Entity/AbstractEntityPersister.cs

@@ -876,8 +876,8 @@ public async Task UpdateAsync(object id, object[] fields, int[] dirtyFields, boo
 			// in the process of being deleted.
 			if (entry == null && !IsMutable)
 				throw new InvalidOperationException("Updating immutable entity that is not in session yet!");
-			
-			if (entityMetamodel.IsDynamicUpdate && dirtyFields != null)
+
+			if (dirtyFields != null && (entityMetamodel.IsDynamicUpdate || HasDirtyLazyProperties(dirtyFields, obj)))
 			{
 				// For the case of dynamic-update="true", we need to generate the UPDATE SQL
 				propsToUpdate = GetPropertiesToUpdate(dirtyFields, hasDirtyCollection);

src/NHibernate/Async/Persister/Entity/IEntityPersister.cs

@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using NHibernate.Cache;
 using NHibernate.Cache.Entry;
 using NHibernate.Engine;
@@ -16,6 +17,9 @@
 using NHibernate.Tuple.Entity;
 using NHibernate.Type;
 using System.Collections;
+using System.Collections.Generic;
+using NHibernate.Intercept;
+using NHibernate.Util;
 
 namespace NHibernate.Persister.Entity
 {

src/NHibernate/Engine/Cascade.cs

@@ -113,12 +113,12 @@ public void CascadeOn(IEntityPersister persister, object parent, object anything
 
 				IType[] types = persister.PropertyTypes;
 				CascadeStyle[] cascadeStyles = persister.PropertyCascadeStyles;
-				bool hasUninitializedLazyProperties = persister.HasUninitializedLazyProperties(parent);
+				var uninitializedLazyProperties = persister.GetUninitializedLazyProperties(parent);
 				for (int i = 0; i < types.Length; i++)
 				{
 					CascadeStyle style = cascadeStyles[i];
 					string propertyName = persister.PropertyNames[i];
-					if (hasUninitializedLazyProperties && persister.PropertyLaziness[i] && !action.PerformOnLazyProperty)
+					if (uninitializedLazyProperties.Contains(propertyName) && persister.PropertyLaziness[i] && !action.PerformOnLazyProperty)
 					{
 						//do nothing to avoid a lazy property initialization
 						continue;