I've started Tuples to LINQ and I'm not sure if it's an anti pattern
In general, I think this pattern makes sense, because it clearly expresses what the method returns and lets you easily do the computation you want to do with the result.

Some thoughts:


I don't see any reason why your extension methods should only work on a collection of Tuples and not on a single Tuple. Because of that, I would probably write extension methods that convert a single Tuple to IEnumerable:

public static IEnumerable&lt;T&gt; ToEnumerable&lt;T&gt;(this Tuple&lt;T, T&gt; tuple)
{
    yield return tuple.Item1;
    yield return tuple.Item2;
}


Since this would make the code you showed more complicated, it might make sense to also keep SelectMany(), but express it using ToEnumerable():

public static IEnumerable&lt;T&gt; SelectMany&lt;T&gt;(
    this IEnumerable&lt;Tuple&lt;T, T&gt;&gt; tuples)
{
    return tuples.SelectMany(t =&gt; t.ToEnumerable());
}

public static IEnumerable&lt;T&gt; SelectMany&lt;T, U&gt;(
    this IEnumerable&lt;U&gt; source, Func&lt;U, Tuple&lt;T, T&gt;&gt; selector)
{
    return source.SelectMany(x =&gt; selector(x).ToEnumerable());
}

It might make sense to create custom types that mean “pair (triple, …) of items of the same type”. As a side benefit, you wouldn't need custom ToEnumerable() or SelectMany() extensions, since those types could implement IEnumerable&lt;T&gt; directly.