Fix dictionary serialization

Change in b062c5e did not handle a number of dictionary cases including

- types that implement IReadOnlyDictionary<TKey,TValue>
- types that implement IDictionary<TKey, TValue>
- non-generic types that inherit a closed generic dictionary type
- types that implement IDictionary that are not generic

Include serialization tests for all the above cases and additionally, serialize null when the cast value in the json converter is null

(cherry picked from commit 9557b99)

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