如何在C＃中动态构建Func Lambda表达式

Question

I have an ElasticSearch database in which I want to perform an aggregation. I'm using NEST and lambda expression to create the query.

However, I need to perform the aggregation on multiple fields of the same document (channel1 and channel2) at the same time. Currently I have 2 channels so my query works fine over them.

    var res = elasticClient.Search<DataRecord>(s => s
        .Index(ElasticIndexName)
        .Aggregations(a => a
            .DateHistogram("mydoc", h => h
                .Aggregations(ag => ag.Average("avg1", b => b.Field("channel1")).Average("avg2", b => b.Field("channel2")))
            )
        )
    );

The problem is that the no. of channels could be different, maybe three or four or whatever so I'd like to have my Func below

ag => ag.Average("avg1", b => b.Field("channel1")).Average("avg2", b => b.Field("channel2"))

to be dynamically created (like you do on a SQL query for example) because the no. of channels is known only at runtime.

Eg If I have four channels the query should be like:

  var res = elasticClient.Search<DataRecord>(s => s
        .Index(ElasticIndexName)
        .Aggregations(a => a
            .DateHistogram("mydoc", h => h
                .Aggregations(ag => ag.Average("avg1", b => b.Field("channel1")).Average("avg2", b => b.Field("channel2")).Average("avg3", b => b.Field("channel3")).Average("avg4", b => b.Field("channel4")))
            )
        )
    );

So basically I need some kind of for loop in which I can build the lambda expression dinamically

Answer 1

Try using the System.Linq.Expressions namespace. It contains various expression types which you can use to construct an expression tree, which you can then compile and run dynamically.

https://msdn.microsoft.com/en-us/library/system.linq.expressions%28v=vs.110%29.aspx

You can use the LoopExpression if you need it. Alternatively, if you know the number needed at the time of expression tree creation, you could loop using normal C# code to add in the repeated functionality to basically unroll the loop. You can cast the compiled expression to the desired Func type if you wish (or specify this in the generic arguments of the Lambda method), to use a strongly-typed approach. You can see this in the example in the link I posted.

EDIT: Based on your requirements, you probably do not need to use the Expressions namespace if you do not want to, though you still could. Perhaps you may want to write an extension method like this:

// Replace the return type "object" with the type you expect returned from the Average call
// Replace the "object" in 'this object @this' with the type of 'ag' in the lambda 'h.Aggregations(ag => ag'
public static object AverageChannels(this object @this, int channelCount) // alternatively, obtain the channel count from the input variable if this can be done
{
    if (channelCount < 1)
    {
      // do something
    }

    var result = @this.Average("avg1", b => b.Field("channel1");
    for (int i = 2; i < channelCount + 1; i++)
    {
        var avgText = "avg" + i.ToString();
        var channelText = "channel" + i.ToString();
        result = result .Average(avgText, b => b.Field(channelText))
    }

    return result;
}

This will call .Average at least once if the count is greater than 0, and then for each additional channel. You would use it like this:

.DateHistogram("mydoc", h => h.Aggregations(ag => ag.AverageChannels(4))

If the channel count is retrievable from the 'ag' object, then you can exclude the channelCount parameter entirely if you want.

Answer 2

This is written outside Visual Studio, so I can't guarantee it's 100% correct, but something like the following demonstrates how you can construct expressions, as well as compile them for direct invocation:

// Test whether a string is a certain length

public Func<string,bool> IsOfCorrectLength(int lengthToTest)
{
    var param = Expression.Parameter(typeof(string));
    var test = Expression.Equal(Expression.Property(param, "Length"), Expression.Constant(lengthToTest));
    return Expression.Lambda<string,bool>(test,param).Compile();
}

public void DoSomething()
{
    var is5CharsLong = IsOfCorrectLength(5);

    var result = is5CharsLong("Here's a string that would fail");
}

For situations where you just need the expression, you could just pass around the expression; just be aware that some consumers of expressions may not support every expression type - particularly if the expression has to be transpiled into something like SQL.

MSDN has some very interesting articles on how to use expressions at runtime to do some pretty nifty things.

Answer 3

You can write a method that takes a name for the histogram and collection of field names and returns a Func<AggregationDescriptor<DataRecord>, AggregationDescriptor<DataRecord>>

public static Func<AggregationDescriptor<DataRecord>, AggregationDescriptor<DataRecord>> DateHistogramOfAveragesForFields(
    string histogramName, 
    IEnumerable<string> fields)
{
    return aggs => aggs
        .DateHistogram(histogramName, h => h
            .Aggregations(d => 
                fields.Select((field, index) => new { Field = field, Name = "avg" + (index + 1) })
                      .Aggregate(d, (descriptor, field) => descriptor.Average(field.Name, b => b.Field(field.Field)))));
}

It looks a bit long in the tooth, but essentially, we build up a method that expects to receive a AggregationDescriptor<DataRecord> and call .DateHistogram() on it, passing it the histogram name and generate a collection of field names and decription labels from the field collection to pass to the DateHistogramAggregationDescriptor<DataRecord> .

To use is simply

void Main()
{
    var settings = new ConnectionSettings(new Uri("http://localhost:9200"));

    var client = new ElasticClient(settings);

    var results = client.Search<DataRecord>(s => s
       .Index("index")
       .Aggregations(DateHistogramOfAveragesForFields("mydoc", new[] { "channel1", "channel2", "channel3", "channel4" })
       )
   );

    Console.WriteLine(string.Format("{0} {1}", results.RequestInformation.RequestMethod, results.RequestInformation.RequestUrl));
    Console.WriteLine(Encoding.UTF8.GetString(results.RequestInformation.Request));
}

public class DataRecord { }

which outputs the following search query

POST http://localhost:9200/index/datarecord/_search
{
  "aggs": {
    "mydoc": {
      "date_histogram": {
        "format": "date_optional_time"
      },
      "aggs": {
        "avg1": {
          "avg": {
            "field": "channel1"
          }
        },
        "avg2": {
          "avg": {
            "field": "channel2"
          }
        },
        "avg3": {
          "avg": {
            "field": "channel3"
          }
        },
        "avg4": {
          "avg": {
            "field": "channel4"
          }
        }
      }
    }
  }
}

No need to build up an Expression tree with the Expression API :)