Unable to write Extension method to wrap a NEST client method - elasticsearch

Question

Basically, I was attempting to write the following extension method to avoid having to constantly write the .Suffix("keyword"). I dislike having string literals all over the place, and multiple properties of my ElasticSearch indices happen to require adding the keyword suffix to query properly.
public static class NestHelperExtensions
{
public static object UseKeywordSuffix(this object #object)
{
return #object.Suffix("keyword");
}
}
If I use the method presented above, it doesn't apply the suffix, but I'm not sure why it wouldn't work. I may be going about this the wrong way, and perhaps there is a way to add a model attribute or something to build a nestCilent.Search<T>, but when I attempted to use the KeywordAttribute, that didn't seem to work either.
Can anyone offer up an explanation as to why it wouldn't be this simple and if it should be possible, can you provide an example or workaround e.g. using attributes?

Answer 1

This won't work because the Suffix method is specifically handled when visiting the field expression
if (methodCall.Method.Name == nameof(SuffixExtensions.Suffix) && methodCall.Arguments.Any())
{
VisitConstantOrVariable(methodCall, _stack);
var callingMember = new ReadOnlyCollection<Expression>(
new List<Expression> { { methodCall.Arguments.First() } }
);
Visit(callingMember);
return methodCall;
}
So, an extension method like above would need to be called Suffix to begin and it would have to have at least one argument. You might think of supplying an optional parameter with a default value of "keyword" would work, but expression trees do not support this, so wouldn't work.
Another approach would be to utilise the AppendSuffix extension method on Expression<Func<T, object>> to build something; the nicest way to use this would be to pull the lambda expression out of the fluent call and into a variable
public static class NestHelperExtensions
{
public static Expression<Func<T, object>> KeywordSuffix<T>(this Expression<Func<T, object>> expression)
{
return expression.AppendSuffix("keyword");
}
}
var client = new ElasticClient();
Expression<Func<Person, object>> firstName = f => f.FirstName;
var searchResponse = client.Search<Person>(s => s
.Query(q => q
.Match(m => m
.Field(firstName.KeywordSuffix())
.Query("bar")
)
)
);
The not so nice way would be casting the lambda expression to Expression<Func<T, object>> inline
var searchResponse = client.Search<Person>(s => s
.Query(q => q
.Match(m => m
.Field(((Expression<Func<Person, object>>)(f => f.FirstName)).KeywordSuffix())
.Query("bar")
)
)
);
Another, perhaps simpler approach, would be to introduce a constant for the string "keyword", and use that in the Suffix extension method; it avoids using a string literal all over the place.