Honour DataMember and DataContract attributes (#3304)

* Honour DataMember and DataContract attributes

This commit updates the behaviour of TypeNameResolver and
PropertyMapping to respect the usage of DataMember and
DataContract attributes for all requests.

Prior behaviour to this commit was that indexing would honour
DataMember attributes on a document due to the internal implementation of
JSON.Net honouring them. With other requests such as Search however,
where a Field type is used, the resolution of the Field string name did
not honour the attributes.

Include behaviour in documentation

Closes #3107

(cherry picked from commit 97455b8)

Author: russcam

docs/client-concepts/high-level/inference/field-inference.asciidoc

@@ -116,7 +116,8 @@ Expect("name")
 To ease creating a `Field` instance from expressions, there is a static `Infer` class you can use
 
 [TIP]
-This example uses the https://msdn.microsoft.com/en-us/library/sf0df423.aspx#Anchor_0[static import] `using static Nest.Infer;` in the using directives to shorthand `Nest.Infer.Field<T>()`
+This example uses the https://msdn.microsoft.com/en-us/library/sf0df423.aspx#Anchor_0[static import] `using static Nest.Infer;`
+in the using directives to shorthand `Nest.Infer.Field<T>()`
 to simply `Field<T>()`. Be sure to include this static import if copying any of these examples.
 
 [source,csharp]
@@ -324,6 +325,7 @@ Expect("leadDeveloper.firstName.raw.evendeeper").WhenSerializing(multiSuffixFiel
 Expect("metadata.hardcoded.raw.evendeeper").WhenSerializing(multiSuffixFieldExpressions[4]);
 ----
 
+[[field-name-attribute]]
 ==== Attribute based naming
 
 Using NEST's property attributes you can specify a new name for the properties
@@ -339,9 +341,29 @@ public class BuiltIn
 Expect("naam").WhenSerializing(Field<BuiltIn>(p => p.Name));
 ----
 
-Starting with NEST 2.x, we also ask the serializer if it can resolve a property to a name.
-Here we ask the default `JsonNetSerializer` to resolve a property name and it takes
-the `JsonPropertyAttribute` into account
+[[data-member-field-attribute]]
+==== DataMember attributes
+
+If a property has a `System.Runtime.Serialization.DataMemberAttribute` applied, this can be used to resolve
+a field value for a property
+
+[source,csharp]
+----
+public class DataMember
+{
+    [DataMember(Name = "nameFromDataMember")]
+    public string Name { get; set; }
+}
+
+Expect("nameFromDataMember").WhenSerializing(Field<DataMember>(p => p.Name));
+----
+
+[[serializer-specific-field-attribute]]
+==== Serializer specific attributes
+
+NEST can also use a serializer specific attribute to resolve a field value for a property.
+In this example, we use the `JsonPropertyAttribute` to resolve a field, which is understood
+by the default `JsonNetSerializer`
 
 [source,csharp]
 ----
@@ -441,13 +463,15 @@ fieldNameOnB.Should().Be("c.name");
 
 To wrap up, the precedence in which field names are inferred is:
 
-. A hard rename of the property on connection settings using `.Rename()`
+. A naming of the property on `ConnectionSettings` using `.Rename()`
 
 . A NEST property mapping
 
-. Ask the serializer if the property has a verbatim value e.g it has an explicit JsonProperty attribute.
+. Ask the serializer if the property has a verbatim value, e.g. it has a `JsonPropertyAttribute` when using the default `JsonNetSerializer`
 
-. Pass the MemberInfo's Name to the DefaultFieldNameInferrer, which by default camelCases
+. See if the `MemberInfo` has a `DataMemberAttribute` applied
+
+. Pass the `MemberInfo` to the `DefaultFieldNameInferrer`, which by default will camel case the `Name` property
 
 The following example class will demonstrate this precedence
 
@@ -469,6 +493,9 @@ class Precedence
     [JsonProperty("dontaskme")]
     public string AskSerializer { get; set; } <4>
 
+    [DataMember(Name = "data")]
+    public string DataMember { get; set; }
+
     public string DefaultFieldNameInferrer { get; set; } <5>
 }
 ----
@@ -489,7 +516,6 @@ Here we create a custom serializer that renames any property named `AskSerialize
 class CustomSerializer : JsonNetSerializer
 {
     public CustomSerializer(IConnectionSettingsValues settings) : base(settings) { }
-
     public override IPropertyMapping CreatePropertyMapping(MemberInfo memberInfo)
     {
         return memberInfo.Name == nameof(Precedence.AskSerializer)
@@ -516,6 +542,7 @@ usingSettings.Expect("renamed").ForField(Field<Precedence>(p => p.RenamedOnConne
 usingSettings.Expect("nestAtt").ForField(Field<Precedence>(p => p.NestAttribute));
 usingSettings.Expect("jsonProp").ForField(Field<Precedence>(p => p.JsonProperty));
 usingSettings.Expect("ask").ForField(Field<Precedence>(p => p.AskSerializer));
+usingSettings.Expect("data").ForField(Field<Precedence>(p => p.DataMember));
 usingSettings.Expect("DEFAULTFIELDNAMEINFERRER").ForField(Field<Precedence>(p => p.DefaultFieldNameInferrer));
 ----
 
@@ -529,14 +556,16 @@ usingSettings.Expect(new []
     "DEFAULTFIELDNAMEINFERRER",
     "jsonProp",
     "nestAtt",
-    "renamed"
+    "renamed",
+    "data"
 }).AsPropertiesOf(new Precedence
 {
     RenamedOnConnectionSettings = "renamed on connection settings",
     NestAttribute = "using a nest attribute",
     JsonProperty = "the default serializer resolves json property attributes",
     AskSerializer = "serializer fiddled with this one",
-    DefaultFieldNameInferrer = "shouting much?"
+    DefaultFieldNameInferrer = "shouting much?",
+    DataMember = "using a DataMember attribute"
 });
 
 public class Parent

docs/client-concepts/high-level/inference/type-name-inference.asciidoc

@@ -0,0 +1,74 @@
+:ref_current: https://www.elastic.co/guide/en/elasticsearch/reference/5.6
+
+:github: https://github.com/elastic/elasticsearch-net
+
+:nuget: https://www.nuget.org/packages
+
+////
+IMPORTANT NOTE
+==============
+This file has been generated from https://github.com/elastic/elasticsearch-net/tree/5.x/src/Tests/ClientConcepts/HighLevel/Inference/TypeNameInference.doc.cs. 
+If you wish to submit a PR for any spelling mistakes, typos or grammatical errors for this file,
+please modify the original csharp file found at the link and submit the PR with that change. Thanks!
+////
+
+[[type-name-inference]]
+=== Type name inference
+
+Type names are resolved in NEST by default, by lowercasing the CLR type name
+
+[source,csharp]
+----
+var settings = new ConnectionSettings();
+var resolver = new TypeNameResolver(settings);
+var type = resolver.Resolve<Project>();
+type.Should().Be("project");
+----
+
+[[elasticsearchtype-attribute]]
+==== Applying a type name with `ElasticsearchTypeAttribute`
+
+A type name can be applied for a CLR type, using the Name property on `ElasticsearchTypeAttribute`
+
+[source,csharp]
+----
+[ElasticsearchType(Name = "attributed_project")]
+public class AttributedProject { }
+
+var settings = new ConnectionSettings();
+var resolver = new TypeNameResolver(settings);
+var type = resolver.Resolve<AttributedProject>();
+type.Should().Be("attributed_project");
+----
+
+[[datacontract-attribute]]
+==== Applying a type name with `DataContractAttribute`
+
+Similarly to <<elasticsearchtype-attribute, `ElasticsearchTypeAttribute`>>, a type name can be applied for a
+CLR type, using the Name property on `System.Runtime.Serialization.DataContractAttribute`
+
+[source,csharp]
+----
+[DataContract(Name = "data_contract_project")]
+public class DataContractProject { }
+
+var settings = new ConnectionSettings();
+var resolver = new TypeNameResolver(settings);
+var type = resolver.Resolve<DataContractProject>();
+type.Should().Be("data_contract_project");
+----
+
+[[type-name-inferrer]]
+==== Override type name inferrer
+
+You can provide a delegate to override the default type name inferrer for types
+
+[source,csharp]
+----
+var settings = new ConnectionSettings()
+    .DefaultTypeNameInferrer(t=>t.Name.ToLower() + "-suffix");
+var resolver = new TypeNameResolver(settings);
+var type = resolver.Resolve<Project>();
+type.Should().Be("project-suffix");
+----
+

docs/high-level.asciidoc

@@ -29,14 +29,16 @@ the `.LowLevel` property on `ElasticClient`.
 
 There are a number of conventions that NEST uses for inference of
 
-* <<index-name-inference, Index Names>>
-
-* <<indices-paths, Building a URI path to one or more indices>>
+* <<index-name-inference, Index names>>
 
-* <<field-inference, Field names>> and <<property-inference, Property names>>
+* <<type-name-inference, Type names>>
 
 * <<ids-inference, Document IDs>>
 
+* <<field-inference, Field names>> 
+
+* <<property-inference, Property names>>
+
 * <<document-paths, Building a URI path to a document>>
 
 * <<features-inference, API features>>
@@ -120,10 +122,10 @@ There are several ways to control mapping in NEST
 
 * <<auto-map, Auto mapping (inferred from POCO property types)>>
 
-* <<attribute-mapping, Attribute mapping>>
-
 * <<fluent-mapping, Fluent mapping>>
 
+* <<attribute-mapping, Attribute mapping>>
+
 * <<visitor-pattern-mapping, through the Visitor Pattern>>
 
 and these can be combined to form an overall mapping approach. In addition, there are also ways to control
@@ -134,10 +136,10 @@ and these can be combined to form an overall mapping approach. In addition, ther
 
 include::{output-dir}/mapping/auto-map.asciidoc[]
 
-include::{output-dir}/mapping/attribute-mapping.asciidoc[]
-
 include::{output-dir}/mapping/fluent-mapping.asciidoc[]
 
+include::{output-dir}/mapping/attribute-mapping.asciidoc[]
+
 include::{output-dir}/mapping/visitor-pattern-mapping.asciidoc[]
 
 include::{output-dir}/mapping/ignoring-properties.asciidoc[]
@@ -203,35 +205,37 @@ include::aggregations/reserved-aggregation-names.asciidoc[]
 
 There are a number of conventions that NEST uses for inference of
 
-* <<document-paths, Document paths>>
+* <<index-name-inference, Index names>>
 
-* <<features-inference, API features>>
+* <<type-name-inference, Type names>>
 
-* <<field-inference, Fields>>
+* <<ids-inference, Document Ids>>
 
-* <<ids-inference, Ids>>
+* <<field-inference, Document field names>>
 
-* <<index-name-inference, Index names>>
+* <<property-inference, Document properties>>
+
+* <<document-paths, Document paths>>	 
 
 * <<indices-paths, Index paths>>
 
-* <<property-inference, Properties>>
+* <<features-inference, API features>>
 
-:includes-from-dirs: client-concepts/high-level/inference
+include::{output-dir}/inference/index-name-inference.asciidoc[]
 
-include::client-concepts/high-level/inference/document-paths.asciidoc[]
+include::{output-dir}/inference/type-name-inference.asciidoc[]
 
-include::client-concepts/high-level/inference/features-inference.asciidoc[]
+include::{output-dir}/inference/ids-inference.asciidoc[]
 
-include::client-concepts/high-level/inference/field-inference.asciidoc[]
+include::{output-dir}/inference/field-inference.asciidoc[]
 
-include::client-concepts/high-level/inference/ids-inference.asciidoc[]
+include::{output-dir}/inference/property-inference.asciidoc[]
 
-include::client-concepts/high-level/inference/index-name-inference.asciidoc[]
+include::{output-dir}/inference/document-paths.asciidoc[]
 
-include::client-concepts/high-level/inference/indices-paths.asciidoc[]
+include::{output-dir}/inference/indices-paths.asciidoc[]
 
-include::client-concepts/high-level/inference/property-inference.asciidoc[]
+include::{output-dir}/inference/features-inference.asciidoc[]
 
 [[common-types]]
 == Common Types
@@ -240,9 +244,9 @@ NEST has a number of types for working with Elasticsearch conventions for
 
 * <<time-units, Time units>>
 
-* <<distance-units, Distance units>>
+* <<distance-units, Distance Units>>
 
-* <<date-math-expressions, Dat math expressions>>
+* <<date-math-expressions, Date math expressions>>
 
 include::common-options/time-unit/time-units.asciidoc[]
 

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

@@ -17,7 +17,7 @@ internal class HasVariableExpressionVisitor : ExpressionVisitor
 		private bool _found;
 		public bool Found
 		{
-			get { return _found; }
+			get => _found;
 			// This is only set to true once to prevent clobbering from subsequent node visits
 			private set { if (!_found) _found = value; }
 		}
@@ -36,11 +36,10 @@ public override Expression Visit(Expression node)
 
 		protected override Expression VisitMethodCall(MethodCallExpression node)
 		{
-			if (node.Method.Name == "Suffix" && node.Arguments.Any())
+			if (node.Method.Name == nameof(SuffixExtensions.Suffix) && node.Arguments.Any())
 			{
 				var lastArg = node.Arguments.Last();
-				var constantExpression = lastArg as ConstantExpression;
-				this.Found = constantExpression == null;
+				this.Found = !(lastArg is ConstantExpression);
 			}
 			else if (node.Method.Name == "get_Item" && node.Arguments.Any())
 			{
@@ -53,8 +52,7 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
 				if (!isDict)
 					return base.VisitMethodCall(node);
 				var lastArg = node.Arguments.Last();
-				var constantExpression = lastArg as ConstantExpression;
-				this.Found = constantExpression == null;
+				this.Found = !(lastArg is ConstantExpression);
 			}
 			return base.VisitMethodCall(node);
 		}
@@ -90,8 +88,7 @@ public string Resolve(MemberInfo info)
 
 			var name = info.Name;
 
-			IPropertyMapping propertyMapping = null;
-			if (this._settings.PropertyMappings.TryGetValue(info, out propertyMapping))
+			if (this._settings.PropertyMappings.TryGetValue(info, out var propertyMapping))
 				return propertyMapping.Name;
 
 			var att = ElasticsearchPropertyAttributeBase.From(info);
@@ -111,7 +108,7 @@ protected override Expression VisitMember(MemberExpression expression)
 
 		protected override Expression VisitMethodCall(MethodCallExpression methodCall)
 		{
-			if (methodCall.Method.Name == "Suffix" && methodCall.Arguments.Any())
+			if (methodCall.Method.Name == nameof(SuffixExtensions.Suffix) && methodCall.Arguments.Any())
 			{
 				VisitConstantOrVariable(methodCall, _stack);
 				var callingMember = new ReadOnlyCollection<Expression>(

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

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
+using System.Runtime.Serialization;
 
 namespace Nest
 {
@@ -21,9 +23,8 @@ public TypeNameResolver(IConnectionSettingsValues connectionSettings)
 		private string ResolveType(Type type)
 		{
 			if (type == null) return null;
-			string typeName;
 
-			if (TypeNames.TryGetValue(type, out typeName))
+			if (TypeNames.TryGetValue(type, out var typeName))
 				return typeName;
 
 			if (_connectionSettings.DefaultTypeNames.TryGetValue(type, out typeName))
@@ -36,11 +37,16 @@ private string ResolveType(Type type)
 			if (att != null && !att.Name.IsNullOrEmpty())
 				typeName = att.Name;
 			else
-				typeName = _connectionSettings.DefaultTypeNameInferrer(type);
+			{
+				var dataContract = type.GetAttributes<DataContractAttribute>().FirstOrDefault();
+				typeName = dataContract != null
+					? dataContract.Name
+					: _connectionSettings.DefaultTypeNameInferrer(type);
+			}
+			if (typeName.IsNullOrEmpty()) throw new ArgumentNullException($"{type.FullName} resolved to an empty string or null");
 
 			TypeNames.TryAdd(type, typeName);
 			return typeName;
 		}
-
 	}
 }