Looping through columns in Entity Framework Is there a cleaner/more efficient way to loop through the columns in EF implicitly than the way written below?

static void Main(string[] args) {
    using (var db = new someDbContext()) {
        var query = from p in db.someTable
                    select new {
                        column1 = p.column1
                        column2 = p.column2
                    };

        var columnAccessors = CreateAccessors(query.FirstOrDefault());

        foreach (var row in query) {
            foreach (var col in columnAccessors) {
                var val = col(row);
                //Do something with val here.
            }
        }
    }
}

static Func&lt;T, object&gt;[] CreateAccessors&lt;T&gt;(T source = default(T)) {
    var propertyAccessors = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public)
                .Where(p =&gt; p.CanRead)
                .Select((p, i) =&gt; new {
                    Index = i,
                    Property = p,
                    Accessor = CreatePropertyAccessor&lt;T&gt;(p)
                })
                .ToArray();

    return propertyAccessors.Select(p =&gt; p.Accessor).ToArray();
}

static Func&lt;T, object&gt; CreatePropertyAccessor&lt;T&gt;(PropertyInfo prop) {
    var param = Expression.Parameter(typeof(T), "input");
    var propertyAccess = Expression.Property(param, prop.GetGetMethod());
    var castAsObject = Expression.TypeAs(propertyAccess, typeof(object));
    var lambda = Expression.Lambda&lt;Func&lt;T, object&gt;&gt;(castAsObject, param);
    return lambda.Compile();
}


I've tried simply doing a foreach (var col in row) before but I know that it won't work because row doesn't contain a definition for GetEnumerator and I'm not sure how one would go about implementing a solution that would do so generically for something like this.

I was working on implementing a DataReader and came across this page: http://www.developerfusion.com/article/122498/using-sqlbulkcopy-for-high-performance-inserts/. The thought occurred to me that I could modify the CreatePropertyAccessors segments to loop through columns and so I came up with the above. Problem being I'm just not sure that it's a "good" solution.

Edit:

With one small change the following is possible as well:

var query = from p in db.someTable
            select new SomeModel {
                item1 = p.column1,
                item2 = p.column2
            };

var columnAccessors = CreateAccessors&lt;SomeModel&gt;();
So I had a look and made a few modifications, see below with comments.

// Made the method generic, the constaint is required by DbSet
static void LoopThroughColumns&lt;T&gt;(Func&lt;someDbContext, DbSet&lt;T&gt;&gt; getTable)
    where T : class
{
    using (var db = new someDbContext())
    {
        // Selecting columns exlicitly was unnecessary
        var query = getTable(db);
        var columnAccessors = CreateAccessors&lt;T&gt;();

        foreach (var row in query)
        {
            foreach (var col in columnAccessors)
            {
                var val = col(row);
            }
        }
    }
}

// Parameter is unnecessary as you never used it
static Func&lt;T, object&gt;[] CreateAccessors&lt;T&gt;()
{
    // Index and Property values weren't being used
    // ToArray() was an unnecessary conversion
    var propertyAccessors = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public)
                .Where(p =&gt; p.CanRead)
                .Select((p, i) =&gt;  CreatePropertyAccessor&lt;T&gt;(p));

    return propertyAccessors.Select(e =&gt; e).ToArray();
}

static Func&lt;T, object&gt; CreatePropertyAccessor&lt;T&gt;(PropertyInfo prop)
{
    var param = Expression.Parameter(typeof(T), "input");
    var propertyAccess = Expression.Property(param, prop.GetGetMethod());
    var castAsObject = Expression.TypeAs(propertyAccess, typeof(object));
    var lambda = Expression.Lambda&lt;Func&lt;T, object&gt;&gt;(castAsObject, param);
    return lambda.Compile();
}


Usage is a little different now, you would call it like this:

LoopThroughColumns(e =&gt; e.someTable);


To be extra-super cool (ie. generic) you could even pass in an Action&lt;object&gt; and have that define what is done with val, then derive different methods on that one. Below I'm creating a PrintColumnValues method which calls LoopThroughColumns with an specific Action&lt;object&gt; to perform.

static void LoopThroughColumns&lt;T&gt;(Func&lt;someDbContext, DbSet&lt;T&gt;&gt; getTable, Action&lt;object&gt; actionOnObject)
    where T : class
{
    using (var db = new someDbContext())
    {
        var query = getTable(db);
        var columnAccessors = CreateAccessors&lt;T&gt;();

        foreach (var row in query)
        {
            foreach (var col in columnAccessors)
            {
                actionOnObject(col(row));
            }
        }
    }
}

static void PrintColumnValues&lt;T&gt;(Func&lt;someDbContext, DbSet&lt;T&gt;&gt; getTable)
    where T : class
{
    LoopThroughColumns(getTable, 
        new Action&lt;object&gt;(e =&gt; 
        {
            Console.WriteLine(e);
        }));
}


Usage

PrintColumnValues(e =&gt; e.someTable);