Convert EntityKey to struct

Author: bahusoid

src/NHibernate/Action/EntityIdentityInsertAction.cs

@@ -19,7 +19,7 @@ public EntityIdentityInsertAction(object[] state, object instance, IEntityPersis
 			: base(null, state, instance, persister, session)
 		{
 			this.isDelayed = isDelayed;
-			delayedEntityKey = this.isDelayed ? GenerateDelayedEntityKey() : null;
+			delayedEntityKey = this.isDelayed ? GenerateDelayedEntityKey() : EntityKey.Null;
 		}
 
 		public object GeneratedId

src/NHibernate/Async/Event/Default/AbstractSaveEventListener.cs

@@ -150,7 +150,7 @@ protected virtual async Task<object> PerformSaveAsync(object entity, object id,
 			}
 			else
 			{
-				key = null;
+				key = EntityKey.Null;
 			}
 
 			if (InvokeSaveLifecycle(entity, persister, source))
@@ -184,7 +184,7 @@ protected virtual async Task<object> PerformSaveOrReplicateAsync(object entity,
 			cancellationToken.ThrowIfCancellationRequested();
 			Validate(entity, persister, source);
 
-			object id = key == null ? null : key.Identifier;
+			object id = key.IsNull ? null : key.Identifier;
 
 			bool shouldDelayIdentityInserts = !requiresImmediateIdAccess;
 

src/NHibernate/Async/Event/Default/DefaultReplicateEventListener.cs

@@ -102,7 +102,7 @@ public virtual async Task OnReplicateAsync(ReplicateEvent @event, CancellationTo
 				}
 
 				bool regenerate = persister.IsIdentifierAssignedByInsert; // prefer re-generation of identity!
-				EntityKey key = regenerate ? null : source.GenerateEntityKey(id, persister);
+				EntityKey key = regenerate ? EntityKey.Null : source.GenerateEntityKey(id, persister);
 
 				await (PerformSaveOrReplicateAsync(entity, key, persister, regenerate, replicationMode, source, true, cancellationToken)).ConfigureAwait(false);
 			}

src/NHibernate/Async/Impl/MultiCriteriaImpl.cs

@@ -184,7 +184,7 @@ private async Task GetResultsFromDatabaseAsync(IList results, CancellationToken
 
 							object o =
 								await (loader.GetRowFromResultSetAsync(reader, session, queryParameters, loader.GetLockModes(queryParameters.LockModes),
-																					 null, hydratedObjects[i], keys, true, cancellationToken)).ConfigureAwait(false);
+																					 EntityKey.Null, hydratedObjects[i], keys, true, cancellationToken)).ConfigureAwait(false);
 							if (createSubselects[i])
 							{
 								subselectResultKeys[i].Add(keys);

src/NHibernate/Async/Loader/Loader.cs

@@ -113,7 +113,7 @@ protected async Task<object> LoadSingleRowAsync(DbDataReader resultSet, ISession
 			try
 			{
 				result =
-					await (GetRowFromResultSetAsync(resultSet, session, queryParameters, GetLockModes(queryParameters.LockModes), null,
+					await (GetRowFromResultSetAsync(resultSet, session, queryParameters, GetLockModes(queryParameters.LockModes), EntityKey.Null,
 										hydratedObjects, new EntityKey[entitySpan], returnProxies, cancellationToken)).ConfigureAwait(false);
 			}
 			catch (OperationCanceledException) { throw; }
@@ -178,7 +178,7 @@ internal async Task<object> GetRowFromResultSetAsync(DbDataReader resultSet, ISe
 				{
 					object entity = row[i];
 					var key = keys[i];
-					if (entity == null && key != null && IsChildFetchEntity(i))
+					if (entity == null && key.IsNotNull && IsChildFetchEntity(i))
 					{
 						// The entity was missing in the session, fallback on internal load (which will just yield a
 						// proxy if the persister supports it).
@@ -554,7 +554,7 @@ private async Task<EntityKey> GetKeyFromResultSetAsync(int i, IEntityPersister p
 				}
 			}
 
-			return resultId == null ? null : session.GenerateEntityKey(resultId, persister);
+			return resultId == null ? EntityKey.Null : session.GenerateEntityKey(resultId, persister);
 		}
 
 		/// <summary>
@@ -610,7 +610,7 @@ private async Task<object[]> GetRowAsync(DbDataReader rs, ILoadable[] persisters
 				object obj = null;
 				EntityKey key = keys[i];
 
-				if (key == null)
+				if (key.IsNull)
 				{
 					// do nothing
 					/* TODO NH-1001 : if (persisters[i]...EntityType) is an OneToMany or a ManyToOne and
@@ -736,7 +736,7 @@ private async Task<object> InstanceNotYetLoadedAsync(DbDataReader dr, int i, ILo
 
 			string instanceClass = await (GetInstanceClassAsync(dr, i, persister, key.Identifier, session, cancellationToken)).ConfigureAwait(false);
 
-			if (optionalObjectKey != null && key.Equals(optionalObjectKey))
+			if (optionalObjectKey.IsNotNull && key.Equals(optionalObjectKey))
 			{
 				// its the given optional object
 				obj = optionalObject;

src/NHibernate/Engine/EntityEntry.cs

@@ -192,7 +192,7 @@ public EntityKey EntityKey
 		{
 			get
 			{
-				if (cachedEntityKey == null)
+				if (cachedEntityKey.IsNull)
 				{
 					if (id == null)
 						throw new InvalidOperationException("cannot generate an EntityKey when id is null.");

src/NHibernate/Engine/EntityKey.cs

@@ -3,7 +3,6 @@
 using System.Security;
 using NHibernate.Impl;
 using NHibernate.Persister.Entity;
-using NHibernate.Type;
 
 namespace NHibernate.Engine
 {
@@ -12,28 +11,41 @@ namespace NHibernate.Engine
 	/// and the identifier space (eg. tablename)
 	/// </summary>
 	[Serializable]
-	public sealed class EntityKey : IDeserializationCallback, ISerializable, IEquatable<EntityKey>
+	public struct EntityKey : ISerializable, IEquatable<EntityKey>
 	{
+		public static EntityKey Null { get; } = new EntityKey();
+
+		public bool IsNull => identifier == null;
+		public bool IsNotNull => !IsNull;
+
 		private readonly object identifier;
 		private readonly IEntityPersister _persister;
 		// hashcode may vary among processes, they cannot be stored and have to be re-computed after deserialization
-		[NonSerialized]
-		private int? _hashCode;
+		private readonly int _hashCode;
 
 		/// <summary> Construct a unique identifier for an entity class instance</summary>
 		public EntityKey(object id, IEntityPersister persister)
 		{
 			identifier = id ?? throw new AssertionFailure("null identifier");
 			_persister = persister;
-			_hashCode = GenerateHashCode();
+			_hashCode = GenerateHashCode(persister, id);
 		}
 
 		private EntityKey(SerializationInfo info, StreamingContext context)
 		{
 			identifier = info.GetValue(nameof(Identifier), typeof(object));
+			if (identifier == null)
+			{
+				_hashCode = 0;
+				_persister = null;
+				return;
+			}
+
 			var factory = (ISessionFactoryImplementor) info.GetValue(nameof(_persister.Factory), typeof(ISessionFactoryImplementor));
-			var entityName = (string) info.GetValue(nameof(EntityName), typeof(string));
+			var entityName = info.GetString(nameof(EntityName));
+
 			_persister = factory.GetEntityPersister(entityName);
+			_hashCode = GenerateHashCode(_persister, identifier);
 		}
 
 		public bool IsBatchLoadable => _persister.IsBatchLoadable;
@@ -54,10 +66,8 @@ public override bool Equals(object other)
 
 		public bool Equals(EntityKey other)
 		{
-			if (other == null)
-			{
-				return false;
-			}
+			if (other.IsNull)
+				return IsNull;
 
 			return
 				other.RootEntityName.Equals(RootEntityName)
@@ -66,39 +76,34 @@ public bool Equals(EntityKey other)
 
 		public override int GetHashCode()
 		{
-			// If the object is put in a set or dictionary during deserialization, the hashcode will not yet be
-			// computed. Compute the hashcode on the fly. So long as this happens only during deserialization, there
-			// will be no thread safety issues. For the hashcode to be always defined after deserialization, the
-			// deserialization callback is used.
-			return _hashCode ?? GenerateHashCode();
-		}
-
-		/// <inheritdoc />
-		public void OnDeserialization(object sender)
-		{
-			_hashCode = GenerateHashCode();
+			return _hashCode;
 		}
 
-		private int GenerateHashCode()
+		private static int GenerateHashCode(IEntityPersister persister, object id)
 		{
 			int result = 17;
 			unchecked
 			{
-				result = 37 * result + RootEntityName.GetHashCode();
-				result = 37 * result + _persister.IdentifierType.GetHashCode(identifier, _persister.Factory);
+				result = 37 * result + persister.RootEntityName.GetHashCode();
+				result = 37 * result + persister.IdentifierType.GetHashCode(id, persister.Factory);
 			}
 			return result;
 		}
 
 		public override string ToString()
 		{
-			return "EntityKey" + MessageHelper.InfoString(_persister, Identifier, _persister.Factory);
+			return IsNull
+				? Util.StringHelper.NullObject 
+				: "EntityKey" + MessageHelper.InfoString(_persister, Identifier, _persister?.Factory);
 		}
 
 		[SecurityCritical]
 		public void GetObjectData(SerializationInfo info, StreamingContext context)
 		{
 			info.AddValue(nameof(Identifier), identifier);
+			if (identifier == null)
+				return;
+
 			info.AddValue(nameof(_persister.Factory), _persister.Factory);
 			info.AddValue(nameof(EntityName), EntityName);
 		}

src/NHibernate/Engine/StatefulPersistenceContext.cs

@@ -753,7 +753,7 @@ public object NarrowProxy(INHibernateProxy proxy, IEntityPersister persister, En
 		/// </summary>
 		public object ProxyFor(IEntityPersister persister, EntityKey key, object impl)
 		{
-			if (!persister.HasProxy || key == null)
+			if (!persister.HasProxy || key.IsNull)
 				return impl;
 
 			INHibernateProxy proxy;

src/NHibernate/Event/Default/AbstractSaveEventListener.cs

@@ -177,7 +177,7 @@ protected virtual object PerformSave(object entity, object id, IEntityPersister
 			}
 			else
 			{
-				key = null;
+				key = EntityKey.Null;
 			}
 
 			if (InvokeSaveLifecycle(entity, persister, source))
@@ -209,7 +209,7 @@ protected virtual object PerformSaveOrReplicate(object entity, EntityKey key, IE
 		{
 			Validate(entity, persister, source);
 
-			object id = key == null ? null : key.Identifier;
+			object id = key.IsNull ? null : key.Identifier;
 
 			bool shouldDelayIdentityInserts = !requiresImmediateIdAccess;
 

src/NHibernate/Event/Default/DefaultReplicateEventListener.cs

@@ -95,7 +95,7 @@ public virtual void OnReplicate(ReplicateEvent @event)
 				}
 
 				bool regenerate = persister.IsIdentifierAssignedByInsert; // prefer re-generation of identity!
-				EntityKey key = regenerate ? null : source.GenerateEntityKey(id, persister);
+				EntityKey key = regenerate ? EntityKey.Null : source.GenerateEntityKey(id, persister);
 
 				PerformSaveOrReplicate(entity, key, persister, regenerate, replicationMode, source, true);
 			}