C# Creating a Fluent API for chaining methods

Question

In C#, we can use Func<> and Action<> types to store what are essentially managed pointers to methods. However, in my experience, they need to be explicitly typed when defined: Func<int> someFunc = myObject.MyMethod;

I am trying to design a fluent API that can chain various methods assuming they have a compatible signature. For instance:

public int IntMethodA( value ) { return value * 2; }
public int IntMethodB( value ) { return value * 4; }
public double DoubleMethod( value ) { return value / 0.5; }

public double ChainMethod( value )
{
  return IntMethodA( value )
            .Then( IntMethodB )
            .Then( DoubleMethod );
}

This is something that is supported by .NET's Task<> class. However, for learning purposes, I am trying to develop something like this from scratch, and it has left me with a few questions:

IntMethodA returns an int. In order to achieve something like this, I would likely need to write an extension method for Func<>, along with all of its possible generic overloads. This means I'll need to cast the initial method as a Func and then return a builder object that can accept subsequent methods. Is there any way I can avoid that initial cast, so as to maintain complete fluency?
Is there a way to automate or make generic the builder methods that accept functions and add them to the chain?

For instance, consider:

public int IntMultiply( int a, int b ) { return a * b; }

public Tuple<double, double> Factor( int value )
{
  /* Some code that finds a set of two numbers that multiply to equal 'value' */
}

These two methods have different signatures and return types. However, if I want to chain IntMultiply().Then( Factor ); it should work, because the input of Factor is the same type as the output of IntMultiply.

However, creating a generic fluent API that can do this seems like a challenge. I would need to be able to somehow take the return type of IntMultiply and constrain any additional methods to accept only that type as the input. Is this even possible to do?

If anyone has insights as to how this project can be approached, or if there are existing projects that do something similar, I would appreciate it.

Do you want the result to be the actual value after calling all the methods in order or are you trying to create a Func that you can then reuse with different values? If the latter then I'd suggest limiting the methods to one input argument (only the first one could every have more than one anyway). — juharr
– juharr, Commented Feb 8, 2019 at 20:10
@juharr The former. Outputs are passed down through the chained methods, and whatever the last method outputs is what would be returned when the entire chain is executed. — Haus
– Haus, Commented Feb 8, 2019 at 20:16

Johnny · Accepted Answer · 2019-02-08 22:16:32Z

You could implement something like this:

public class Fluent<TIn, TOut>
{
    private readonly TIn _value;
    private readonly Func<TIn, TOut> _func;

    public Fluent(TIn value, Func<TIn, TOut> func)
    {
        _value = value;
        _func = func;
    }

    public Fluent<TIn, TNewOut> Then<TNewOut>(Func<TOut, TNewOut> func) 
        => new Fluent<TIn, TNewOut>(_value, x => func(_func(x)));

    private TOut Calc() => _func(_value);

    public static implicit operator TOut(Fluent<TIn, TOut> self) => self.Calc();
}

then you could chain multiple methods one after another and return what ever you want:

double f = new Fluent<int, int>(2, x => 2 * x)
    .Then(x => 4 * x)
    .Then(x => x / 0.5);
Tuple<double, double> t = new Fluent<int, int>(2, x => 2 * x)
    .Then(x => new Tuple<double, double>(x,x));

n.b. You could also remove the overloaded implicit cast operator and make Calc method public. In that case, you could use var because there would be no ambiguity between Fluent<TIn, TOut> and TOut.

Heretic Monkey · Accepted Answer · 2019-02-08 20:41:13Z

3

It sounds like you want something like

public static TOut Then<TIn, TOut>(this TIn input, Func<TIn, TOut> func)
{
    return func(input);
}

Then this would work

var result = Multiply(1, 2).Then(Factor);

The idea is that your extension method is not on the first method, but on its result and you can handle the result being anything by making it generic. Then it's just a matter of passing in a Func that takes that value as its input and returns any output you want. Then that output can be passed into the next call to Then with a matching Func. The only down side is that any method you pass into Then can only have one argument, but you can get around that by using tuples or custom classes that your methods return and ingest.

edited Feb 8, 2019 at 20:41

Heretic Monkey

12.2k7 gold badges63 silver badges133 bronze badges

answered Feb 8, 2019 at 20:17

juharr

32.4k4 gold badges60 silver badges95 bronze badges

2 Comments

NetMage Over a year ago

Or perhaps by creating multiple definitions for Then that handle varying number of results, like the multiple Func definitions? Also, I would use => to define Then.

NetMage Over a year ago

Of course, you can't return multiple types from a single method, so perhaps that isn't necessary?

Collectives™ on Stack Overflow

C# Creating a Fluent API for chaining methods

2 Answers 2

Comments

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related