Performance Improvements

- Cache JsonContracts per ConnectionSettings
- Cache Delegates per ConnectionSettings for constructing items in a MultiGetResponse
- Cache Delegates per ConnectionSettings for constructing items in a MultiSearchResponse
- Reuse Inferrer on ConnectionSettings
- Reduce complexity in getting IUrlParameter.GetString() for IndexName and TypeName

Author: russcam

src/Nest/CommonAbstractions/Extensions/JsonExtensions.cs

@@ -14,7 +14,7 @@ public static IConnectionSettingsValues GetConnectionSettings(this JsonSerialize
 		{
 			var contract = serializer.ContractResolver as ElasticContractResolver;
 			if (contract?.ConnectionSettings == null)
-				throw new Exception("If you use a custom contract resolver be sure to subclass from ElasticResolver");
+				throw new Exception("If you use a custom contract resolver be sure to subclass from " + nameof(ElasticContractResolver));
 			return contract.ConnectionSettings;
 		}
 

src/Nest/CommonAbstractions/Extensions/TypeExtensions.cs

@@ -12,18 +12,21 @@ namespace Nest
 {
 	internal static class TypeExtensions
 	{
-		private static MethodInfo GetActivatorMethodInfo = typeof(TypeExtensions).GetMethod("GetActivator", BindingFlags.Static | BindingFlags.NonPublic);
+		private static readonly MethodInfo GetActivatorMethodInfo =
+			typeof(TypeExtensions).GetMethod(nameof(GetActivator), BindingFlags.Static | BindingFlags.NonPublic);
 
-		private static ConcurrentDictionary<string, ObjectActivator<object>> _cachedActivators = new ConcurrentDictionary<string, ObjectActivator<object>>();
-		private static ConcurrentDictionary<string, Type> _cachedGenericClosedTypes = new ConcurrentDictionary<string, Type>();
+		private static readonly ConcurrentDictionary<string, ObjectActivator<object>> CachedActivators =
+			new ConcurrentDictionary<string, ObjectActivator<object>>();
 
+		private static readonly ConcurrentDictionary<string, Type> CachedGenericClosedTypes =
+			new ConcurrentDictionary<string, Type>();
 
-		private static ConcurrentDictionary<Type, IList<JsonProperty>> _cachedTypeProperties =
+		private static readonly ConcurrentDictionary<Type, IList<JsonProperty>> CachedTypeProperties =
 			new ConcurrentDictionary<Type, IList<JsonProperty>>();
 
 		//this contract is only used to resolve properties in class WE OWN.
 		//these are not subject to change depending on what the user passes as connectionsettings
-		private static ElasticContractResolver _jsonContract = new ElasticContractResolver(new ConnectionSettings(), null);
+		private static readonly ElasticContractResolver JsonContract = new ElasticContractResolver(new ConnectionSettings(), null);
 
 		public delegate T ObjectActivator<out T>(params object[] args);
 
@@ -37,10 +40,10 @@ internal static object CreateGenericInstance(this Type t, Type[] closeOver, para
 			var argKey = closeOver.Aggregate(new StringBuilder(), (sb, gt) => sb.Append("--" + gt.FullName), sb => sb.ToString());
 			var key = t.FullName + argKey;
 			Type closedType;
-			if (!_cachedGenericClosedTypes.TryGetValue(key, out closedType))
+			if (!CachedGenericClosedTypes.TryGetValue(key, out closedType))
 			{
 				closedType = t.MakeGenericType(closeOver);
-				_cachedGenericClosedTypes.TryAdd(key, closedType);
+				CachedGenericClosedTypes.TryAdd(key, closedType);
 			}
 			return closedType.CreateInstance(args);
 		}
@@ -50,25 +53,23 @@ internal static object CreateGenericInstance(this Type t, Type[] closeOver, para
 		internal static object CreateInstance(this Type t, params object[] args)
 		{
 			ObjectActivator<object> activator;
-			var argLength = args.Count();
-			//var argKey = string.Join(",", args.Select(a => a.GetType().Name));
-			var argKey = argLength;
+			var argKey = args.Length;
 			var key = argKey + "--" + t.FullName;
-			if (_cachedActivators.TryGetValue(key, out activator))
+			if (CachedActivators.TryGetValue(key, out activator))
 				return activator(args);
-			var generic = GetActivatorMethodInfo.MakeGenericMethod(t);
 
+			var generic = GetActivatorMethodInfo.MakeGenericMethod(t);
 			var constructors = from c in t.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
 							   let p = c.GetParameters()
 							   let k = string.Join(",", p.Select(a => a.ParameterType.Name))
-							   where p.Count() == argLength //&& k == argKey
+							   where p.Length == args.Length
 							   select c;
+
 			var ctor = constructors.FirstOrDefault();
 			if (ctor == null)
-				throw new Exception("Cannot create an instance of " + t.FullName
-				                    + " because it has no constructor taking " + argLength + " arguments");
+				throw new Exception($"Cannot create an instance of {t.FullName} because it has no constructor taking {args.Length} arguments");
 			activator = (ObjectActivator<object>)generic.Invoke(null, new[] { ctor });
-			_cachedActivators.TryAdd(key, activator);
+			CachedActivators.TryAdd(key, activator);
 			return activator(args);
 		}
 
@@ -85,7 +86,7 @@ private static ObjectActivator<T> GetActivator<T>(ConstructorInfo ctor)
 			Expression[] argsExp =
 				new Expression[paramsInfo.Length];
 
-			//pick each arg from the params array 
+			//pick each arg from the params array
 			//and create a typed expression of them
 			for (int i = 0; i < paramsInfo.Length; i++)
 			{
@@ -118,10 +119,10 @@ private static ObjectActivator<T> GetActivator<T>(ConstructorInfo ctor)
 		internal static IList<JsonProperty> GetCachedObjectProperties(this Type t, MemberSerialization memberSerialization = MemberSerialization.OptIn)
 		{
 			IList<JsonProperty> propertyDictionary;
-			if (_cachedTypeProperties.TryGetValue(t, out propertyDictionary))
+			if (CachedTypeProperties.TryGetValue(t, out propertyDictionary))
 				return propertyDictionary;
-			propertyDictionary = _jsonContract.PropertiesOfAll(t, memberSerialization);
-			_cachedTypeProperties.TryAdd(t, propertyDictionary);
+			propertyDictionary = JsonContract.PropertiesOfAll(t, memberSerialization);
+			CachedTypeProperties.TryAdd(t, propertyDictionary);
 			return propertyDictionary;
 		}
 
@@ -163,4 +164,4 @@ internal static IEnumerable<Type> GetInterfaces(this Type type)
 		}
 #endif
 	}
-}
+}

src/Nest/CommonAbstractions/Fields/FieldValues.cs

@@ -51,7 +51,7 @@ public K[] Values<T, K>(Expression<Func<T, K>> objectPath)
 		}
 
 
-		private static JsonSerializer ForceNoDateInferrence = new JsonSerializer
+		private static readonly JsonSerializer ForceNoDateInferrence = new JsonSerializer
 		{
 			DateParseHandling = DateParseHandling.None
 		};
@@ -62,21 +62,21 @@ private K FieldArray<K>(string field)
 			if (this.BackingDictionary != null && this.BackingDictionary.TryGetValue(field, out o))
 			{
 				var t = typeof(K);
-				if (o is JArray && t.GetInterfaces().Contains(typeof(IEnumerable)))
+				var jArray = o as JArray;
+				if (jArray != null && t.GetInterfaces().Contains(typeof(IEnumerable)))
 				{
-					var array = (JArray)o;
-					if (typeof(K) == typeof(string[]) && array.Count > 0 && array.Any(p=>p.Type == JTokenType.Date))
+					if (typeof(K) == typeof(string[]) && jArray.Any(p=>p.Type == JTokenType.Date))
 					{
 						// https://github.com/elastic/elasticsearch-net/issues/2155
 						// o of type JArray has already decided the values are dates so there is no
 						// way around this.
 						// incredibly ugly and sad but the only way I found to cover this edgecase
-						var s = array.Root.ToString();
+						var s = jArray.Root.ToString();
 						using (var sr = new StringReader(s))
 						using (var jr = new JsonTextReader(sr) { DateParseHandling = DateParseHandling.None })
 							return ForceNoDateInferrence.Deserialize<K>(jr);
 					}
-					return array.ToObject<K>();
+					return jArray.ToObject<K>();
 				}
 				return (K)Convert.ChangeType(o, typeof(K));
 			}

src/Nest/CommonAbstractions/Infer/Field/Field.cs

@@ -160,8 +160,8 @@ string IUrlParameter.GetString(IConnectionConfigurationValues settings)
 			var nestSettings = settings as IConnectionSettingsValues;
 			if (nestSettings == null)
 				throw new Exception("Tried to pass field name on querysting but it could not be resolved because no nest settings are available");
-			var infer = new Inferrer(nestSettings);
-			return infer.Field(this);
+
+			return nestSettings.Inferrer.Field(this);
 		}
 
 		private void SetComparisonValue(object value)

src/Nest/CommonAbstractions/Infer/Id/IdJsonConverter.cs

@@ -17,12 +17,13 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
-			var id = value as Id;
-			if (id == null)
+			if (value == null)
 			{
 				writer.WriteNull();
 				return;
 			}
+
+			var id = (Id)value;
 			if (id.Document != null)
 			{
 				var settings = serializer.GetConnectionSettings();

src/Nest/CommonAbstractions/Infer/IndexName/IndexName.cs

@@ -69,7 +69,14 @@ public bool EqualsMarker(IndexName other)
 			return false;
 		}
 
-		public string GetString(IConnectionConfigurationValues settings) => ((IUrlParameter)(Indices)(Indices.Index(this))).GetString(settings);
+		public string GetString(IConnectionConfigurationValues settings)
+		{
+			var nestSettings = settings as IConnectionSettingsValues;
+			if (nestSettings == null)
+				throw new Exception("Tried to pass index name on querysting but it could not be resolved because no nest settings are available");
+
+			return nestSettings.Inferrer.IndexName(this);
+		}
 
 		public static IndexName From<T>() => typeof(T);
 

src/Nest/CommonAbstractions/Infer/IndexName/IndexNameResolver.cs

@@ -16,9 +16,9 @@ public IndexNameResolver(IConnectionSettingsValues connectionSettings)
 
 		public string Resolve(IndexName i)
 		{
-			if (i == null || string.IsNullOrEmpty(i.Name))
-				return this.Resolve(i.Type);
-			return i.Name;
+			return string.IsNullOrEmpty(i?.Name)
+				? this.Resolve(i.Type)
+				: i.Name;
 		}
 
 		public string Resolve(Type type)

src/Nest/CommonAbstractions/Infer/Indices/Indices.cs

@@ -56,7 +56,7 @@ string IUrlParameter.GetString(IConnectionConfigurationValues settings)
 				{
 					var nestSettings = settings as IConnectionSettingsValues;
 					if (nestSettings == null)
-						throw new Exception("Tried to pass field name on querysting but it could not be resolved because no nest settings are available");
+						throw new Exception("Tried to pass index names on querysting but it could not be resolved because no nest settings are available");
 
 					var infer = nestSettings.Inferrer;
 					var indices = many.Indices.Select(i => infer.IndexName(i)).Distinct();

src/Nest/CommonAbstractions/Infer/Inferrer.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 namespace Nest
 {
@@ -12,13 +15,21 @@ public class Inferrer
 		private TypeNameResolver TypeNameResolver { get; }
 		private FieldResolver FieldResolver { get; }
 
+		// TODO: Find some better place for this
+		internal ConcurrentDictionary<Type, JsonContract> Contracts { get; set; }
+		internal ConcurrentDictionary<Type, Action<MultiGetHitJsonConverter.MultiHitTuple, JsonSerializer, ICollection<IMultiGetHit<object>>>> CreateMultiHitDelegates { get; set; }
+		internal ConcurrentDictionary<Type, Action<MultiSearchResponseJsonConverter.SearchHitTuple, JsonSerializer, IDictionary<string, object>>> CreateSearchResponseDelegates { get; set; }
+
 		public Inferrer(IConnectionSettingsValues connectionSettings)
 		{
 			connectionSettings.ThrowIfNull(nameof(connectionSettings));
 			this.IdResolver = new IdResolver(connectionSettings);
 			this.IndexNameResolver = new IndexNameResolver(connectionSettings);
 			this.TypeNameResolver = new TypeNameResolver(connectionSettings);
 			this.FieldResolver = new FieldResolver(connectionSettings);
+			this.Contracts = new ConcurrentDictionary<Type, JsonContract>();
+			this.CreateMultiHitDelegates = new ConcurrentDictionary<Type, Action<MultiGetHitJsonConverter.MultiHitTuple, JsonSerializer, ICollection<IMultiGetHit<object>>>>();
+			this.CreateSearchResponseDelegates = new ConcurrentDictionary<Type, Action<MultiSearchResponseJsonConverter.SearchHitTuple, JsonSerializer, IDictionary<string, object>>>();
 		}
 
 		public string Field(Field field) => this.FieldResolver.Resolve(field);
@@ -28,7 +39,7 @@ public Inferrer(IConnectionSettingsValues connectionSettings)
 		public string IndexName<T>() where T : class => this.IndexNameResolver.Resolve<T>();
 
 		public string IndexName(IndexName index) => this.IndexNameResolver.Resolve(index);
-		
+
 		public string Id<T>(T obj) where T : class => this.IdResolver.Resolve(obj);
 
 		public string Id(Type objType, object obj) => this.IdResolver.Resolve(objType, obj);

src/Nest/CommonAbstractions/Infer/TypeName/TypeName.cs

@@ -79,11 +79,18 @@ public bool EqualsString(string other)
 			return !other.IsNullOrEmpty() && other == this.Name;
 		}
 
-		string IUrlParameter.GetString(IConnectionConfigurationValues settings) => ((IUrlParameter)(Types)(Types.Type(this))).GetString(settings);
+		string IUrlParameter.GetString(IConnectionConfigurationValues settings)
+		{
+			var nestSettings = settings as IConnectionSettingsValues;
+			if (nestSettings == null)
+				throw new Exception("Tried to pass type name on querystring but it could not be resolved because no nest settings are available");
+
+			return nestSettings.Inferrer.TypeName(this);
+		}
 
 		public static TypeName From<T>() => typeof(T);
 
 		public Types And<T>() => new Types(new TypeName[] { this, typeof(T)});
 		public Types And(TypeName type) => new Types(new TypeName[] { this, type });
 	}
-}
+}