C# Binder.SelectMethod方法代码示例

		internal static ConstructorInfo GetConstructorImpl (ConstructorInfo[] methods, BindingFlags bindingAttr,
								       Binder binder,
								       CallingConventions callConvention,
								       Type[] types,
								       ParameterModifier[] modifiers)
		{
			if (bindingAttr == BindingFlags.Default)
				bindingAttr = BindingFlags.Public | BindingFlags.Instance;

			ConstructorInfo found = null;
			MethodBase[] match;
			int count = 0;
			foreach (ConstructorInfo m in methods) {
				// Under MS.NET, Standard|HasThis matches Standard...
				if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
					continue;
				found = m;
				count++;
			}
			if (count == 0)
				return null;
			if (types == null) {
				if (count > 1)
					throw new AmbiguousMatchException ();
				return (ConstructorInfo) CheckMethodSecurity (found);
			}
			match = new MethodBase [count];
			if (count == 1)
				match [0] = found;
			else {
				count = 0;
				foreach (ConstructorInfo m in methods) {
					if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
						continue;
					match [count++] = m;
				}
			}
			if (binder == null)
				binder = Binder.DefaultBinder;
			return (ConstructorInfo) CheckMethodSecurity (binder.SelectMethod (bindingAttr, match, types, modifiers));
		}

		protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder,
								       CallingConventions callConvention, Type[] types,
								       ParameterModifier[] modifiers)
		{
			check_created ();

			if (created == typeof (object)) {
				/* 
				 * This happens when building corlib. Calling created.GetConstructor 
				 * would return constructors from the real mscorlib, instead of the
				 * newly built one.
				 */

				if (ctors == null)
					return null;
 
				ConstructorBuilder found = null;
				int count = 0;
			
				foreach (ConstructorBuilder cb in ctors) {
					if (callConvention != CallingConventions.Any && cb.CallingConvention != callConvention)
						continue;
					found = cb;
					count++;
				}

				if (count == 0)
					return null;
				if (types == null) {
					if (count > 1)
						throw new AmbiguousMatchException ();
					return found;
				}
				MethodBase[] match = new MethodBase [count];
				if (count == 1)
					match [0] = found;
				else {
					count = 0;
					foreach (ConstructorInfo m in ctors) {
						if (callConvention != CallingConventions.Any && m.CallingConvention != callConvention)
							continue;
						match [count++] = m;
					}
				}
				if (binder == null)
					binder = DefaultBinder;
				return (ConstructorInfo) binder.SelectMethod (bindingAttr, match,
															  types, modifiers);
			}

			return created.GetConstructor (bindingAttr, binder, 
				callConvention, types, modifiers);
		}

		protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr,
							     Binder binder,
							     CallingConventions callConvention,
							     Type[] types, ParameterModifier[] modifiers)
		{
			bool ignoreCase = ((bindingAttr & BindingFlags.IgnoreCase) != 0);
			MethodInfo[] methods = GetMethodsByName (name, bindingAttr, ignoreCase, this);
			MethodInfo found = null;
			MethodBase[] match;
			int count = 0;
			
			foreach (MethodInfo m in methods) {
				// Under MS.NET, Standard|HasThis matches Standard...
				if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
					continue;
				found = m;
				count++;
			}

			if (count == 0)
				return null;
			
			if (count == 1 && types == null) 
				return (MethodInfo) CheckMethodSecurity (found);

			match = new MethodBase [count];
			if (count == 1)
				match [0] = found;
			else {
				count = 0;
				foreach (MethodInfo m in methods) {
					if (callConvention != CallingConventions.Any && ((m.CallingConvention & callConvention) != callConvention))
						continue;
					match [count++] = m;
				}
			}

			if (types == null) 
				return (MethodInfo) CheckMethodSecurity (Binder.FindMostDerivedMatch (match));

			if (binder == null)
				binder = Binder.DefaultBinder;
			
			return (MethodInfo) CheckMethodSecurity (binder.SelectMethod (bindingAttr, match, types, modifiers));
		}

 public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers)
 {
     MemberInfo[] member = this.GetMember(name, bindingAttr);
     if (member.Length == 1)
     {
         return (member[0] as MethodInfo);
     }
     int num = 0;
     foreach (MemberInfo info in member)
     {
         if (info.MemberType == MemberTypes.Method)
         {
             num++;
         }
     }
     if (num == 0)
     {
         return null;
     }
     MethodInfo[] match = new MethodInfo[num];
     num = 0;
     foreach (MemberInfo info2 in member)
     {
         if (info2.MemberType == MemberTypes.Method)
         {
             match[num++] = (MethodInfo) info2;
         }
     }
     if (binder == null)
     {
         binder = JSBinder.ob;
     }
     return (MethodInfo) binder.SelectMethod(bindingAttr, match, types, modifiers);
 }

        internal MethodInfo GetMethodImplInternal(String name,
                                                  BindingFlags bindingAttr,
                                                  Binder binder,
                                                  CallingConventions callConvention, 
                                                  Type[] types,
                                                  ParameterModifier[] modifiers, 
                                                  bool verifyAccess)
        {       
            if (binder == null)
                binder = DefaultBinder;
            
            // If the types array is null that means we don't care about the arguments to the method, we will simply
            //  return the one that matchs or throw an argument error...
            int argCnt = (types != null) ? types.Length : -1;
            MethodBase[] meths = GetMemberMethod(name, 
                                                 bindingAttr, 
                                                 callConvention, 
                                                 types, 
                                                 argCnt,
                                                 verifyAccess);
            // at this point a proper filter with respect to BindingAttributes and calling convention already happened
            if (meths == null)
                return null;
            if (argCnt <= 0) {
                // either no args or a method with 0 args was specified
                if (meths.Length == 1)
                    return (MethodInfo) meths[0];
                else if (argCnt < 0) {
                    // There are multiple methods with the same name. Check to see if they are all
                    // new slots with the same name and sig.
                    foreach(MethodBase m in meths) {
                        if (!System.DefaultBinder.CompareMethodSigAndName(m, meths[0]))
                            // One of the methods is not a new slot. So the match is ambigous.
                            throw new AmbiguousMatchException(Environment.GetResourceString("RFLCT.Ambiguous"));
                        }

                    // All the methods are new slots with the same name and sig so return the most derived one.
                    return (MethodInfo) System.DefaultBinder.FindMostDerivedNewSlotMeth(meths, meths.Length);
                }
            }   
            
            return (MethodInfo) binder.SelectMethod(bindingAttr,meths,types,modifiers);                  
        }

     internal ConstructorInfo GetConstructorImplInternal(BindingFlags bindingAttr,
                                                         Binder binder,
                                                         CallingConventions callConvention, 
                                                         Type[] types,
                                                         ParameterModifier[] modifiers, 
                                                         bool verifyAccess)
     {
 
         // Must provide some types (Type[0] for nothing)
         if (types == null)
             throw new ArgumentNullException("types");
         
         if (binder == null)
             binder = DefaultBinder;
         
         int argCnt = types.Length;
         bool isDelegate;
         MethodBase[] cons = GetMemberCons(bindingAttr, 
                                           callConvention, 
                                           types,
                                           argCnt, 
                                           verifyAccess, 
                                           /*binder == DefaultBinder, */
                                           out isDelegate);
         if (cons == null)
             return null;
         
         if (argCnt == 0 && cons.Length == 1) { 
             ParameterInfo[] pars = cons[0].GetParameters();
             if (pars == null || pars.Length == 0) {
                 return (ConstructorInfo) cons[0];
             }
         }
         if ((bindingAttr & BindingFlags.ExactBinding) != 0)
             return (ConstructorInfo) System.DefaultBinder.ExactBinding(cons,types,modifiers);
         
         return (ConstructorInfo) binder.SelectMethod(bindingAttr,cons,types,modifiers);
     }   

 public MethodInfo GetMethod(String name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers){
   MemberInfo[] members = this.GetMember(name, bindingAttr);
   if (members.Length == 1) return members[0] as MethodInfo;
   int methodCount = 0;
   foreach (MemberInfo member in members)
     if (member.MemberType == MemberTypes.Method) methodCount++;
   if (methodCount == 0) return null;
   MethodInfo[] methods = new MethodInfo[methodCount];
   methodCount = 0;
   foreach (MemberInfo member in members)
     if (member.MemberType == MemberTypes.Method) methods[methodCount++] = (MethodInfo)member;
   if (binder == null) binder = JSBinder.ob;
   return (MethodInfo)binder.SelectMethod(bindingAttr, methods, types, modifiers);
 }