In its different steps, DbLinq:- replaces language specific expressions (VB
specific expressions, for example, are changed to standard expressions)
- creates temporary expressions (such as tables, columns, etc.)
- and optimizes some of them (all constant subexpressions are reduced to a
single constant value).

For all three steps, the expression tree needs to be updated, this is why
there is an ExpressionMutator. And because Expressions are immutable, we
needed to create new mutated expressions from old ones.

On Sun, May 17, 2009 at 21:53, Giacomo Tesio <[email protected]> wrote:

> Tring to organize the work needed to make the QueryCache useful by allowing
> each InputParameterExpression to update it's own values from the updated
> expression, I encountered the ExpressionMutatorFactory and all the
> IMutableExpression implementations.
>
> This is something I could not understand yet, about the DbLinq internals.
>
> Why we need them?
>
> I need to understand this, since to allow the closure to be updated via a
> delegate taking the expression (if not the ExpressionChain), I need to pass
> a lambda between the analizing method expressing how to reach the current
> analized expression from the initial one.
>
> Defining such a lambda should not be difficult by itself, but the
> ExpressionMutatorFactory make it harder.
>
>
> Giacomo
>
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"DbLinq" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to 
[email protected]
For more options, visit this group at 
http://groups.google.com/group/dblinq?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to