Merge branch 'fix/5.x-dictionary-serialization' into 5.x

Author: russcam

src/Nest/CommonAbstractions/SerializationBehavior/ElasticContractResolver.cs

@@ -18,9 +18,9 @@ public class ElasticContractResolver : DefaultContractResolver
 		public static JsonSerializer Empty { get; } = new JsonSerializer();
 
 		/// <summary>
-		/// ConnectionSettings can be requested by JsonConverter's.
+		/// ConnectionSettings can be requested by JsonConverters.
 		/// </summary>
-		public IConnectionSettingsValues ConnectionSettings { get; private set; }
+		public IConnectionSettingsValues ConnectionSettings { get; }
 
 		/// <summary>
 		/// Signals to custom converter that it can get serialization state from one of the converters. Ugly but massive performance gain
@@ -40,21 +40,16 @@ protected override JsonContract CreateContract(Type objectType)
 			{
 				var contract = base.CreateContract(o);
 
-				if (typeof(IDictionary).IsAssignableFrom(o) && !typeof(IIsADictionary).IsAssignableFrom(o))
+				if ((typeof(IDictionary).IsAssignableFrom(o) || o.IsGenericDictionary()) && !typeof(IIsADictionary).IsAssignableFrom(o))
 				{
-					if (!o.IsGeneric())
-						contract.Converter = new VerbatimDictionaryKeysJsonConverter<object, object>();
+					Type[] genericArguments;
+					if (!o.TryGetGenericDictionaryArguments(out genericArguments))
+						contract.Converter = new VerbatimDictionaryKeysJsonConverter();
 					else
-					{
-						var genericArguments = o.GetGenericArguments();
-						if (genericArguments.Length != 2)
-							contract.Converter = new VerbatimDictionaryKeysJsonConverter<object, object>();
-						else
-							contract.Converter =
-								(JsonConverter)typeof(VerbatimDictionaryKeysJsonConverter<,>).CreateGenericInstance(genericArguments);
-					}
+						contract.Converter =
+							(JsonConverter)typeof(VerbatimDictionaryKeysJsonConverter<,>).CreateGenericInstance(genericArguments);
 				}
-				if (typeof(IEnumerable<QueryContainer>).IsAssignableFrom(o))
+				else if (typeof(IEnumerable<QueryContainer>).IsAssignableFrom(o))
 					contract.Converter = new QueryContainerCollectionJsonConverter();
 				else if (o == typeof(ServerError))
 					contract.Converter = new ServerErrorJsonConverter();

src/Nest/CommonAbstractions/SerializationBehavior/GenericJsonConverters/VerbatimDictionaryKeysConverter.cs

@@ -12,9 +12,105 @@ namespace Nest
 	/// JSON converter for IDictionary that ignores the contract resolver (e.g. CamelCaseFieldNamesContractResolver)
 	/// when converting dictionary keys to property names.
 	/// </summary>
+	internal class VerbatimDictionaryKeysJsonConverter : JsonConverter
+	{
+		public override bool CanConvert(Type t) => typeof(IDictionary).IsAssignableFrom(t);
+
+		public override bool CanRead => false;
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			var dictionary = (IDictionary)value;
+			if (dictionary == null)
+			{
+				writer.WriteNull();
+				return;
+			}
+
+			var settings = serializer.GetConnectionSettings();
+			var seenEntries = new Dictionary<string, object>(dictionary.Count);
+
+			Field fieldName;
+			PropertyName propertyName;
+			IndexName indexName;
+			TypeName typeName;
+
+			foreach (DictionaryEntry entry in dictionary)
+			{
+				if (entry.Value == null && serializer.NullValueHandling == NullValueHandling.Ignore)
+					continue;
+				string key;
+				if (settings == null)
+					key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
+				else if (AsType(entry.Key, out fieldName))
+				{
+					key = settings.Inferrer.Field(fieldName);
+				}
+				else if (AsType(entry.Key, out propertyName))
+				{
+					if (propertyName?.Property != null)
+					{
+						IPropertyMapping mapping;
+						if (settings.PropertyMappings.TryGetValue(propertyName.Property, out mapping) && mapping.Ignore)
+						{
+							continue;
+						}
+					}
+
+					key = settings.Inferrer.PropertyName(propertyName);
+				}
+				else if (AsType(entry.Key, out indexName))
+				{
+					key = settings.Inferrer.IndexName(indexName);
+				}
+				else if (AsType(entry.Key, out typeName))
+				{
+					key = settings.Inferrer.TypeName(typeName);
+				}
+				else
+					key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
+
+				if (key != null)
+					seenEntries[key] = entry.Value;
+			}
+
+			writer.WriteStartObject();
+			foreach (var entry in seenEntries)
+			{
+				writer.WritePropertyName(entry.Key);
+				serializer.Serialize(writer, entry.Value);
+			}
+			writer.WriteEndObject();
+		}
+
+		private static bool AsType<T>(object value, out T convertedValue) where T : class
+		{
+			convertedValue = value as T;
+			return convertedValue != null;
+		}
+	}
+
+	/// <summary>
+	/// JSON converter for IDictionary&lt;TKey,TValue&gt; and IReadOnlyDictionary&lt;TKey,TValue&gt;
+	/// that ignores the contract resolver (e.g. CamelCaseFieldNamesContractResolver)
+	/// when converting dictionary keys to property names.
+	/// </summary>
 	internal class VerbatimDictionaryKeysJsonConverter<TKey, TValue> : JsonConverter
 	{
-		public override bool CanConvert(Type t) => typeof (IDictionary<TKey, TValue>).IsAssignableFrom(t);
+		private readonly bool _keyIsString = typeof(TKey) == typeof(string);
+		private readonly bool _keyIsField = typeof(TKey) == typeof(Field);
+		private readonly bool _keyIsPropertyName = typeof(TKey) == typeof(PropertyName);
+		private readonly bool _keyIsIndexName = typeof(TKey) == typeof(IndexName);
+		private readonly bool _keyIsTypeName = typeof(TKey) == typeof(TypeName);
+
+		public override bool CanConvert(Type t) =>
+			typeof(IDictionary<TKey, TValue>).IsAssignableFrom(t) ||
+			typeof(IReadOnlyDictionary<TKey, TValue>).IsAssignableFrom(t);
 
 		public override bool CanRead => false;
 
@@ -25,32 +121,31 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
-			var dictionary = value as IDictionary<TKey, TValue>;
-			if (dictionary == null) return;
+			var enumerable = (IEnumerable<KeyValuePair<TKey, TValue>>)value;
+			if (enumerable == null)
+			{
+				writer.WriteNull();
+				return;
+			}
 
 			var settings = serializer.GetConnectionSettings();
-			var seenEntries = new Dictionary<string, TValue>(dictionary.Count);
-			var keyIsString = typeof(TKey) == typeof(string);
-			var keyIsField = typeof(TKey) == typeof(Field);
-			var keyIsPropertyName = typeof(TKey) == typeof(PropertyName);
-			var keyIsIndexName = typeof(TKey) == typeof(IndexName);
-			var keyIsTypeName = typeof(TKey) == typeof(TypeName);
-
-			foreach (var entry in dictionary)
+			var seenEntries = new Dictionary<string, TValue>(enumerable.Count());
+
+			foreach (var entry in enumerable)
 			{
 				if (entry.Value == null && serializer.NullValueHandling == NullValueHandling.Ignore)
 					continue;
 				string key;
-				if (keyIsString)
+				if (_keyIsString)
 					key = entry.Key?.ToString();
 				else if (settings == null)
 					key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
-				else if (keyIsField)
+				else if (_keyIsField)
 				{
 					var fieldName = entry.Key as Field;
 					key = settings.Inferrer.Field(fieldName);
 				}
-				else if (keyIsPropertyName)
+				else if (_keyIsPropertyName)
 				{
 					var propertyName = entry.Key as PropertyName;
 					if (propertyName?.Property != null)
@@ -64,12 +159,12 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 
 					key = settings.Inferrer.PropertyName(propertyName);
 				}
-				else if (keyIsIndexName)
+				else if (_keyIsIndexName)
 				{
 					var indexName = entry.Key as IndexName;
 					key = settings.Inferrer.IndexName(indexName);
 				}
-				else if (keyIsTypeName)
+				else if (_keyIsTypeName)
 				{
 					var typeName = entry.Key as TypeName;
 					key = settings.Inferrer.TypeName(typeName);

src/Nest/CrossPlatform/TypeExtensions.cs

@@ -13,10 +13,35 @@ internal static bool IsGeneric(this Type type)
 #if DOTNETCORE
 			return type.GetTypeInfo().IsGenericType;
 #else
-		return type.IsGenericType;
+			return type.IsGenericType;
 #endif
 		}
 
+		internal static bool IsGenericDictionary(this Type type)
+		{
+			return type.GetInterfaces().Any(t =>
+				t.IsGeneric() && (
+				t.GetGenericTypeDefinition() == typeof(IDictionary<,>) ||
+				t.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary<,>)));
+		}
+
+		internal static bool TryGetGenericDictionaryArguments(this Type type, out Type[] genericArguments)
+		{
+			var genericDictionary = type.GetInterfaces().FirstOrDefault(t =>
+				t.IsGeneric() && (
+				t.GetGenericTypeDefinition() == typeof(IDictionary<,>) ||
+				t.GetGenericTypeDefinition() == typeof(IReadOnlyDictionary<,>)));
+
+			if (genericDictionary == null)
+			{
+				genericArguments = new Type[0];
+				return false;
+			}
+
+			genericArguments = genericDictionary.GetGenericArguments();
+			return true;
+		}
+
 		internal static bool IsValue(this Type type)
 		{
 #if DOTNETCORE