Is it possible to create fluent interface that can nest generic types many times in C#

Question

I'm trying to create a Fluent API that describes a nested structure and as a result I would like to use generics to type the resulting object. I would like to do something like:

var test = new Query<Entity>().Select(x => x.UniqueValue<string>())
                              .Select(x => x.UniqueValue<DateTime>())
                              .Select(x => x.UniqueValue<decimal>());

Where test would be of type:

Result<Entity, string, Result<Entity, DateTime, Result<Entity, decimal>>>

So far I have code like:

   class Program
{
    static void Main(string[] args)
    {
        // test : ResultWithResult<Entity,string, Result<Entity, DateTime, ChildLessResult<Entity, decimal>>>
        var test = new Query<Entity>().Select(x => x.UniqueValue<string>())
                                      .Select(x => x.UniqueValue<DateTime>())
                                      .Select(x => x.UniqueValue<decimal>());
    }
}

public class Entity
{
    public string Item1 { get; set; }
}

public class Aggregate<TEntity>
{
    public ChildLessResult<TEntity, TReturnValue> UniqueValue<TReturnValue>()
    {
        return new ChildLessResult<TEntity, TReturnValue>();
    }
}

public class Query<TEntity>
{
    public ChildLessResult<TEntity, TReturnValue> Select<TReturnValue>(Func<Aggregate<TEntity>, ChildLessResult<TEntity, TReturnValue>> predicate)
    {
        var aggregator = new Aggregate<TEntity>();
        return predicate(aggregator);
    }
}

public class ChildLessResult<TEntity, TReturnValue>
{
    public Result<TEntity, TReturnValue, TChild> Select<TChild>(Func<Aggregate<TEntity>, ChildLessResult<TEntity, TChild>> predicate)
    {
        return new Result<TEntity, TReturnValue, TChild>();
    }
}

public class Result<TEntity, TReturnValue, TChild>
{
    private ChildLessResult<TEntity, TChild> _child = new ChildLessResult<TEntity, TChild>();

    public ResultWithResult<TEntity, TReturnValue, Result<TEntity, TChild, ChildLessResult<TEntity, TNewChild>>> Select<TNewChild>(Func<Aggregate<TEntity>, ChildLessResult<TEntity, TNewChild>> predicate)
    {
        return new ResultWithResult<TEntity, TReturnValue,
            Result<TEntity, TChild, ChildLessResult<TEntity, TNewChild>>>();
    }
}

public class ResultWithResult<TEntity, TReturnValue, TChild>
{
}

As you can see this is pretty limited since it only allows you to go as deep as the structures you have defined and you would need a new structure for each level deeper. Is it possible to create types that would allow an unlimited number of levels (i.e. as many Selects as you would ever want without the same corresponding number of Types).

Answer 1

Yes, sort of.... it is possible to create some very long and deep nested types, more or less automatically. The trick is you need to use generic type inference, and since constructors don't do inference, you have to use a factory method. For example:

public class MyType<TData,TChild>
{
    public MyType(TData data, TChild child)
    {
    }
}

public class MyTypeFactory
{
   public static MyType<TData,TChild> Create<TData,TChild>(TData data, TChild child)
   {
      return new MyType<TData,TChild>(data, child);
   }
    
   public static MyType<TData,object> Create<TData>(TData data)
   {
      return new MyType<TData,object>(data, null);
   }
}

public static class Program
{
    static public void Main()
    {
        var grandchild  = MyTypeFactory.Create( 12 );
        var child       = MyTypeFactory.Create( 13D, grandchild );
        var parent      = MyTypeFactory.Create( 14M, child) ;
        var grandparent = MyTypeFactory.Create( 15F, parent );
        
        Console.WriteLine(  grandchild.GetType().FullName );
        Console.WriteLine(       child.GetType().FullName );
        Console.WriteLine(      parent.GetType().FullName );
        Console.WriteLine( grandparent.GetType().FullName );
    }
}

The output:

MyType'2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

MyType'2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]

MyType'2[[System.Decimal, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]

MyType'2[[System.Single, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Decimal, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Double, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[MyType'2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]], uy2zelya, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]

It's even type-safe, amazingly enough. If you add the necessary properties...

public class MyType<TData,TChild>
{
    protected readonly TChild _child;
    protected readonly TData _data;
    
    public MyType(TData data, TChild child)
    {
        _data = data;
        _child = child;
    }
    
    public TChild Child
    {
        get
        {
            return _child;
        }
    }
    
    public TData Data
    {
        get
        {
            return _data;
        }
    }
}

...this will work:

var grandchildValue = grandparent.Child.Child.Child.Data;
Console.WriteLine(grandchildValue); //12
Console.WriteLine(grandchildValue.GetType().Name); //int32

And of course you can use the builder pattern:

public static class ExtensionMethods
{
    static public MyType<TDataAdd,MyType<TDataIn,TResultIn>> AddColumn<TDataIn,TResultIn,TDataAdd>(this MyType<TDataIn,TResultIn> This, TDataAdd columnValue)
    {
        return MyTypeFactory.Create(columnValue, This);
    }
}

var grandparent = MyTypeFactory.Create( 12 )
    .AddColumn( 13D )
    .AddColumn( 14M )
    .AddColumn( 15F );

var grandchildValue = grandparent.Child.Child.Child.Data;
Console.WriteLine(grandchildValue);                       //12
Console.WriteLine(grandchildValue.GetType().FullName);    //System.Int32

See my code on DotNetFiddle

P.S. This is a great example of why we needed the var keyword! Otherwise you'd be typing forever.