diff --git a/src/Ninject/Activation/Caching/ActivationCache.cs b/src/Ninject/Activation/Caching/ActivationCache.cs
index 48f0657c..33e391fc 100644
--- a/src/Ninject/Activation/Caching/ActivationCache.cs
+++ b/src/Ninject/Activation/Caching/ActivationCache.cs
@@ -11,27 +11,7 @@ namespace Ninject.Activation.Caching
     /// </summary>
     public class ActivationCache : NinjectComponent, IActivationCache, IPruneable
     {
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-        /// <summary>
-        /// The objects that were activated as reference equal weak references.
-        /// </summary>
-        private readonly IDictionary<object, bool> activatedObjects = new Dictionary<object, bool>(new WeakReferenceEqualityComparer());
-
-        /// <summary>
-        /// The objects that were activated as reference equal weak references.
-        /// </summary>
-        private readonly IDictionary<object, bool> deactivatedObjects = new Dictionary<object, bool>(new WeakReferenceEqualityComparer());
-#else
-        /// <summary>
-        /// The objects that were activated as reference equal weak references.
-        /// </summary>
-        private readonly HashSet<object> activatedObjects = new HashSet<object>(new WeakReferenceEqualityComparer());
-
-        /// <summary>
-        /// The objects that were activated as reference equal weak references.
-        /// </summary>
-        private readonly HashSet<object> deactivatedObjects = new HashSet<object>(new WeakReferenceEqualityComparer());
-#endif
+        private readonly IActivationCacheImpl cacheImpl;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ActivationCache"/> class.
@@ -40,8 +20,21 @@ public class ActivationCache : NinjectComponent, IActivationCache, IPruneable
         public ActivationCache(ICachePruner cachePruner)
         {
             cachePruner.Start(this);
+
+#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF
+            cacheImpl = new DictionaryBasedActivationCacheImpl();
+#else
+            if (RuntimeEnvironment.IsMonoRuntime)
+            {
+                cacheImpl = new DictionaryBasedActivationCacheImpl();
+            }
+            else
+            {
+                cacheImpl = new HashSetBasedActivationCacheImpl();
+            }
+#endif
         }
-        
+
         /// <summary>
         /// Gets the activated object count.
         /// </summary>
@@ -50,7 +43,7 @@ public int ActivatedObjectCount
         {
             get
             {
-                return this.activatedObjects.Count;
+                return cacheImpl.ActivatedObjectCount;
             }
         }
 
@@ -62,24 +55,16 @@ public int DeactivatedObjectCount
         {
             get
             {
-                return this.deactivatedObjects.Count;
+                return cacheImpl.DeactivatedObjectCount;
             }
         }
-        
+
         /// <summary>
         /// Clears the cache.
         /// </summary>
         public void Clear()
         {
-            lock (this.activatedObjects)
-            {
-                this.activatedObjects.Clear();
-            }
-
-            lock (this.deactivatedObjects)
-            {
-                this.deactivatedObjects.Clear();
-            }
+            cacheImpl.Clear();
         }
 
         /// <summary>
@@ -88,14 +73,7 @@ public void Clear()
         /// <param name="instance">The instance to be added.</param>
         public void AddActivatedInstance(object instance)
         {
-            lock (this.activatedObjects)
-            {
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-                this.activatedObjects.Add(new ReferenceEqualWeakReference(instance), true);
-#else
-                this.activatedObjects.Add(new ReferenceEqualWeakReference(instance));
-#endif
-            }
+            cacheImpl.AddActivatedInstance(instance);
         }
 
         /// <summary>
@@ -104,14 +82,7 @@ public void AddActivatedInstance(object instance)
         /// <param name="instance">The instance to be added.</param>
         public void AddDeactivatedInstance(object instance)
         {
-            lock (this.deactivatedObjects)
-            {
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-                this.deactivatedObjects.Add(new ReferenceEqualWeakReference(instance), true);
-#else
-                this.deactivatedObjects.Add(new ReferenceEqualWeakReference(instance));
-#endif
-            }
+            cacheImpl.AddDeactivatedInstance(instance);
         }
 
         /// <summary>
@@ -123,11 +94,7 @@ public void AddDeactivatedInstance(object instance)
         /// </returns>
         public bool IsActivated(object instance)
         {
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-            return this.activatedObjects.ContainsKey(instance);
-#else
-            return this.activatedObjects.Contains(instance);
-#endif
+            return cacheImpl.IsActivated(instance);
         }
 
         /// <summary>
@@ -139,11 +106,7 @@ public bool IsActivated(object instance)
         /// </returns>
         public bool IsDeactivated(object instance)
         {
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-            return this.deactivatedObjects.ContainsKey(instance);
-#else
-            return this.deactivatedObjects.Contains(instance);
-#endif        
+            return cacheImpl.IsDeactivated(instance);
         }
 
         /// <summary>
@@ -151,39 +114,320 @@ public bool IsDeactivated(object instance)
         /// </summary>
         public void Prune()
         {
-            lock (this.activatedObjects)
+            cacheImpl.Prune();
+        }
+
+        private interface IActivationCacheImpl
+        {
+            /// <summary>
+            /// Gets the activated object count.
+            /// </summary>
+            /// <value>The activated object count.</value>
+            int ActivatedObjectCount { get; }
+
+            /// <summary>
+            /// Gets the deactivated object count.
+            /// </summary>
+            /// <value>The deactivated object count.</value>
+            int DeactivatedObjectCount { get; }
+
+            /// <summary>
+            /// Clears the cache.
+            /// </summary>
+            void Clear();
+
+            /// <summary>
+            /// Adds an activated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            void AddActivatedInstance(object instance);
+
+            /// <summary>
+            /// Adds an deactivated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            void AddDeactivatedInstance(object instance);
+
+            /// <summary>
+            /// Determines whether the specified instance is activated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is activated; otherwise, <c>false</c>.
+            /// </returns>
+            bool IsActivated(object instance);
+
+            /// <summary>
+            /// Determines whether the specified instance is deactivated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is deactivated; otherwise, <c>false</c>.
+            /// </returns>
+            bool IsDeactivated(object instance);
+
+            /// <summary>
+            /// Prunes this instance.
+            /// </summary>
+            void Prune();
+        }
+
+#if !SILVERLIGHT_20 && !SILVERLIGHT_30 && !WINDOWS_PHONE && !NETCF
+        private class HashSetBasedActivationCacheImpl : IActivationCacheImpl
+        {
+            /// <summary>
+            /// The objects that were activated as reference equal weak references.
+            /// </summary>
+            private readonly HashSet<object> activatedObjects = new HashSet<object>(new WeakReferenceEqualityComparer());
+
+            /// <summary>
+            /// The objects that were activated as reference equal weak references.
+            /// </summary>
+            private readonly HashSet<object> deactivatedObjects = new HashSet<object>(new WeakReferenceEqualityComparer());
+
+            /// <summary>
+            /// Gets the activated object count.
+            /// </summary>
+            /// <value>The activated object count.</value>
+            public int ActivatedObjectCount
             {
-                RemoveDeadObjects(this.activatedObjects);
+                get
+                {
+                    return this.activatedObjects.Count;
+                }
             }
 
-            lock (this.deactivatedObjects)
+            /// <summary>
+            /// Gets the deactivated object count.
+            /// </summary>
+            /// <value>The deactivated object count.</value>
+            public int DeactivatedObjectCount
             {
-                RemoveDeadObjects(this.deactivatedObjects);
+                get
+                {
+                    return this.deactivatedObjects.Count;
+                }
             }
-        }
 
-#if SILVERLIGHT_20 || SILVERLIGHT_30 || WINDOWS_PHONE || NETCF || MONO
-        /// <summary>
-        /// Removes all dead objects.
-        /// </summary>
-        /// <param name="objects">The objects collection to be freed of dead objects.</param>
-        private static void RemoveDeadObjects(IDictionary<object, bool> objects)
-        {
-            var deadObjects = objects.Where(entry => !((ReferenceEqualWeakReference)entry.Key).IsAlive).ToList();
-            foreach (var deadObject in deadObjects)
+            /// <summary>
+            /// Clears the cache.
+            /// </summary>
+            public void Clear()
             {
-                objects.Remove(deadObject.Key);
+                lock (this.activatedObjects)
+                {
+                    this.activatedObjects.Clear();
+                }
+
+                lock (this.deactivatedObjects)
+                {
+                    this.deactivatedObjects.Clear();
+                }
+            }
+
+            /// <summary>
+            /// Adds an activated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            public void AddActivatedInstance(object instance)
+            {
+                lock (this.activatedObjects)
+                {
+                    this.activatedObjects.Add(new ReferenceEqualWeakReference(instance));
+                }
+            }
+
+            /// <summary>
+            /// Adds an deactivated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            public void AddDeactivatedInstance(object instance)
+            {
+                lock (this.deactivatedObjects)
+                {
+                    this.deactivatedObjects.Add(new ReferenceEqualWeakReference(instance));
+                }
+            }
+
+            /// <summary>
+            /// Determines whether the specified instance is activated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is activated; otherwise, <c>false</c>.
+            /// </returns>
+            public bool IsActivated(object instance)
+            {
+                return this.activatedObjects.Contains(instance);
+            }
+
+            /// <summary>
+            /// Determines whether the specified instance is deactivated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is deactivated; otherwise, <c>false</c>.
+            /// </returns>
+            public bool IsDeactivated(object instance)
+            {
+                return this.deactivatedObjects.Contains(instance);
+            }
+
+            /// <summary>
+            /// Prunes this instance.
+            /// </summary>
+            public void Prune()
+            {
+                lock (this.activatedObjects)
+                {
+                    RemoveDeadObjects(this.activatedObjects);
+                }
+
+                lock (this.deactivatedObjects)
+                {
+                    RemoveDeadObjects(this.deactivatedObjects);
+                }
+            }
+
+            /// <summary>
+            /// Removes all dead objects.
+            /// </summary>
+            /// <param name="objects">The objects collection to be freed of dead objects.</param>
+            private static void RemoveDeadObjects(HashSet<object> objects)
+            {
+                objects.RemoveWhere(reference => !((ReferenceEqualWeakReference)reference).IsAlive);
             }
         }
-#else
-        /// <summary>
-        /// Removes all dead objects.
-        /// </summary>
-        /// <param name="objects">The objects collection to be freed of dead objects.</param>
-        private static void RemoveDeadObjects(HashSet<object> objects)
+#endif
+
+        private class DictionaryBasedActivationCacheImpl : IActivationCacheImpl
         {
-            objects.RemoveWhere(reference => !((ReferenceEqualWeakReference)reference).IsAlive);
+            /// <summary>
+            /// The objects that were activated as reference equal weak references.
+            /// </summary>
+            private readonly IDictionary<object, bool> activatedObjects = new Dictionary<object, bool>(new WeakReferenceEqualityComparer());
+
+            /// <summary>
+            /// The objects that were activated as reference equal weak references.
+            /// </summary>
+            private readonly IDictionary<object, bool> deactivatedObjects = new Dictionary<object, bool>(new WeakReferenceEqualityComparer());
+
+            /// <summary>
+            /// Gets the activated object count.
+            /// </summary>
+            /// <value>The activated object count.</value>
+            public int ActivatedObjectCount
+            {
+                get
+                {
+                    return this.activatedObjects.Count;
+                }
+            }
+
+            /// <summary>
+            /// Gets the deactivated object count.
+            /// </summary>
+            /// <value>The deactivated object count.</value>
+            public int DeactivatedObjectCount
+            {
+                get
+                {
+                    return this.deactivatedObjects.Count;
+                }
+            }
+
+            /// <summary>
+            /// Clears the cache.
+            /// </summary>
+            public void Clear()
+            {
+                lock (this.activatedObjects)
+                {
+                    this.activatedObjects.Clear();
+                }
+
+                lock (this.deactivatedObjects)
+                {
+                    this.deactivatedObjects.Clear();
+                }
+            }
+
+            /// <summary>
+            /// Adds an activated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            public void AddActivatedInstance(object instance)
+            {
+                lock (this.activatedObjects)
+                {
+                    this.activatedObjects.Add(new ReferenceEqualWeakReference(instance), true);
+                }
+            }
+
+            /// <summary>
+            /// Adds an deactivated instance.
+            /// </summary>
+            /// <param name="instance">The instance to be added.</param>
+            public void AddDeactivatedInstance(object instance)
+            {
+                lock (this.deactivatedObjects)
+                {
+                    this.deactivatedObjects.Add(new ReferenceEqualWeakReference(instance), true);
+                }
+            }
+
+            /// <summary>
+            /// Determines whether the specified instance is activated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is activated; otherwise, <c>false</c>.
+            /// </returns>
+            public bool IsActivated(object instance)
+            {
+                return this.activatedObjects.ContainsKey(instance);
+            }
+
+            /// <summary>
+            /// Determines whether the specified instance is deactivated.
+            /// </summary>
+            /// <param name="instance">The instance.</param>
+            /// <returns>
+            ///     <c>true</c> if the specified instance is deactivated; otherwise, <c>false</c>.
+            /// </returns>
+            public bool IsDeactivated(object instance)
+            {
+                return this.deactivatedObjects.ContainsKey(instance);
+            }
+
+            /// <summary>
+            /// Prunes this instance.
+            /// </summary>
+            public void Prune()
+            {
+                lock (this.activatedObjects)
+                {
+                    RemoveDeadObjects(this.activatedObjects);
+                }
+
+                lock (this.deactivatedObjects)
+                {
+                    RemoveDeadObjects(this.deactivatedObjects);
+                }
+            }
+
+            /// <summary>
+            /// Removes all dead objects.
+            /// </summary>
+            /// <param name="objects">The objects collection to be freed of dead objects.</param>
+            private static void RemoveDeadObjects(IDictionary<object, bool> objects)
+            {
+                var deadObjects = objects.Where(entry => !((ReferenceEqualWeakReference)entry.Key).IsAlive).ToList();
+                foreach (var deadObject in deadObjects)
+                {
+                    objects.Remove(deadObject.Key);
+                }
+            }
         }
-#endif
     }
-}
\ No newline at end of file
+}
diff --git a/src/Ninject/Components/ComponentContainer.cs b/src/Ninject/Components/ComponentContainer.cs
index fe12ec6d..c79adbeb 100644
--- a/src/Ninject/Components/ComponentContainer.cs
+++ b/src/Ninject/Components/ComponentContainer.cs
@@ -232,7 +232,7 @@ private static ConstructorInfo SelectConstructor(Type component, Type implementa
             return constructor;
         }
 
-#if SILVERLIGHT_30 || SILVERLIGHT_20 || WINDOWS_PHONE || NETCF_35 || MONO
+#if SILVERLIGHT_30 || SILVERLIGHT_20 || WINDOWS_PHONE || NETCF_35 || MONO_20 || MONO_35
         private class HashSet<T>
         {
             private IDictionary<T, bool> data = new Dictionary<T,bool>();
@@ -249,4 +249,4 @@ public bool Contains(T o)
         }
 #endif
     }
-}
\ No newline at end of file
+}
diff --git a/src/Ninject/Infrastructure/Introspection/FormatExtensions.cs b/src/Ninject/Infrastructure/Introspection/FormatExtensions.cs
index d720e63b..c894ff49 100644
--- a/src/Ninject/Infrastructure/Introspection/FormatExtensions.cs
+++ b/src/Ninject/Infrastructure/Introspection/FormatExtensions.cs
@@ -156,14 +156,8 @@ public static string Format(this Type type)
         {
             var friendlyName = GetFriendlyName(type);
 
-#if !MONO
-            if (friendlyName.Contains("AnonymousType"))
+            if (friendlyName.Contains("AnonymousType") || friendlyName.Contains("__AnonType"))
                 return "AnonymousType";
-#else
-
-            if (friendlyName.Contains("__AnonType"))
-                return "AnonymousType";
-#endif
 
             switch (friendlyName.ToLower(CultureInfo.InvariantCulture))
             {
diff --git a/src/Ninject/Infrastructure/Language/ExtensionsForMemberInfo.cs b/src/Ninject/Infrastructure/Language/ExtensionsForMemberInfo.cs
index ee102115..54d391f1 100644
--- a/src/Ninject/Infrastructure/Language/ExtensionsForMemberInfo.cs
+++ b/src/Ninject/Infrastructure/Language/ExtensionsForMemberInfo.cs
@@ -2,10 +2,10 @@
 //
 // Author: Remo Gloor (remo.gloor@bbv.ch)
 // Copyright (c) 2010, bbv Software Engineering AG.
-// 
+//
 // Dual-licensed under the Apache License, Version 2.0, and the Microsoft Public License (Ms-PL).
 // See the file LICENSE.txt for details.
-// 
+//
 #endregion
 
 namespace Ninject.Infrastructure.Language
@@ -28,23 +28,37 @@ public static class ExtensionsForMemberInfo
         const BindingFlags Flags = DefaultFlags;
 #endif
 
-#if !MONO
-        private static MethodInfo parentDefinitionMethodInfo;
+        private static readonly IParentDefinitionStrategy parentDefinitionStrategy;
+        private static readonly ICustomAttributesForMemberInfoStrategy customAttributesStrategy;
 
-        private static MethodInfo ParentDefinitionMethodInfo
+        static ExtensionsForMemberInfo()
         {
-            get
+#if MEDIUM_TRUST
+            parentDefinitionStrategy = new TraversingParentDefinitionStrategy();
+#else
+            if (RuntimeMethodInfoBasedParentDefinitionStrategy.IsAvailable)
             {
-                if (parentDefinitionMethodInfo == null)
-                {
-                    var runtimeAssemblyInfoType = typeof(MethodInfo).Assembly.GetType("System.Reflection.RuntimeMethodInfo");
-                    parentDefinitionMethodInfo = runtimeAssemblyInfoType.GetMethod("GetParentDefinition", Flags);
-                }
+                parentDefinitionStrategy = new RuntimeMethodInfoBasedParentDefinitionStrategy();
+            }
+            else
+            {
+                parentDefinitionStrategy = new TraversingParentDefinitionStrategy();
+            }
+#endif
 
-                return parentDefinitionMethodInfo;
+#if !NET_35
+            if (RuntimeEnvironment.IsMonoOnFramework40OrGreater())
+            {
+                customAttributesStrategy = new TraversingCustomAttributesStrategy();
             }
-        }
+            else
+            {
+                customAttributesStrategy = new StandardDotNetCustomAttributesStrategy();
+            }
+#else
+            customAttributesStrategy = new TraversingCustomAttributesStrategy();
 #endif
+        }
 
         /// <summary>
         /// Determines whether the specified member has attribute.
@@ -133,17 +147,7 @@ public static bool IsPrivate(this PropertyInfo propertyInfo)
         /// <returns></returns>
         public static object[] GetCustomAttributesExtended(this MemberInfo member, Type attributeType, bool inherited)
         {
-#if !NET_35 && !MONO_40
-            return Attribute.GetCustomAttributes(member, attributeType, inherited);
-#else
-            var propertyInfo = member as PropertyInfo;
-            if (propertyInfo != null)
-            {
-                return GetCustomAttributes(propertyInfo, attributeType, inherited);
-            }
-
-            return member.GetCustomAttributes(attributeType, inherited);
-#endif
+            return customAttributesStrategy.GetCustomAttributesExtended(member, attributeType, inherited);
         }
 
         private static PropertyInfo GetParentDefinition(PropertyInfo property)
@@ -163,25 +167,7 @@ private static PropertyInfo GetParentDefinition(PropertyInfo property)
 
         private static MethodInfo GetParentDefinition(this MethodInfo method, BindingFlags flags)
         {
-#if MEDIUM_TRUST || MONO
-            var baseDefinition = method.GetBaseDefinition(); 
-            var type = method.DeclaringType.BaseType;
-            MethodInfo result = null;
-            while (result == null && type != null)
-            {
-                result = type.GetMethods(flags).Where(m => m.GetBaseDefinition().Equals(baseDefinition)).SingleOrDefault();
-                type = type.BaseType;
-            }
-
-            return result;
-#else
-            if (ParentDefinitionMethodInfo == null)
-            {
-                return null;
-            }
-
-            return (MethodInfo)ParentDefinitionMethodInfo.Invoke(method, flags, null, null, CultureInfo.InvariantCulture);
-#endif
+            return parentDefinitionStrategy.GetParentDefinition(method, flags);
         }
 
         private static bool IsDefined(PropertyInfo element, Type attributeType, bool inherit)
@@ -212,53 +198,144 @@ private static bool IsDefined(PropertyInfo element, Type attributeType, bool inh
             return false;
         }
 
-        private static object[] GetCustomAttributes(PropertyInfo propertyInfo, Type attributeType, bool inherit)
+        private static void AddAttributes(List<object> attributes, object[] customAttributes, Dictionary<Type, bool> attributeUsages)
         {
-            if (inherit)
+            foreach (object attribute in customAttributes)
+            {
+                Type type = attribute.GetType();
+                if (!attributeUsages.ContainsKey(type))
+                {
+                    attributeUsages[type] = InternalGetAttributeUsage(type).Inherited;
+                }
+
+                if (attributeUsages[type])
+                {
+                    attributes.Add(attribute);
+                }
+            }
+        }
+
+        private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
+        {
+            object[] customAttributes = type.GetCustomAttributes(typeof(AttributeUsageAttribute), true);
+            return (AttributeUsageAttribute)customAttributes[0];
+        }
+
+        private interface IParentDefinitionStrategy
+        {
+            MethodInfo GetParentDefinition(MethodInfo method, BindingFlags flags);
+        }
+
+        private class RuntimeMethodInfoBasedParentDefinitionStrategy : IParentDefinitionStrategy
+        {
+            private static MethodInfo parentDefinitionMethodInfo;
+
+            private MethodInfo ParentDefinitionMethodInfo
             {
-                if (InternalGetAttributeUsage(attributeType).Inherited)
+                get
                 {
-                    var attributeUsages = new Dictionary<Type, bool>();
-                    var attributes = new List<object>();
-                    attributes.AddRange(propertyInfo.GetCustomAttributes(attributeType, false));
-                    for (var info = GetParentDefinition(propertyInfo);
-                         info != null;
-                         info = GetParentDefinition(info))
+                    if (parentDefinitionMethodInfo == null)
                     {
-                        object[] customAttributes = info.GetCustomAttributes(attributeType, false);
-                        AddAttributes(attributes, customAttributes, attributeUsages);
+                        var runtimeAssemblyInfoType = typeof(MethodInfo).Assembly.GetType("System.Reflection.RuntimeMethodInfo");
+                        parentDefinitionMethodInfo = runtimeAssemblyInfoType.GetMethod("GetParentDefinition", Flags);
                     }
 
-                    var result = Array.CreateInstance(attributeType, attributes.Count) as object[];
-                    Array.Copy(attributes.ToArray(), result, result.Length);
-                    return result;
+                    return parentDefinitionMethodInfo;
+                }
+            }
+
+            public MethodInfo GetParentDefinition(MethodInfo method, BindingFlags flags)
+            {
+                if (ParentDefinitionMethodInfo == null)
+                {
+                    return null;
                 }
+
+                return (MethodInfo)ParentDefinitionMethodInfo.Invoke(method, flags, null, null, CultureInfo.InvariantCulture);
             }
 
-            return propertyInfo.GetCustomAttributes(attributeType, inherit);
+            internal static bool IsAvailable
+            {
+                get {
+                    var runtimeAssemblyInfoType = typeof(MethodInfo).Assembly.GetType("System.Reflection.RuntimeMethodInfo");
+                    if (runtimeAssemblyInfoType == null)
+                    {
+                        return false;
+                    }
+                    parentDefinitionMethodInfo = runtimeAssemblyInfoType.GetMethod("GetParentDefinition", Flags);
+                    return parentDefinitionMethodInfo != null;
+                }
+            }
         }
 
-        private static void AddAttributes(List<object> attributes, object[] customAttributes, Dictionary<Type, bool> attributeUsages)
+        private class TraversingParentDefinitionStrategy : IParentDefinitionStrategy
         {
-            foreach (object attribute in customAttributes)
+            public MethodInfo GetParentDefinition(MethodInfo method, BindingFlags flags)
             {
-                Type type = attribute.GetType();
-                if (!attributeUsages.ContainsKey(type))
+                var baseDefinition = method.GetBaseDefinition();
+                var type = method.DeclaringType.BaseType;
+                MethodInfo result = null;
+                while (result == null && type != null)
                 {
-                    attributeUsages[type] = InternalGetAttributeUsage(type).Inherited;
+                    result = type.GetMethods(flags).SingleOrDefault(m => m.GetBaseDefinition().Equals(baseDefinition));
+                    type = type.BaseType;
                 }
 
-                if (attributeUsages[type])
+                return result;
+            }
+        }
+
+        private interface ICustomAttributesForMemberInfoStrategy
+        {
+            object[] GetCustomAttributesExtended(MemberInfo member, Type attributeType, bool inherited);
+        }
+
+        private class TraversingCustomAttributesStrategy : ICustomAttributesForMemberInfoStrategy
+        {
+            public object[] GetCustomAttributesExtended(MemberInfo member, Type attributeType, bool inherited)
+            {
+                var propertyInfo = member as PropertyInfo;
+                if (propertyInfo != null)
                 {
-                    attributes.Add(attribute);
+                    return GetCustomAttributes(propertyInfo, attributeType, inherited);
+                }
+
+                return member.GetCustomAttributes(attributeType, inherited);
+            }
+
+            private static object[] GetCustomAttributes(PropertyInfo propertyInfo, Type attributeType, bool inherit)
+            {
+                if (inherit)
+                {
+                    if (InternalGetAttributeUsage(attributeType).Inherited)
+                    {
+                        var attributeUsages = new Dictionary<Type, bool>();
+                        var attributes = new List<object>();
+                        attributes.AddRange(propertyInfo.GetCustomAttributes(attributeType, false));
+                        for (var info = GetParentDefinition(propertyInfo);
+                             info != null;
+                             info = GetParentDefinition(info))
+                        {
+                            object[] customAttributes = info.GetCustomAttributes(attributeType, false);
+                            AddAttributes(attributes, customAttributes, attributeUsages);
+                        }
+
+                        var result = Array.CreateInstance(attributeType, attributes.Count) as object[];
+                        Array.Copy(attributes.ToArray(), result, result.Length);
+                        return result;
+                    }
                 }
+
+                return propertyInfo.GetCustomAttributes(attributeType, inherit);
             }
         }
 
-        private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
+        private class StandardDotNetCustomAttributesStrategy : ICustomAttributesForMemberInfoStrategy
         {
-            object[] customAttributes = type.GetCustomAttributes(typeof(AttributeUsageAttribute), true);
-            return (AttributeUsageAttribute)customAttributes[0];
-        } 
+            public object[] GetCustomAttributesExtended(MemberInfo member, Type attributeType, bool inherited)
+            {
+                return Attribute.GetCustomAttributes(member, attributeType, inherited);
+            }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Ninject/Ninject.csproj b/src/Ninject/Ninject.csproj
index 199f2dbe..33f77f17 100644
--- a/src/Ninject/Ninject.csproj
+++ b/src/Ninject/Ninject.csproj
@@ -179,6 +179,7 @@
     <Compile Include="Planning\Bindings\Resolvers\SelfBindingResolver.cs" />
     <Compile Include="Planning\Bindings\Resolvers\StandardBindingResolver.cs" />
     <Compile Include="Planning\Bindings\Resolvers\IBindingResolver.cs" />
+    <Compile Include="RuntimeEnvironment.cs" />
     <Compile Include="Selection\Heuristics\IInjectionHeuristic.cs" />
     <Compile Include="Selection\Heuristics\SpecificConstructorSelector.cs" />
     <Compile Include="Syntax\BindingRoot.cs" />
@@ -284,7 +285,7 @@
     </BootstrapperPackage>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
   </Target>
diff --git a/src/Ninject/RuntimeEnvironment.cs b/src/Ninject/RuntimeEnvironment.cs
new file mode 100644
index 00000000..3bbe04e2
--- /dev/null
+++ b/src/Ninject/RuntimeEnvironment.cs
@@ -0,0 +1,32 @@
+using System;
+
+namespace Ninject
+{
+    /// <summary>
+    /// Utility method to determine runtime platform.
+    /// </summary>
+    public static class RuntimeEnvironment
+    {
+        /// <summary>
+        /// Is the code currently running on a Mono runtime?
+        /// </summary>
+        public static bool IsMonoRuntime
+        {
+            get
+            {
+                var t = Type.GetType("Mono.Runtime");
+                return t != null;
+            }
+        }
+
+        /// <summary>
+        /// Is the code currently running on Mono-4.0 or later?
+        /// </summary>
+        /// <returns></returns>
+        public static bool IsMonoOnFramework40OrGreater()
+        {
+            // If we are running on a 4.x runtime, we assume that we're running on a .NET 4+ compatible framework
+            return IsMonoRuntime && Environment.Version.Major >= 4;
+        }
+    }
+}
\ No newline at end of file