title: Can I capture a local variable into a LINQ Expression as a constant rather than a closure reference?
body: <p>I'd like to say </p>
  
  <pre><code>int x = magic(), y = moremagic();
  return i =&gt; i + (x/y);
  </code></pre>
  
  <p>and have the x be captured as a constant instead of a variable reference. The idea is that x will never change and so when the expression is later compiled, the compiler to can do constant folding and produce more efficient code -- i.e. calculating <code>x/y</code> once instead of on every call, via pointer dereferences into a closure record. </p>
  
  <p>There is no way to mark x as readonly within a method, and the compiler is not clever enough to detect that it doesn't change after the creation of the expression.</p>
  
  <p>I'd hate to have to build the expression by hand. Any brilliant ideas?</p>
  
  <p><strong>UPDATE</strong>: I ended up using the marvelous <a href="http://www.albahari.com/nutshell/linqkit.aspx" rel="noreferrer">LinqKit</a> to build a partial evaluator that will do the substitutions I want. The transform is only safe if you know that relevant references will not change, but it worked for my purposes. It is possible to restrict the partial evaluation only to direct members of your closure, which you control, by adding an extra check or two in there, which is fairly obvious on inspection of the sample code provided in the LinqKit.</p>
  
  <pre><code>/// &lt;summary&gt;Walks your expression and eagerly evaluates property/field members and substitutes them with constants.
  /// You must be sure this is semantically correct, by ensuring those fields (e.g. references to captured variables in your closure)
  /// will never change, but it allows the expression to be compiled more efficiently by turning constant numbers into true constants, 
  /// which the compiler can fold.&lt;/summary&gt;
  public class PartiallyEvaluateMemberExpressionsVisitor : ExpressionVisitor
  {
      protected override Expression VisitMemberAccess(MemberExpression m)
      {
          Expression exp = this.Visit(m.Expression);
  
          if (exp == null || exp is ConstantExpression) // null=static member
          {
              object @object = exp == null ? null : ((ConstantExpression)exp).Value;
              object value = null; Type type = null;
              if (m.Member is FieldInfo)
              {
                  FieldInfo fi = (FieldInfo)m.Member;
                  value = fi.GetValue(@object);
                  type = fi.FieldType;
              }
              else if (m.Member is PropertyInfo)
              {
                  PropertyInfo pi = (PropertyInfo)m.Member;
                  if (pi.GetIndexParameters().Length != 0)
                      throw new ArgumentException("cannot eliminate closure references to indexed properties");
                  value = pi.GetValue(@object, null);
                  type = pi.PropertyType;
              }
              return Expression.Constant(value, type);
          }
          else // otherwise just pass it through
          {
              return Expression.MakeMemberAccess(exp, m.Member);
          }
      }
  }
  </code></pre>