Reduce verbosity of object initializer syntax

[tuespetre]

First let me say that I am very pleased that you offer both fluent and object initialization syntaxes. There are times where I will use one or the other.

That being said, I feel that there can be some excessive verbosity when writing a complex query using the object initializer syntax. The following example illustrates all three of the points I have noticed so far:

var aggregations = new Dictionary<string, IAggregationContainer>
{
    {
        "my_aggregation", new AggregationContainer
        {
            Filter = new FilterAggregator
            {
                Filter = (FilterContainer)new QueryFilter
                {
                    Query = (QueryContainer)new QueryStringQuery
                    {
                       Query = "Just an example"
                    }
                }
            }
        }
    }
};

• PlainQuery will implicitly cast to QueryContainer but not IQueryContainer
• PlainFilter will implicitly cast to FilterContainer but not IFilterContainer
• Aggregators must be wrapped in an AggregationContainer even if you are only specifying that aggregator without any subaggregations or other options; there is no cast from a single aggregator to a container like there is for queries and filters, let alone a cast to IAggregationContainer

If such casting was offered by the library, the above snippet could look like this:

var aggregations = new Dictionary<string, IAggregationContainer>
{
    {
        "my_aggregation", new FilterAggregator
        {
            Filter = new QueryFilter
            {
                Query = new QueryStringQuery
                {
                    Query = "Just an example"
                }
            }
        }
    }
};

[Mpdreamz]

C# does not support implicit casts to interfaces otherwise we would have totally added it!

The properties need to be actual interfaces because both the fluent and object initializer syntaxes need to assign to them.

In addition to implicit cast support Containers also support adding what they contain in the constructor or calling .ToContainer() on the containee's. That said these are missing for AggregationContainer and its Aggregators as showcased in the attached unit tests and we should totally add that!

[tuespetre]

C# does not support implicit casts to interfaces otherwise we would have totally added it!

Aw damn, well, the more you know!

This syntax would still be nice for aggregations:

var aggregations = new Dictionary<string, IAggregationContainer>
{
    {
        "my_aggregation", (AggregationContainer)new FilterAggregator
        {
            Filter = (FilterContainer)new QueryFilter
            {
                Query = (QueryContainer)new QueryStringQuery
                {
                    Query = "Just an example"
                }
            }
        }
    }
};

[tuespetre]

Hmmm, maybe I will have to take that statement back. The way it is now is very much 1-to-1 with the anonymous object / JSON API.

[Mpdreamz]

Hey @tuespetre in 2.0 we will introduce a much terser API for aggregations when using the Object Initializer syntax have a sneak peak:

new SearchRequest<Project>
{
    Aggregations = new ChildrenAgg("name_of_child_agg", typeof(CommitActivity))
    {
        Aggregations = 
            new AverageAgg("average_per_child", Field<CommitActivity>(p=>p.ConfidenceFactor))
            && new MaxAgg("max_per_child", Field<CommitActivity>(p=>p.ConfidenceFactor))
    }
};

The old object initializer syntax will also still work.

Similarly you'll no longer need the casts for filtercontainer in the object initializer query dsl

new SearchRequest<Project>
{
    Query = new TermQuery
    {
        Field = "name",
        Value = "elasticsearch"
    }
};