Question

Help, I appeared to wondered off the path somewhat.

After asking this question yesterday, I decided to take a look into expression trees. I found a nice little place to start and here is what I have so far:

  // Gets the property type
  ParameterExpression paramProperty = Expression.Parameter(property.PropertyType);
  // Gets the value from row[0] (SqlDataReader)
  ParameterExpression paramValue = Expression.Parameter(row[0].GetType());
  // really no clue, makes a property so to speak?
  MemberExpression prop = Expression.Property(paramProperty, property);
  // assigns the property the value from the SqlDataReader
  BinaryExpression assign = Expression.Assign(prop, paramValue);
  // adds to an expression list ready for compilation
  exps.Add(assign);
  // allows things to be executed sequentially?
  BlockExpression blockExpression = exps.Count > 0 ? Expression.Block(exps) : Expression.Block(Expression.Empty());
  // create the parameter array
  List<ParameterExpression> paramArr = new List<ParameterExpression>();
  paramArr.Add(paramProperty);
  paramArr.Add(paramValue);
  // get a lambda so I can compile this for re-use
  Expression<Action<T>> lamExp = Expression.Lambda<Action<T>>(blockExpression, paramArr);

First of all, are my comments right? I am piecing this information in the good old fashion way of a tutorial and msdn doc’s.

From the bits that I have been reading, I think I should have been able to compile this, store it in a dictionary with a type as the key and call it when I needed to. Eg.

  ConcurrentDictionary<Type, ??> ExpressionCache;
  if(ExpressionCache.ContainsKey(typeof(T))
  {
         // property is the variable of a foreach loop of type PropertyInfo
         ExpressionCache[typeof(T)](property); 
  } // else do the first piece of code...

So in summary,

1. Am I heading down the right track?
2. Are my comments about the Expressions correct?
3. What type should I use for the concurrent dictionary?
4. When I cache the reference, how do I pass different parameters to the lambda?

Any improvements or suggestions are welcome as long as the are explained well. I am trying to understand how it works not just to make it work 🙂

Answer 1

It sounds like you’re looking for commentary more than anything else…right?

First of all, how will you have your SqlReader at compile time?

// Gets the value from row[0] (SqlDataReader)
ParameterExpression paramValue = Expression.Parameter(Type.GetTypeFromHandle(row[0].GetType()));

Your lambda takes two parameters though…so something is wrong (Action takes one parameter).

I would think that you really want is an Func<SqlDataReader, T>. That way, you give it your SqlDataReader and it produces a T. So:

var list = new List<T>();
// get a SqlDataReader
while (reader.Read())
{
    Func<SqlDataReader, T> readRow = GetReader<T>();
    list.Add(readRow(reader);
}

I would store your cache as

 ConcurrentDictionary<Type, Delegate> ExpressionCache;  // can't use T here since each Func will have a different T

Then cast it to the appropriate delegate type for the caller upon retrieval (have your method take a generic parameter:

 public Func<SqlDataReader, T> GetReader<T>() 
 { 
     Delegate d;
     if(!ExpressionCache.TryGetValue(typeof(T), out d)
     {
         ExpressionCache[typeof(T)] = d = // build and compile lambda
     } 
     // cast to strong typed delegate...we don't want to have to DynamicInvoke...that's slow
     return (Func<SqlDataReader, T>)d;
 }

So…as for your lambda builder/compiler:

        // hang on to row[string] property 
        var indexerProperty = typeof(SqlDataReader).GetProperty("Item", new[] { typeof(string) });

        // list of statements in our dynamic method
        var statements = new List<Expression>();

        // store instance for setting of properties
        ParameterExpression instanceParameter = Expression.Variable(typeof(T));
        ParameterExpression sqlDataReaderParameter = Expression.Parameter(typeof(SqlDataReader));

        // create and assign new T to variable: var instance = new T();
        BinaryExpression createInstance = Expression.Assign(instanceParameter, Expression.New(typeof(T)));
        statements.Add(createInstance);

        foreach (var property in typeof(T).GetProperties())
        {
            // instance.MyProperty
            MemberExpression getProperty = Expression.Property(instanceParameter, property);

            // row[property] -- NOTE: this assumes column names are the same as PropertyInfo names on T
            IndexExpression readValue = Expression.MakeIndex(sqlDataReaderParameter, indexerProperty, new[] { Expression.Constant(property.Name) });

            // instance.MyProperty = row[property]
            BinaryExpression assignProperty = Expression.Assign(getProperty, Expression.Convert(readValue, property.PropertyType));

            statements.Add(assignProperty);
        }

        var returnStatement = instanceParameter;
        statements.Add(returnStatement);

        var body = Expression.Block(instanceParameter.Type, new[] { instanceParameter }, statements.ToArray());

        /* so we end up with
         * T Read(SqlDataReader row)
         * {
         * var x = new T();
         * x.Prop1 = (cast)row["Prop1"]
         * x.Prop2 = (cast)row["Prop2"]
         * x.Prop3 = (cast)row["Prop3"]
         * x.Prop4 = (cast)row["Prop4"]
         * etc.
         * return x
         * }
         */
        var lambda = Expression.Lambda<Func<SqlDataReader, T>>(body, sqlDataReaderParameter);

        // cache me!
        return lambda.Compile();

Haven’t tested this, so please use with care and give it a try yourself.

I’m not sure if I got your intended usage correct…is it?