C# IMethodRemover.RemoveMethod方法代码示例

 public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder spec) {
     var attr = type.GetCustomAttribute<NakedObjectsTypeAttribute>();
     if (attr == null) {
         RemoveExplicitlyIgnoredMembers(type, methodRemover);
     } else {
         switch (attr.ReflectionScope) {
             case ReflectOver.All:
                 RemoveExplicitlyIgnoredMembers(type, methodRemover);
             break;
             case ReflectOver.TypeOnlyNoMembers:
                 foreach (MethodInfo method in type.GetMethods()) {
                     methodRemover.RemoveMethod(method);
                 }
                 break;
             case ReflectOver.ExplicitlyIncludedMembersOnly:
                 foreach (MethodInfo method in type.GetMethods()) {
                     if (method.GetCustomAttribute<NakedObjectsIncludeAttribute>() == null) {
                         methodRemover.RemoveMethod(method);
                     }
                 }
                 break;
             case ReflectOver.None:
                 throw new ReflectionException("Attempting to introspect a class that has been marked with NakedObjectsType with ReflectOver.None");
             default:
                 throw new ReflectionException(String.Format("Unhandled value for ReflectOver: {0}", attr.ReflectionScope));
         }
     }
 }

        /// <summary>
        ///     If no title or ToString can be used then will use Facets provided by
        ///     <see cref="FallbackFacetFactory" /> instead.
        /// </summary>
        public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder facetHolder) {
            IList<MethodInfo> attributedMethods = new List<MethodInfo>();
            foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
                if (propertyInfo.GetCustomAttribute<TitleAttribute>() != null) {
                    if (attributedMethods.Count > 0) {
                        Log.Warn("Title annotation is used more than once in " + type.Name + ", this time on property " + propertyInfo.Name + "; this will be ignored");
                    }
                    attributedMethods.Add(propertyInfo.GetGetMethod());
                }
            }

            if (attributedMethods.Count > 0) {
                return FacetUtils.AddFacet(new TitleFacetViaProperty(attributedMethods.First(), facetHolder));
            }

            try {
                MethodInfo titleMethod = FindMethod(type, MethodType.Object, PrefixesAndRecognisedMethods.TitleMethod, typeof (string), Type.EmptyTypes);
                IFacet titleFacet = null;

                if (titleMethod != null) {
                    methodRemover.RemoveMethod(titleMethod);
                    titleFacet = new TitleFacetViaTitleMethod(titleMethod, facetHolder);
                }

                MethodInfo toStringMethod = FindMethod(type, MethodType.Object, PrefixesAndRecognisedMethods.ToStringMethod, typeof (string), Type.EmptyTypes);
                if (toStringMethod != null && !toStringMethod.DeclaringType.Equals(typeof (object))) {
                    methodRemover.RemoveMethod(toStringMethod);
                }
                else {
                    // on object do not use 
                    toStringMethod = null;
                }

                MethodInfo maskMethod = FindMethod(type, MethodType.Object, PrefixesAndRecognisedMethods.ToStringMethod, typeof (string), new[] {typeof (string)});

                if (maskMethod != null) {
                    methodRemover.RemoveMethod(maskMethod);
                }

                if (titleFacet == null && toStringMethod == null) {
                    // nothing to use 
                    return false;
                }

                if (titleFacet == null) {
                    titleFacet = new TitleFacetViaToStringMethod(toStringMethod, maskMethod, facetHolder);
                }

                return FacetUtils.AddFacet(titleFacet);
            }
            catch {
                return false;
            }
        }

        /// <summary>
        ///     If no title or ToString can be used then will use Facets provided by
        ///     <see cref="FallbackFacetFactory" /> instead.
        /// </summary>
        public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
            IList<MethodInfo> attributedMethods = new List<MethodInfo>();
            foreach (PropertyInfo propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
                if (propertyInfo.GetCustomAttribute<TitleAttribute>() != null) {
                    if (attributedMethods.Count > 0) {
                        Log.Warn("Title annotation is used more than once in " + type.Name + ", this time on property " + propertyInfo.Name + "; this will be ignored");
                    }
                    attributedMethods.Add(propertyInfo.GetGetMethod());
                }
            }

            if (attributedMethods.Count > 0) {
                // attributes takes priority
                FacetUtils.AddFacet(new TitleFacetViaProperty(attributedMethods.First(), specification));
                return;
            }

            try {
                MethodInfo titleMethod = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.TitleMethod, typeof (string), Type.EmptyTypes);
                IFacet titleFacet = null;

                if (titleMethod != null) {
                    methodRemover.RemoveMethod(titleMethod);
                    titleFacet = new TitleFacetViaTitleMethod(titleMethod, specification);
                }

                MethodInfo toStringMethod = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.ToStringMethod, typeof (string), Type.EmptyTypes);
                if (toStringMethod != null && !(toStringMethod.DeclaringType == typeof (object))) {
                    methodRemover.RemoveMethod(toStringMethod);
                }
                else {
                    // on object do not use 
                    toStringMethod = null;
                }

                MethodInfo maskMethod = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.ToStringMethod, typeof(string), new[] { typeof(string) });

                if (maskMethod != null) {
                    methodRemover.RemoveMethod(maskMethod);
                }

                if (titleFacet == null && toStringMethod != null) {
                    titleFacet = new TitleFacetViaToStringMethod(maskMethod, specification);
                }

                FacetUtils.AddFacet(titleFacet);
            }
            catch (Exception e) {
                Log.Warn("Unexpected Exception", e);
            }
        }

 public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
     if (typeof (IEnumerable).IsAssignableFrom(type) && !TypeUtils.IsSystem(type)) {
         MethodInfo method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.GetEnumeratorMethod, null, Type.EmptyTypes);
         if (method != null) {
             methodRemover.RemoveMethod(method);
         }
     }
 }

 public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
     if (IsDynamicProxyType(type)) {
         foreach (MethodInfo method in type.GetMethods().Join(MethodsToRemove, mi => mi.Name, s => s, (mi, s) => mi)) {
             if (methodRemover != null && method != null) {
                 methodRemover.RemoveMethod(method);
             }
         }
     }
 }

 public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
     if (typeof (IEnumerable).IsAssignableFrom(type) && !TypeUtils.IsSystem(type)) {
         MethodInfo method = FindMethod(type, MethodType.Object, PrefixesAndRecognisedMethods.GetEnumeratorMethod, null, Type.EmptyTypes);
         if (method != null) {
             methodRemover.RemoveMethod(method);
         }
     }
     return false;
 }

 public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {
     try {
         foreach (string methodName in FixedPrefixes) {
             MethodInfo methodInfo = FindMethod(reflector, type, MethodType.Object, methodName, typeof (string), Type.EmptyTypes);
             if (methodInfo != null) {
                 methodRemover.RemoveMethod(methodInfo);
             }
         }
     }
     catch (Exception e) {
         Log.Error("Unexpected exception", e);
     }
 }

 public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder facetHolder) {
     try {
         foreach (string methodName in FixedPrefixes) {
             MethodInfo methodInfo = FindMethod(type, MethodType.Object, methodName, typeof (string), Type.EmptyTypes);
             if (methodInfo != null) {
                 methodRemover.RemoveMethod(methodInfo);
             }
         }
         return false;
     }
     catch {
         return false;
     }
 }

        public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) {

            var methodPeers = new List<ValidateObjectFacet.NakedObjectValidationMethod>();
            MethodInfo[] methods = FindMethods(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.ValidatePrefix, typeof (string));

            if (methods.Any()) {
                foreach (MethodInfo method in methods) {
                    ParameterInfo[] parameters = method.GetParameters();
                    if (parameters.Length >= 2) {
                        bool parametersMatch = parameters.Select(parameter => parameter.Name).Select(name => name[0].ToString(Thread.CurrentThread.CurrentCulture).ToUpper() + name.Substring(1)).All(p => ContainsField(p, type));
                        if (parametersMatch) {
                            methodPeers.Add(new ValidateObjectFacet.NakedObjectValidationMethod(method));
                            methodRemover.RemoveMethod(method);
                        }
                    }
                }
            }

            IValidateObjectFacet validateFacet = methodPeers.Any() ? (IValidateObjectFacet) new ValidateObjectFacet(specification, methodPeers) : new ValidateObjectFacetNull(specification);
            FacetUtils.AddFacet(validateFacet);
        }

 protected void FindAndRemoveHideMethod(IReflector reflector, IList<IFacet> facets, IMethodRemover methodRemover, Type type, MethodType methodType, string capitalizedName, ISpecification specification) {
     MethodInfo method = FindMethod(reflector, type, methodType, RecognisedMethodsAndPrefixes.HidePrefix + capitalizedName, typeof (bool), Type.EmptyTypes);
     if (method != null) {
         methodRemover.RemoveMethod(method);
         facets.Add(new HideForContextFacet(method, specification));
         AddOrAddToExecutedWhereFacet(method, specification);
     }
 }

 protected static void RemoveMethod(IMethodRemover methodRemover, MethodInfo method) {
     if (methodRemover != null && method != null) {
         methodRemover.RemoveMethod(method);
     }
 }

 private static void RemoveExplicitlyIgnoredMembers(Type type, IMethodRemover methodRemover) {
     foreach (MethodInfo method in type.GetMethods().Where(m => m.GetCustomAttribute<NakedObjectsIgnoreAttribute>() != null)) {
         methodRemover.RemoveMethod(method);
     }
 }