Doesn't IQueryable.Expression = Expression.Constant(this); cause an infinite loop?

Expression trees represent code in a tree-like data structure, where each node is an expression. In Linq they are used by linq providers to convert them into native language of a target process.

I know very little of expression trees, but I've been reading the following code where author uses Expression.Constant(this) to describe the initial query. Thus according to author Expression.Constant(this) should enable provider to retrieve the initial sequence of elements for someQuery.

But to my understanding this should instead cause an infinite loop, since expression tree in someQuery.Expression is describing someQuery object and not the details of the query itself ( or to put it diff开发者_开发问答erently, if target platform is SQL DB, Expression.Constant(this) doesn't describe in non-sql terms which rows or tables a query should retrieve from a DB ). And thus when provider looks into someQuery.Expression, it will only find description D of someQuery object.And if it further inspects the details of D.Expression property, it again finds the description of someQuery object and so on – thus infinite loop:

    public class Query<T> : IQueryable<T>...
    {
        QueryProvider provider;
        Expression expression;

        public Query(QueryProvider provider) {
            this.provider = provider;
            this.expression = Expression.Constant(this);
        }
                     ...
    }

Query<string> someQuery = new Query<string>();

thank you

I'd expect the provider to have knowledge of the query type and know that when it hit a constant expression of type Query<T>, it had hit a leaf, effectively. Sooner or later, the provider has to get to something describing "the whole table" or an equivalent. Of course the Query<T> would need the information about which table etc, but in a full example I'd expect it to have that information.

(Out of interest, am I the author in question? I wrote something very similar in C# in Depth...)