public static class DictionaryHelper
    {
        public static TValue GetValueOrDefault<TKey, TValue>(
            this Dictionary<TKey, TValue> src, 
            TKey key,
            TValue defaultValue = default(TValue))
        {
            TValue result;
            if (src.TryGetValue(key, out result))
                return result;
            return defaultValue;
        }

        public static TValue GetOrAddValue<TKey, TValue>(
            this Dictionary<TKey, TValue> src,
            TKey key,
            Func<TValue> getNewValue)
        {
            TValue result;
            if (src.TryGetValue(key, out result) == false)
            {
                result = getNewValue();
                src.Add(key, result);
            }
            return result;
        }
    }

    static class EmitTypeInfo
    {
        class EmitPropertyInfoCollection
        {
            public EmitPropertyInfo[] Items;
            public Dictionary<string, EmitPropertyInfo> ByName;
        }

        class CacheDictionary : Dictionary<Type, EmitPropertyInfoCollection>
        { }

        static CacheDictionary Cache = new CacheDictionary();

        public static IEnumerable<EmitPropertyInfo> GetProperties(Type type)
        {
            return GetPropertiesInternalCollection(type).Items;
        }

        public static EmitPropertyInfo FindProperty(Type type, string propertyName)
        {
            var result = GetProperty(type, propertyName);

            if (result == null)
                throw new ArgumentException(
                    string.Format("Property {0}.{1} not found", type.FullName, propertyName)
                );

            return result;
        }

        public static EmitPropertyInfo GetProperty(Type type, string propertyName)
        {
            return GetPropertiesInternalCollection(type)
                .ByName
                .GetValueOrDefault(propertyName);
        }

        static EmitPropertyInfoCollection GetPropertiesInternalCollection(Type type)
        {
            lock (Cache)
                return Cache.GetOrAddValue(
                    type,
                    () =>
                    {
                        var items = CreateEmitProperties(type).ToArray();
                        return new EmitPropertyInfoCollection
                        {
                            Items = items,
                            ByName = items.ToDictionary(v => v.Property.Name)
                        };
                    }
                );
        }

        static IEnumerable<EmitPropertyInfo> CreateEmitProperties(Type type)
        {
            var properties = type
                .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(v =>
                    (v.GetGetMethod() == null || v.GetGetMethod().GetParameters().Length == 0) &&
                    (v.GetSetMethod() == null || v.GetSetMethod().GetParameters().Length == 1)
                );

            foreach (var property in properties)
                yield return new EmitPropertyInfo(
                    property,
                    CreatePropertyGet(property),
                    CreatePropertySet(property)
                );
        }

        static Func<object, object> CreatePropertyGet(PropertyInfo pi)
        {
            var getMethod = pi.GetGetMethod();

            if (getMethod == null)
                return src =>
                {
                    throw new InvalidOperationException(
                        string.Format(
                            "Getter for property {0}.{1} not found",
                            pi.DeclaringType.FullName,
                            pi.Name
                        )
                    );
                };

            var method = new DynamicMethod(
                GetDynamicMethodName(pi, "Get"),
                typeof(object),
                new[] { typeof(object) },
                pi.Module
            );

            var il = method.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            if (pi.DeclaringType.IsValueType)
                il.Emit(OpCodes.Unbox, pi.DeclaringType);
            else
                il.Emit(OpCodes.Castclass, pi.DeclaringType);

            il.EmitCall(OpCodes.Callvirt, getMethod, null);

            if (pi.PropertyType.IsValueType)
                il.Emit(OpCodes.Box, pi.PropertyType);

            il.Emit(OpCodes.Ret);

            return (Func<object, object>)method.CreateDelegate(typeof(Func<object, object>));
        }

        static Action<object, object> CreatePropertySet(PropertyInfo pi)
        {
            var setMethod = pi.GetSetMethod();

            if (setMethod == null)
                return (src, value) =>
                {
                    throw new InvalidOperationException(
                        string.Format(
                            "Setter for property {0}.{1} not found",
                            pi.DeclaringType.FullName,
                            pi.Name
                        )
                    );
                };

            var method = new DynamicMethod(
                GetDynamicMethodName(pi, "Set"),
                typeof(void),
                new[] { typeof(object), typeof(object) },
                pi.Module
            );

            var il = method.GetILGenerator();

            il.Emit(OpCodes.Ldarg_0);
            if (pi.DeclaringType.IsValueType)
                il.Emit(OpCodes.Unbox, pi.DeclaringType);
            else
                il.Emit(OpCodes.Castclass, pi.DeclaringType);

            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Unbox_Any, pi.PropertyType);

            il.EmitCall(OpCodes.Callvirt, setMethod, null);

            il.Emit(OpCodes.Ret);

            return (Action<object, object>)method.CreateDelegate(typeof(Action<object, object>));
        }

        static string GetDynamicMethodName(PropertyInfo pi, string suffix)
        {
            return string.Join(
                "/",
                typeof(EmitTypeInfo).FullName,
                pi.DeclaringType.FullName,
                pi.Name,
                suffix
            );
        }
    }

    class EmitPropertyInfo
    {
        public PropertyInfo Property { get; private set; }
        public Func<object, object> GetValue { get; private set; }
        public Action<object, object> SetValue { get; private set; }

        public EmitPropertyInfo(
            PropertyInfo property,
            Func<object, object> getValue,
            Action<object, object> setValue
        )
        {
            Property = property;
            GetValue = getValue;
            SetValue = setValue;
        }
    }