using System;

using System.Dynamic;

using System.Linq.Expressions;

using System.Collections.Generic;

using System.Linq;

using Newtonsoft.Json;

public class Program

{

    public static void Main()

    {

        var thing = new Thing() { ID = 1, Name = "Tom" };

        var ex = thing.AsExpando<Thing>(x => x.Name);

        string output = JsonConvert.SerializeObject(ex);

        Console.WriteLine(output);

        var things = new List<Thing>()

        {

            new Thing() { ID = 2, Name = "Steve", Age = 8 },

            new Thing() { ID = 2, Name = "Steve" },

            new Thing() { ID = 2, Name = "Steve", Age = 9 },

        };

        var exes = things.AsExpando<Thing>(x => x.Name);

        output = JsonConvert.SerializeObject(exes);

        exes = things.AsExpando<Thing>(x => x.Name);

        output = JsonConvert.SerializeObject(exes);

        //Console.WriteLine(output);

        Console.WriteLine(Extensions.CompileCount);

    }

​

}

​

public class Compiled<T>

{

    public string Name { get; set; }

    public Func<T, object> Func { get; set; }

}

​

public class Thing

{

    public int ID { get; set; }

    public string Name { get; set; }

    public int Age { get ;set; }

}

​

​

public static class Extensions

{

    static Dictionary<Type, Object> typedic = new Dictionary<Type, Object>();

    public static int CompileCount = 0;

    public static IEnumerable<ExpandoObject> AsExpando<T>(this IEnumerable<T> items, params Expression<Func<T, object>>[] props)

    {

        return items.Select(x => AsExpando(x, props));

    }

    public static ExpandoObject AsExpando<T>(this T item, params Expression<Func<T, object>>[] props )

    {

        var expando = new ExpandoObject();

        var dict = expando as IDictionary<string, object>;

        Dictionary<string, Compiled<T>> propdic = null;

        if (!typedic.ContainsKey(typeof(T)))

        {

            propdic = new Dictionary<string, Compiled<T>>(); 

            typedic.Add(typeof(T), propdic);

        }

        else

        {

            propdic = (Dictionary<string, Compiled<T>>)typedic[typeof(T)];

        }

        foreach (var prop in props)

        {

            string name = null;

            Func<T, object> func = null;

            var bodyString = prop.Body.ToString();

            if (!propdic.ContainsKey(bodyString))

            {

                name = GetFullPropertyName<T, object>(prop);    

                func = prop.Compile();

                CompileCount++;

                var comp = new Compiled<T>() { Name = name, Func = func };

                propdic.Add(bodyString, comp);

            }

            else

            {

                var comp = propdic[bodyString];

                name = comp.Name;

                func = comp.Func;

            }

            if (String.IsNullOrEmpty(name))

            {

                continue;

            }

            var val = func(item);           

            dict.Add(name, val);

        }

        return expando;

    }

    static string GetFullPropertyName<T, TProperty> (Expression<Func<T, TProperty>> exp)

    {

        MemberExpression memberExp;

        if (!TryFindMemberExpression(exp.Body, out memberExp))

            return string.Empty;

        var memberNames = new Stack<string>();

        do

        {

            memberNames.Push(memberExp.Member.Name);

        }

        while (TryFindMemberExpression(memberExp.Expression, out memberExp));

        return string.Join(".", memberNames.ToArray());

    }

​

// code adjusted to prevent horizontal overflow

private static bool TryFindMemberExpression

(Expression exp, out MemberExpression memberExp)

{

    memberExp = exp as MemberExpression;

    if (memberExp != null)

    {

        // heyo! that was easy enough

        return true;

    }

​

    // if the compiler created an automatic conversion,

    // it'll look something like...

    // obj => Convert(obj.Property) [e.g., int -> object]

    // OR:

    // obj => ConvertChecked(obj.Property) [e.g., int -> long]

    // ...which are the cases checked in IsConversion

    if (IsConversion(exp) && exp is UnaryExpression)

    {

        memberExp = ((UnaryExpression)exp).Operand as MemberExpression;

        if (memberExp != null)

        {

            return true;

        }

    }

​

    return false;

}

​

private static bool IsConversion(Expression exp)

{

    return (

        exp.NodeType == ExpressionType.Convert ||

        exp.NodeType == ExpressionType.ConvertChecked

    );

}

}

​

​

​