public abstract SelectMethod ( BindingFlags bindingAttr, Array match, Array types, Array modifiers ) : |
||
bindingAttr | BindingFlags | |
match | Array | |
types | Array | |
modifiers | Array | |
return |
public override MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] argumentTypes, ParameterModifier[] modifiers) #endif { if (match.Length == 0) { return(null); } #if CSHARP8 MethodBase?result = null; #else MethodBase result = null; #endif // SelectMethod on the default binder throws an exception if passed // typebuilders. this comes up when trying to bind to proxy methods // during analysis when (the proxy type is not yet complete). we // skip the default binder in this case and fall back on our own logic bool allRuntimeTypes = true; for (var i = 0; i < argumentTypes.Length; i++) { if (argumentTypes[i] is System.Reflection.Emit.TypeBuilder) { allRuntimeTypes = false; break; } } if (allRuntimeTypes) { result = _binder.SelectMethod(bindingAttr, match, argumentTypes, modifiers); } if (result != null) { return(result); } foreach (var candidate in match) { if (MatchByMagicBindingRules(bindingAttr, candidate, argumentTypes, modifiers)) { if (result != null) { throw new AmbiguousMatchException(); } else { result = candidate; continue; } } } return(result); }
/// <include file='doc\Module.uex' path='docs/doc[@for="Module.GetMethodImpl"]/*' /> protected virtual MethodInfo GetMethodImpl(String name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers) { if (binder == null) { binder = Type.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 = InternalGetMethod(name, bindingAttr, callConvention, types, argCnt); // 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)); }
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); }
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 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); }