using System;

using System.Collections.Generic;

using System.Linq.Expressions;

using System.Reflection;

public class Program

{

    public static void Main()

    {

        var test = new Test() { Foo = "woop", Bar = 3 };

        var expr = CreatePropertyDict(typeof(Test));

        expr(test).Dump();

    }

    public static Func<object, Dictionary<string, object>> CreatePropertyDict(Type type)

    {

        var dictType = typeof(Dictionary<string, object>);

        var dictCtor = dictType.GetConstructor(new[] { typeof(int) });

        var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);

        var dictAddMethod = dictType.GetMethod("Add");

        var blockExpressions = new List<Expression>();

        // 'object input' is our input parameter

        var inputParameter = Expression.Parameter(typeof(object), "input");

        // MyType d;

        var dVariable = Expression.Variable(type, "d");

        // d = (MyType)inputObject;

        blockExpressions.Add(Expression.Assign(dVariable, Expression.Convert(inputParameter, type)));

        // Dictionary<string, object> dict;

        var dictVariable = Expression.Variable(dictType, "dict");

        // dict = new Dictionary<string, object>(3) (or however many properties there are)

        blockExpressions.Add(Expression.Assign(dictVariable, Expression.New(dictCtor, Expression.Constant(properties.Length))));

        foreach (var property in properties)

        {

            var propertyAccess = Expression.Property(dVariable, property);

            // dict.Add("Foo", (object)d.Foo)

            blockExpressions.Add(Expression.Call(

                dictVariable,

                dictAddMethod,

                Expression.Constant(property.Name),

                Expression.Convert(propertyAccess, typeof(object))));

        };

        // The final statement in a block is the return value

        blockExpressions.Add(dictVariable);

        var block = Expression.Block(new[] { dVariable, dictVariable }, blockExpressions);

        return Expression.Lambda<Func<object, Dictionary<string, object>>>(block, inputParameter).Compile();

    }

}

​

public class Test

{

    public string Foo { get; set; }

    public int Bar { get; set; }

}