Question

I have a type that wraps an IEnumerable<T> and contains some additional logic, implementing an interface which we’ll call IMyIterable<T>. On one hand, I want people to use LINQ methods to filter and process IMyIterable<T> (by actually applying them to the underlying object), but on the other hand, I still want to fluently expose IMyIterable<T>‘s custom instance functionality (e.g state information) after the LINQ methods have been applied. e.g.

var query = myIterable.Select(x => x.whatever);
//query is now of a completely different type than IMyIterable<T>
var result = query.MyCustomThingy(); 
//But I really want MyCustomThingy to work too.

I know a solution would be:

var query = myIterable.Linq(x => x.Select(y => y.Whatever));

But the extra brackets are unseemly to me. Are there any other ways I could do this? I’m not actually asking for the method Select() to return a custom class (though if there are neat ways to do this, e.g. involving code generation, I’m definitely aboard), just some neater syntax.

Answer 1

LINQ is not tied to IEnumerable. You can implement the LINQ methods you need on IMyIterable itself (either as instance methods or as extension methods). This way you can even use the linq syntax directly on a variable of type IMyIterable.

E.g.:

public interface IMyIterable<T>
{
    IMyIterable<TOut> Select<TOut>(Func<T, TOut> selector);
    IMyIterable<T> Where(Func<T, bool> predicate);
    // ...
}

This would allow you to write something like this:

 IMyIterable<T> source = ...;

 var query = from item in source 
             where item.X == Y
             select new {...}