Ignoring propertiesedit

Properties on a POCO can be ignored for mapping purposes in a few ways:

  • Using the Ignore property on a derived ElasticsearchPropertyAttribute type applied to the property that should be ignored on the POCO
  • Using the .DefaultMappingFor<TDocument>(Func<ClrTypeMappingDescriptor<TDocument>, IClrTypeMapping<TDocument>> selector) on ConnectionSettings
  • Using an ignore attribute applied to the POCO property that is understood by the IElasticsearchSerializer used, and inspected inside of the CreatePropertyMapping() on the serializer. Using the builtin SourceSerializer this would be the IgnoreProperty

This example demonstrates all ways, using the Ignore property on the attribute to ignore the property PropertyToIgnore, the infer mapping to ignore the property AnotherPropertyToIgnore and the json serializer specific attribute to ignore the property either IgnoreProperty or JsonIgnoredProperty depending on which SourceSerializer we configured.

[ElasticsearchType(RelationName = "company")]
public class CompanyWithAttributesAndPropertiesToIgnore
{
    public string Name { get; set; }

    [Text(Ignore = true)]
    public string PropertyToIgnore { get; set; }

    public string AnotherPropertyToIgnore { get; set; }

    [Ignore, JsonIgnore]
    public string JsonIgnoredProperty { get; set; }
}

All of the properties except Name have been ignored in the mapping

var connectionSettings = new ConnectionSettings(new InMemoryConnection()) 
    .DisableDirectStreaming() 
    .DefaultMappingFor<CompanyWithAttributesAndPropertiesToIgnore>(m => m
        .Ignore(p => p.AnotherPropertyToIgnore)
    );

var client = new ElasticClient(connectionSettings);

var createIndexResponse = client.Indices.Create("myindex", c => c
    .Map<CompanyWithAttributesAndPropertiesToIgnore>(m => m
        .AutoMap()
    )
);

we’re using an in-memory connection, but in your application, you’ll want to use an IConnection that actually sends a request.

we disable direct streaming here to capture the request and response bytes. In a production application, you would likely not call this as it adds overhead to each call.

The JSON output for the mapping does not contain the ignored properties

{
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      }
    }
  }
}

Ignoring inherited propertiesedit

By using the DefaultMappingFor<T>() configuration for a POCO on the ConnectionSettings, it is possible to ignore inherited properties too

public class Parent
{
    public int Id { get; set; }
    public string Description { get; set; }
    public string IgnoreMe { get; set; }
}

public class Child : Parent { }

var connectionSettings = new ConnectionSettings(new InMemoryConnection())
        .DisableDirectStreaming()
        .DefaultMappingFor<Child>(m => m
            .PropertyName(p => p.Description, "desc")
            .Ignore(p => p.IgnoreMe)
        );

var client = new ElasticClient(connectionSettings);

var createIndexResponse = client.Indices.Create("myindex", c => c
        .Map<Child>(m => m
            .AutoMap()
        )
    );

The property IgnoreMe has been ignored for the child mapping

{
  "mappings": {
    "properties": {
      "id": {
        "type": "integer"
      },
      "desc": {
        "fields": {
          "keyword": {
            "ignore_above": 256,
            "type": "keyword"
          }
        },
        "type": "text"
      }
    }
  }
}

Overriding inherited propertiesedit

DefaultMappingFor<T>() configuration for a POCO on the ConnectionSettings can also be used to override inherited properties.

In the following example, the Id property is shadowed in ParentWithStringId as a string type, resulting in NEST’s automapping inferring the mapping as the default text with keyword multi-field field datatype mapping for a string type.

public class ParentWithStringId : Parent
{
    public new string Id { get; set; }
}

var connectionSettings = new ConnectionSettings(new InMemoryConnection()) 
        .DisableDirectStreaming() 
        .DefaultMappingFor<ParentWithStringId>(m => m
            .Ignore(p => p.Description)
            .Ignore(p => p.IgnoreMe)
        );

var client = new ElasticClient(connectionSettings);

var createIndexResponse = client.Indices.Create("myindex", c => c
        .Map<ParentWithStringId>(m => m
            .AutoMap()
        )
    );

we’re using an in memory connection for this example. In your production application though, you’ll want to use an IConnection that actually sends a request.

we disable direct streaming here to capture the request and response bytes. In your production application however, you’ll likely not want to do this, since it causes the request and response bytes to be buffered in memory.

{
  "mappings": {
    "properties": {
      "id": {
        "type": "text",
        "fields": {
          "keyword": {
            "ignore_above": 256,
            "type": "keyword"
          }
        }
      }
    }
  }
}