Reduce impact of extra collection pass

Assuming that default interface methods are relatively rare, if we keep
track of which interfaces contain any of them at all, we can then limit
our extra pass during class proxy generation to just those interfaces
and exclude the rest (i.e. hopefully the majority).

src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs

@@ -44,6 +44,11 @@ protected override IEnumerable<MembersCollector> GetCollectors()
 
 			foreach (var @interface in targetType.GetAllInterfaces())
 			{
+				if (@interface.HasAnyOverridableDefaultImplementations() == false)
+				{
+					continue;
+				}
+
 				yield return new InterfaceMembersWithDefaultImplementationCollector(@interface, targetType);
 			}
 

src/Castle.Core/DynamicProxy/Internal/TypeUtil.cs

@@ -27,6 +27,7 @@ namespace Castle.DynamicProxy.Internal
 	public static class TypeUtil
 	{
 		private static readonly Dictionary<Type, MethodInfo[]> instanceMethodsCache = new Dictionary<Type, MethodInfo[]>();
+		private static readonly Dictionary<Type, bool> hasAnyOverridableDefaultImplementationsCache = new Dictionary<Type, bool>();
 
 		internal static bool IsNullableType(this Type type)
 		{
@@ -134,6 +135,32 @@ public static Type GetTypeOrNull(object target)
 			return target.GetType();
 		}
 
+		internal static bool HasAnyOverridableDefaultImplementations(this Type interfaceType)
+		{
+			Debug.Assert(interfaceType != null);
+			Debug.Assert(interfaceType.IsInterface);
+
+			var cache = hasAnyOverridableDefaultImplementationsCache;
+			lock (cache)
+			{
+				if (!cache.TryGetValue(interfaceType, out var result))
+				{
+					foreach (var method in interfaceType.GetAllInstanceMethods())
+					{
+						if (method.IsAbstract == false && method.IsFinal == false && method.IsVirtual)
+						{
+							result = true;
+							break;
+						}
+					}
+
+					cache[interfaceType] = result;
+				}
+
+				return result;
+			}
+		}
+
 		internal static Type[] AsTypeArray(this GenericTypeParameterBuilder[] typeInfos)
 		{
 			Type[] types = new Type[typeInfos.Length];