added propertyname inferrer to IConnectionSettings so you can override how NEST handles unspecified propertynames without supplying your own JsonContractResolver

Author: Mpdreamz

src/Nest.Tests.Unit/Core/Index/IndexTests.cs

@@ -13,42 +13,40 @@
 
 namespace Nest.Tests.Unit.Core.Index
 {
-	[TestFixture]
-	public class IndexTests : BaseJsonTests
-	{
-		[Test]
-		public void IndexParameters()
-		{
-			var o = new ElasticSearchProject { Id = 1, Name = "Test" };
-			var result = this._client.Index(o, new IndexParameters 
-			{ 
-				Version = "1",
+  [TestFixture]
+  public class IndexTests : BaseJsonTests
+  {
+    [Test]
+    public void IndexParameters()
+    {
+      var o = new ElasticSearchProject { Id = 1, Name = "Test" };
+      var result = this._client.Index(o, new IndexParameters
+      {
+        Version = "1",
+      });
+      var status = result.ConnectionStatus;
+      StringAssert.Contains("version=1", status.RequestUrl);
+    }
 
-			});
-			var status = result.ConnectionStatus;
-			StringAssert.Contains("version=1", status.RequestUrl);
-		}
-	
-		[Test]
-		public void IndexingDictionaryRespectsCasing()
-		{
-			var x = new
-			{
-				FirstDictionary = new Dictionary<string, object>
+    [Test]
+    public void IndexingDictionaryRespectsCasing()
+    {
+      var x = new
+      {
+        FirstDictionary = new Dictionary<string, object>
 				{
 					{"ALLCAPS", 1 },
 					{"PascalCase", "should work as well"},
 					{"camelCase", DateTime.Now}
 				}
-			};
-			var result = this._client.Index(x);
+      };
+      var result = this._client.Index(x);
 
-			var request = result.ConnectionStatus.Request;
-			StringAssert.Contains("ALLCAPS", request);
-			StringAssert.Contains("PascalCase", request);
-			StringAssert.Contains("camelCase", request);
-			StringAssert.Contains("firstDictionary", request);
-
-		}
-	}
+      var request = result.ConnectionStatus.Request;
+      StringAssert.Contains("ALLCAPS", request);
+      StringAssert.Contains("PascalCase", request);
+      StringAssert.Contains("camelCase", request);
+      StringAssert.Contains("firstDictionary", request);
+    }
+  }
 }

src/Nest/Domain/Connection/ConnectionSettings.cs

@@ -35,6 +35,7 @@ public string DefaultIndex
 		public FluentDictionary<Type, string> DefaultIndices { get; private set; }
 		public FluentDictionary<Type, string> DefaultTypeNames { get; private set; }
 		public NameValueCollection QueryStringParameters { get; private set; }
+    public Func<string, string> DefaultPropertyNameInferrer { get; private set; }
 
 		public ConnectionSettings(Uri uri)
 		{
@@ -160,6 +161,19 @@ private void ConnectionStatusDefaultHandler(ConnectionStatus status)
 			return;
 		}
 
+    /// <summary>
+    /// By default NEST camelCases property names (EmailAddress => emailAddress) that do not have an explicit propertyname 
+    /// either via an ElasticProperty attribute or because they are part of Dictionary where the keys should be treated verbatim.
+    /// <pre>
+    /// Here you can register a function that transforms propertynames (default casing, pre- or suffixing)
+    /// </pre>
+    /// </summary>
+    public ConnectionSettings SetDefaultPropertyNameInferrer(Func<string, string> propertyNameSelector)
+    {
+      this.DefaultPropertyNameInferrer = propertyNameSelector;
+      return this;
+    }
+
 		public ConnectionSettings SetDefaultTypeNameInferrer(Func<Type, string> defaultTypeNameInferrer)
 		{
 			defaultTypeNameInferrer.ThrowIfNull("defaultTypeNameInferrer");
@@ -187,5 +201,6 @@ public ConnectionSettings MapDefaultTypeNames(Action<FluentDictionary<Type, stri
 			return this;
 		}
 
-	}
+
+  }
 }

src/Nest/Domain/Connection/IConnectionSettings.cs

@@ -1,28 +1,30 @@
-using System;
+using System;
 using System.Collections.Specialized;
-
-namespace Nest
-{
-    public interface IConnectionSettings
-    {
-        FluentDictionary<Type, string> DefaultIndices { get; }
-        FluentDictionary<Type, string> DefaultTypeNames { get; }
-        string DefaultIndex { get; }
 
-		Uri Uri { get; }
-		int MaximumAsyncConnections { get; }
-        string Host { get; }
-        int Port { get; }
-        int Timeout { get; }
-        string ProxyAddress { get; }
-        string ProxyUsername { get; }
-        string ProxyPassword { get; }
-
-		bool TraceEnabled { get; }
-		bool DontDoubleEscapePathDotsAndSlashes { get; }
-        NameValueCollection QueryStringParameters { get; }
-        Action<ConnectionStatus> ConnectionStatusHandler { get; }
+namespace Nest
+{
+  public interface IConnectionSettings
+  {
+    FluentDictionary<Type, string> DefaultIndices { get; }
+    FluentDictionary<Type, string> DefaultTypeNames { get; }
+    string DefaultIndex { get; }
 
-        Func<Type, string> DefaultTypeNameInferrer { get; }	
-    }
-}
+    Uri Uri { get; }
+    int MaximumAsyncConnections { get; }
+    string Host { get; }
+    int Port { get; }
+    int Timeout { get; }
+    string ProxyAddress { get; }
+    string ProxyUsername { get; }
+    string ProxyPassword { get; }
+
+    bool TraceEnabled { get; }
+    bool DontDoubleEscapePathDotsAndSlashes { get; }
+    NameValueCollection QueryStringParameters { get; }
+    Action<ConnectionStatus> ConnectionStatusHandler { get; }
+
+    Func<string, string> DefaultPropertyNameInferrer { get; }
+
+    Func<Type, string> DefaultTypeNameInferrer { get; }
+  }
+}

src/Nest/ElasticSerializer.cs

@@ -108,7 +108,7 @@ public T Deserialize<T>(string value, IEnumerable<JsonConverter> extraConverters
 				var concrete = extraConverters.OfType<ConcreteTypeConverter>().FirstOrDefault();
 				if (concrete != null)
 				{
-					((ElasticResolver)settings.ContractResolver).ConcreteTypeConverter = concrete;
+					((ElasticContractResolver)settings.ContractResolver).ConcreteTypeConverter = concrete;
 				}
 				else
 					settings.Converters = settings.Converters.Concat(extraConverters).ToList();
@@ -120,7 +120,7 @@ private JsonSerializerSettings CreateSettings()
 		{
 			return new JsonSerializerSettings()
 			{
-				ContractResolver = new ElasticCamelCaseResolver(this._settings),
+				ContractResolver = new ElasticContractResolver(this._settings),
 				NullValueHandling = NullValueHandling.Ignore,
 				DefaultValueHandling = DefaultValueHandling.Include,
 				Converters = _defaultConverters.Concat(_extraConverters).ToList()

src/Nest/Nest.csproj

@@ -539,7 +539,7 @@
     <Compile Include="DSL\Query\Term.cs" />
     <Compile Include="DSL\Query\Wildcard.cs" />
     <Compile Include="ElasticClient-Search.cs" />
-    <Compile Include="Resolvers\ElasticSearchJsonResolver.cs" />
+    <Compile Include="Resolvers\ElasticContractResolver.cs" />
     <Compile Include="Enums\Consistency.cs" />
     <Compile Include="Enums\FacetTypes.cs" />
     <Compile Include="Enums\Replication.cs" />

src/Nest/RawElasticClient.cs

@@ -13,71 +13,29 @@ namespace Nest
 {
 	public partial class RawElasticClient : IRawElasticClient
 	{
-		protected IConnection Connection { get; set; }
+		public IConnection Connection { get; protected set; }
 		public IConnectionSettings Settings { get; protected set; }
+    public ElasticSerializer Serializer { get; protected set; }
 
 		public RawElasticClient(IConnectionSettings settings)
 			: this(settings, new Connection(settings))
 		{
 
 		}
 
-		internal readonly JsonSerializerSettings SerializationSettings;
-		internal readonly JsonSerializerSettings IndexSerializationSettings;
-		internal readonly PropertyNameResolver PropertyNameResolver;
-		private readonly List<JsonConverter> _extraConverters = new List<JsonConverter>();
-
-		private readonly List<JsonConverter> _defaultConverters = new List<JsonConverter>
-		{
-			new IsoDateTimeConverter(),
-			new FacetConverter()
-		};
-
-		private JsonSerializerSettings CreateSettings()
-		{
-			return new JsonSerializerSettings()
-			{
-				ContractResolver = new ElasticResolver(this.Settings),
-				NullValueHandling = NullValueHandling.Ignore,
-				DefaultValueHandling = DefaultValueHandling.Include,
-				Converters = _defaultConverters.Concat(_extraConverters).ToList()
-			};
-		}
-		public void AddConverter(JsonConverter converter)
-		{
-			this.IndexSerializationSettings.Converters.Add(converter);
-			this.SerializationSettings.Converters.Add(converter);
-			_extraConverters.Add(converter);
-		}
-
-		public void ModifyJsonSerializationSettings(Action<JsonSerializerSettings> modifier)
-		{
-			modifier(this.IndexSerializationSettings);
-			modifier(this.SerializationSettings);
-		}
-
-		/// <summary>
-		/// serialize an object using the internal registered converters without camelcasing properties as is done 
-		/// while indexing objects
-		/// </summary>
-		public string Serialize(object @object)
-		{
-			return JsonConvert.SerializeObject(@object, Formatting.Indented, this.SerializationSettings);
-		}
-
 		public RawElasticClient(IConnectionSettings settings, IConnection connection)
 		{
 			if (settings == null)
 				throw new ArgumentNullException("settings");
 
 			this.Settings = settings;
 			this.Connection = connection;
+      this.Serializer = new ElasticSerializer(this.Settings);
+		}
 
-			this.SerializationSettings = this.CreateSettings();
-			var indexSettings = this.CreateSettings();
-
-			indexSettings.ContractResolver = new ElasticCamelCaseResolver(this.Settings);
-			this.IndexSerializationSettings = indexSettings;
+		public string Serialize(object @object)
+		{
+      return this.Serializer.Serialize(@object);
 		}
 
 		protected ConnectionStatus DoRequest(string method, string path, object data = null,  NameValueCollection queryString = null)

src/Nest/Resolvers/Converters/ConcreteTypeConverter.cs

@@ -32,7 +32,7 @@ public ConcreteTypeConverter(Type baseType, Func<dynamic, Hit<dynamic>, Type> co
 
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
-			var realConcreteConverter = ((ElasticResolver) serializer.ContractResolver).ConcreteTypeConverter;
+			var realConcreteConverter = ((ElasticContractResolver) serializer.ContractResolver).ConcreteTypeConverter;
 
 			if (realConcreteConverter != null)
 			{

src/Nest/Resolvers/Converters/IndexNameMarkerConverter.cs

@@ -23,7 +23,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 				return;
 			}
 
-			var settings = serializer.ContractResolver as ElasticResolver;
+			var settings = serializer.ContractResolver as ElasticContractResolver;
 			if (settings != null && settings.ConnectionSettings != null)
 			{
 				var typeName = marker.Resolve(settings.ConnectionSettings);

src/Nest/Resolvers/Converters/IndexSettingsConverter.cs

@@ -105,7 +105,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 			writer.WriteEndObject();
 			if (indexSettings.Mappings.Count > 0)
 			{
-				var settings = serializer.ContractResolver as ElasticResolver;
+				var settings = serializer.ContractResolver as ElasticContractResolver;
 				if (settings != null && settings.ConnectionSettings != null)
 				{
 					writer.WritePropertyName("mappings");

src/Nest/Resolvers/Converters/TypeNameMarkerConverter.cs

@@ -22,7 +22,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 				writer.WriteNull();
 				return;
 			}
-			var settings = serializer.ContractResolver as ElasticResolver;
+			var settings = serializer.ContractResolver as ElasticContractResolver;
 			if (settings != null && settings.ConnectionSettings != null)
 			{
 				var typeName = marker.Resolve(settings.ConnectionSettings);