Disable append-hashcode when not built for netFx

Under .Net Core, hashcodes are not stable, causing distributed cache
to be segregated by process

Author: fredericDelaporte

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/CoreDistributedCacheProviderFixture.cs

@@ -68,6 +68,7 @@ public void TestExpiration()
 		[Test]
 		public void TestAppendHashcodeToKey()
 		{
+#if NETFX
 			Assert.That(CoreDistributedCacheProvider.AppendHashcodeToKey, Is.True, "Default is not true");
 
 			var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
@@ -83,6 +84,23 @@ public void TestAppendHashcodeToKey()
 			{
 				CoreDistributedCacheProvider.AppendHashcodeToKey = true;
 			}
+#else
+			Assert.That(CoreDistributedCacheProvider.AppendHashcodeToKey, Is.False, "Default is not false");
+
+			var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
+			Assert.That(cache.AppendHashcodeToKey, Is.False, "First built cache not correctly set");
+
+			CoreDistributedCacheProvider.AppendHashcodeToKey = true;
+			try
+			{
+				cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache;
+				Assert.That(cache.AppendHashcodeToKey, Is.True, "Second built cache not correctly set");
+			}
+			finally
+			{
+				CoreDistributedCacheProvider.AppendHashcodeToKey = false;
+			}
+#endif
 		}
 	}
 }

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/CoreDistributedCacheSectionHandlerFixture.cs

@@ -48,13 +48,23 @@ public void TestGetConfigNullSection()
 			Assert.That(config.Properties.Count, Is.EqualTo(0), "Properties count");
 			Assert.That(config.Regions, Is.Not.Null, "Regions");
 			Assert.That(config.Regions.Length, Is.EqualTo(0));
-			Assert.That(config.AppendHashcodeToKey, Is.True);
+			Assert.That(config.AppendHashcodeToKey,
+#if NETFX
+				Is.True
+#else
+				Is.False
+#endif
+				);
 		}
 
 		[Test]
 		public void TestGetConfigFromFile()
 		{
-			const string xmlSimple = "<coredistributedcache factory-class=\"factory1\" append-hashcode=\"false\"><properties><property name=\"prop1\">Value1</property></properties><cache region=\"foo\" expiration=\"500\" sliding=\"true\" /></coredistributedcache>";
+			const string xmlSimple =
+				"<coredistributedcache factory-class=\"factory1\" append-hashcode=\"false\">" +
+				"<properties><property name=\"prop1\">Value1</property></properties>" +
+				"<cache region=\"foo\" expiration=\"500\" sliding=\"true\" append-hashcode=\"true\" />" +
+				"</coredistributedcache>";
 
 			var handler = new CoreDistributedCacheSectionHandler();
 			var section = GetConfigurationSection(xmlSimple);
@@ -77,6 +87,8 @@ public void TestGetConfigFromFile()
 			Assert.That(config.Regions[0].Properties["cache.use_sliding_expiration"], Is.EqualTo("true"));
 			Assert.That(config.Regions[0].Properties, Does.ContainKey("expiration"));
 			Assert.That(config.Regions[0].Properties["expiration"], Is.EqualTo("500"));
+			Assert.That(config.Regions[0].Properties, Does.ContainKey("cache.use_sliding_expiration"));
+			Assert.That(config.Regions[0].Properties["cache.use_sliding_expiration"], Is.EqualTo("true"));
 
 			Assert.That(config.AppendHashcodeToKey, Is.False);
 		}

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CacheConfig.cs

@@ -46,8 +46,7 @@ public CacheConfig(
 
 		/// <summary>Should the keys be appended with their hashcode?</summary>
 		/// <remarks>This option is a workaround for distinguishing composite-id missing an
-		/// <see cref="object.ToString"/> override. It may causes trouble if the cache is shared
-		/// between processes running different runtimes.</remarks>
+		/// <see cref="object.ToString"/> override.</remarks>
 		public bool AppendHashcodeToKey { get; }
 
 		/// <summary>The configured cache regions.</summary>
@@ -68,14 +67,29 @@ public class RegionConfig
 		/// <param name="region">The configured cache region.</param>
 		/// <param name="expiration">The expiration for the region.</param>
 		/// <param name="sliding">Whether the expiration should be sliding or not.</param>
-		public RegionConfig(string region, string expiration, string sliding)
+		// Since 5.5
+		[Obsolete("Use overload with appendHashcodeToKey additional parameter")]
+		public RegionConfig(string region, string expiration, string sliding) : this(region, expiration, sliding, null)
+		{
+		}
+
+		/// <summary>
+		/// Build a cache region configuration.
+		/// </summary>
+		/// <param name="region">The configured cache region.</param>
+		/// <param name="expiration">The expiration for the region.</param>
+		/// <param name="sliding">Whether the expiration should be sliding or not.</param>
+		/// <param name="appendHashcodeToKey">Should the keys be appended with their hashcode?</param>
+		public RegionConfig(string region, string expiration, string sliding, string appendHashcodeToKey)
 		{
 			Region = region;
 			Properties = new Dictionary<string, string>();
 			if (!string.IsNullOrEmpty(expiration))
 				Properties["expiration"] = expiration;
 			if (!string.IsNullOrEmpty(sliding))
 				Properties["cache.use_sliding_expiration"] = sliding;
+			if (!string.IsNullOrEmpty(appendHashcodeToKey))
+				Properties["cache.append_hashcode_to_key"] = appendHashcodeToKey;
 		}
 
 		/// <summary>The region name.</summary>

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CoreDistributedCache.cs

@@ -44,6 +44,7 @@ public partial class CoreDistributedCache : ICache
 
 		private static readonly TimeSpan DefaultExpiration = TimeSpan.FromSeconds(300);
 		private const bool _defaultUseSlidingExpiration = false;
+		private const bool _defaultAppendHashcodeToKey = false;
 		private static readonly string DefaultRegionPrefix = string.Empty;
 		private const string _cacheKeyPrefix = "NHibernate-Cache:";
 
@@ -96,11 +97,20 @@ public CoreDistributedCache(
 		public bool UseSlidingExpiration { get; private set; }
 
 		/// <summary>Should the keys be appended with their hashcode?</summary>
-		/// <remarks>This option is a workaround for distinguishing composite-id missing an
+		/// <remarks>
+		/// <para>
+		/// This option is a workaround for distinguishing composite-id missing an
 		/// <see cref="object.ToString"/> override. It may causes trouble if the cache is shared
-		/// between processes running different runtimes. Configure it through
-		/// <see cref="CoreDistributedCacheProvider.AppendHashcodeToKey"/>.</remarks>
-		public bool AppendHashcodeToKey { get; internal set; }
+		/// between processes running another runtime than .Net Framework, or with future versions
+		/// of .Net Framework: the hascode is not guaranteed to be stable.
+		/// </para>
+		/// <para>
+		/// The value of this property can be set with the attribute <c>append-hashcode</c> of the
+		/// region configuration node, or globally through
+		/// <see cref="CoreDistributedCacheProvider.AppendHashcodeToKey"/>.
+		/// </para>
+		/// </remarks>
+		public bool AppendHashcodeToKey { get; private set; }
 
 		private void Configure(IDictionary<string, string> props)
 		{
@@ -110,12 +120,14 @@ private void Configure(IDictionary<string, string> props)
 				Log.Warn("Configuring cache with default values");
 				Expiration = DefaultExpiration;
 				UseSlidingExpiration = _defaultUseSlidingExpiration;
+				AppendHashcodeToKey = _defaultAppendHashcodeToKey;
 			}
 			else
 			{
 				Expiration = GetExpiration(props);
 				UseSlidingExpiration = GetUseSlidingExpiration(props);
 				regionPrefix = GetRegionPrefix(props);
+				AppendHashcodeToKey = GetAppendHashcodeToKey(props);
 			}
 
 			_fullRegion = regionPrefix + RegionName;
@@ -172,6 +184,13 @@ private static bool GetUseSlidingExpiration(IDictionary<string, string> props)
 			return sliding;
 		}
 
+		private static bool GetAppendHashcodeToKey(IDictionary<string, string> props)
+		{
+			var append = PropertiesHelper.GetBoolean("cache.append_hashcode_to_key", props, _defaultAppendHashcodeToKey);
+			Log.Debug("Use append hashcode to key value: {0}", append);
+			return append;
+		}
+
 		private string GetCacheKey(object key)
 		{
 			var baseKey = _cacheKeyPrefix + _fullRegion + ":" + key;

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CoreDistributedCacheProvider.cs

@@ -51,14 +51,18 @@ public class CoreDistributedCacheProvider : ICacheProvider
 		public static IDistributedCacheFactory CacheFactory { get; set; }
 
 		/// <summary>Should the keys be appended with their hashcode?</summary>
-		/// <value><see langword="true" /> by default.</value>
+		/// <value>By defauly <see langword="true" /> for the .Net Framework build,
+		/// <see langword="false" /> otherwise. This setting will be <c>false</c> by default
+		/// for all runtime in the next major release (6.0).</value>
 		/// <remarks>
 		/// <para>This option is a workaround for distinguishing composite-id missing an
 		/// <see cref="object.ToString"/> override. It may causes trouble if the cache is shared
-		/// between processes running different runtimes.
+		/// between processes running another runtime than .Net Framework, or with future versions
+		/// of .Net Framework: the hascode is not guaranteed to be stable.
 		/// </para>
 		/// <para>
-		/// Changes to this property affect only caches built after the change.
+		/// Changes to this property affect only caches built after the change, and whose configuration node
+		/// does not define their own <c>append-hashcode</c> attribute.
 		/// </para>
 		/// <para>
 		/// The value of this property can be set with the attribute <c>append-hashcode</c> of the
@@ -120,28 +124,22 @@ public ICache BuildCache(string regionName, IDictionary<string, string> properti
 				regionName = string.Empty;
 			}
 
+			properties = properties != null
+				// Duplicate it for not altering the global configuration
+				? new Dictionary<string, string>(properties)
+				: new Dictionary<string, string>();
+
+			properties["cache.append_hashcode_to_key"] = AppendHashcodeToKey.ToString();
+
 			if (ConfiguredCachesProperties.TryGetValue(regionName, out var configuredProperties) && configuredProperties.Count > 0)
 			{
-				if (properties != null)
-				{
-					// Duplicate it for not altering the global configuration
-					properties = new Dictionary<string, string>(properties);
-					foreach (var prop in configuredProperties)
-					{
-						properties[prop.Key] = prop.Value;
-					}
-				}
-				else
+				foreach (var prop in configuredProperties)
 				{
-					properties = configuredProperties;
+					properties[prop.Key] = prop.Value;
 				}
 			}
 
 			// create cache
-			if (properties == null)
-			{
-				properties = new Dictionary<string, string>(1);
-			}
 
 			if (Log.IsDebugEnabled())
 			{
@@ -159,10 +157,7 @@ public ICache BuildCache(string regionName, IDictionary<string, string> properti
 				Log.Debug("building cache with region: {0}, properties: {1}, factory: {2}" , regionName, sb.ToString(), CacheFactory.GetType().FullName);
 			}
 			return
-				new CoreDistributedCache(CacheFactory.BuildCache(), CacheFactory.Constraints, regionName, properties)
-				{
-					AppendHashcodeToKey = AppendHashcodeToKey
-				};
+				new CoreDistributedCache(CacheFactory.BuildCache(), CacheFactory.Constraints, regionName, properties);
 		}
 
 		/// <inheritdoc />

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CoreDistributedCacheSectionHandler.cs

@@ -26,9 +26,10 @@ public object Create(object parent, object configContext, XmlNode section)
 				var region = node.Attributes["region"]?.Value;
 				var expiration = node.Attributes["expiration"]?.Value;
 				var sliding = node.Attributes["sliding"]?.Value;
+				var appendHashcode = node.Attributes["append-hashcode"]?.Value;
 				if (region != null)
 				{
-					caches.Add(new RegionConfig(region, expiration, sliding));
+					caches.Add(new RegionConfig(region, expiration, sliding, appendHashcode));
 				}
 				else
 				{
@@ -53,8 +54,16 @@ public object Create(object parent, object configContext, XmlNode section)
 						node.OuterXml);
 				}
 			}
-			var appendHashcodeToKey = !StringComparer.OrdinalIgnoreCase.Equals(
-				section.Attributes?["append-hashcode"]?.Value, "false");
+
+			var appendHashcodeToKey =
+// 6.0 TODO: disable for all cases by default (so keep only the else code)
+#if NETFX
+				!StringComparer.OrdinalIgnoreCase.Equals(
+					section.Attributes?["append-hashcode"]?.Value, "false");
+#else
+				StringComparer.OrdinalIgnoreCase.Equals(
+					section.Attributes?["append-hashcode"]?.Value, "true");
+#endif
 
 			return new CacheConfig(factoryClass, properties, caches.ToArray(), appendHashcodeToKey);
 		}