|
public abstract GetBaseDefinition ( ) : |
||
| return | ||
public MethodInfo(System.Reflection.MethodInfo mi)
{
name = mi.Name;
// get acces modifires
modificators = GetModificators(mi.GetType()) + mi.ToString();
if (mi.IsAbstract && !mi.DeclaringType.IsInterface)
{
modificators += "abstract ";
}
if (mi.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null)
{
modificators += "async ";
}
if ((mi.MethodImplementationFlags & MethodImplAttributes.InternalCall) != 0)
{
modificators += "extern ";
}
if (!mi.Equals(mi.GetBaseDefinition()))
{
modificators += "overriden ";
}
if (mi.IsVirtual && mi.IsFinal)
{
modificators += "sealed ";
}
if (mi.IsStatic)
{
modificators += "static ";
}
if (mi.IsVirtual && !mi.IsFinal && mi.Equals(mi.GetBaseDefinition()) && !mi.DeclaringType.IsInterface)
{
modificators += "virtual ";
}
}
private static PropertyInfo GetProperty(MethodInfo propertyGetterOrSetter)
{
return
(from property in propertyGetterOrSetter.DeclaringType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
let getMethod = property.GetGetMethod(true)
let setMethod = property.GetSetMethod(true)
where (getMethod != null && getMethod.GetBaseDefinition().Equals(propertyGetterOrSetter.GetBaseDefinition()))
|| (setMethod != null && setMethod.GetBaseDefinition().Equals(propertyGetterOrSetter.GetBaseDefinition()))
select property).Single();
}
///// <summary>
///// 创建并返回当前方法的拦截器管道
///// </summary>
//public InterceptorPipeline CreatePipeline(MethodInfo method, Func<IEnumerable<IInterceptor>> getInterceptors)
//{
// var key = InterceptorPipelineKey.ForMethod(method);
// if (pipelines.ContainsKey(key))
// return pipelines[key];
// if (method.GetBaseDefinition() == method)
// return pipelines[key] = new InterceptorPipeline(getInterceptors());
// return pipelines[key] = CreatePipeline(method.GetBaseDefinition(), getInterceptors);
//}
/// <summary>
/// 创建并返回当前方法的拦截器管道
/// </summary>
public InterceptorPipeline CreatePipeline(MethodInfo method, Func<MethodInfo, IEnumerable<IInterceptor>> getInterceptors)
{
var key = InterceptorPipelineKey.ForMethod(method);
if(pipelines.ContainsKey(key))
return pipelines[key];
if(method.GetBaseDefinition() == method)
return pipelines[key] = new InterceptorPipeline(getInterceptors(method));
return pipelines[key] = CreatePipeline(method.GetBaseDefinition(), getInterceptors);
}
private bool IsValidActionMethod(MethodInfo methodInfo, bool stripInfrastructureMethods)
{
if (methodInfo.IsSpecialName)
{
// not a normal method, e.g. a constructor or an event
return false;
}
if (methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(AsyncController)))
{
// is a method on Object, ControllerBase, Controller, or AsyncController
return false;
}
if (stripInfrastructureMethods)
{
if (IsCompletedSuffixedMethod(methodInfo))
{
// do not match FooCompleted() methods, as these are infrastructure methods
return false;
}
}
return true;
}
internal NativeMethodBuilder (MethodInfo minfo) {
ExportAttribute ea = (ExportAttribute) Attribute.GetCustomAttribute (minfo.GetBaseDefinition (), typeof (ExportAttribute));
ParameterInfo [] parms = minfo.GetParameters ();
if (ea == null)
throw new ArgumentException ("MethodInfo does not have a export attribute");
rettype = ConvertReturnType (minfo.ReturnType);
// FIXME: We should detect if this is in a bound assembly or not and only alloc if needed
Selector = new Selector (ea.Selector ?? minfo.Name, true).Handle;
Signature = string.Format ("{0}@:", TypeConverter.ToNative (rettype));
ParameterTypes = new Type [2 + parms.Length];
ParameterTypes [0] = typeof (NSObject);
ParameterTypes [1] = typeof (Selector);
for (int i = 0; i < parms.Length; i++) {
if (parms [i].ParameterType.IsByRef && (parms[i].ParameterType.IsSubclassOf (typeof (NSObject)) || parms[i].ParameterType == typeof (NSObject)))
ParameterTypes [i + 2] = typeof (IntPtr).MakeByRefType ();
else
ParameterTypes [i + 2] = parms [i].ParameterType;
Signature += TypeConverter.ToNative (parms [i].ParameterType);
}
DelegateType = CreateDelegateType (rettype, ParameterTypes);
this.minfo = minfo;
}
private static bool HasSameBaseMethod(MethodInfo first, MethodInfo second)
{
var baseOfFirst = first.GetBaseDefinition();
var baseOfSecond = second.GetBaseDefinition();
return IsSameMethod(baseOfFirst, baseOfSecond);
}
internal NativeMethodBuilder(MethodInfo minfo)
{
ExportAttribute ea = (ExportAttribute) Attribute.GetCustomAttribute (minfo.GetBaseDefinition (), typeof (ExportAttribute));
if (ea == null)
throw new ArgumentException ("MethodInfo does not have a export attribute");
parms = minfo.GetParameters ();
rettype = ConvertReturnType (minfo.ReturnType);
// FIXME: We should detect if this is in a bound assembly or not and only alloc if needed
Selector = new Selector (ea.Selector ?? minfo.Name, true).Handle;
Signature = string.Format ("{0}@:", TypeConverter.ToNative (rettype));
ParameterTypes = new Type [2 + parms.Length];
ParameterTypes [0] = typeof (NSObject);
ParameterTypes [1] = typeof (Selector);
for (int i = 0; i < parms.Length; i++) {
if (parms [i].ParameterType.IsByRef && (parms[i].ParameterType.GetElementType ().IsSubclassOf (typeof (NSObject)) || parms[i].ParameterType.GetElementType () == typeof (NSObject)))
ParameterTypes [i + 2] = typeof (IntPtr).MakeByRefType ();
else
ParameterTypes [i + 2] = parms [i].ParameterType;
// The TypeConverter will emit a ^@ for a byref type that is a NSObject or NSObject subclass in this case
// If we passed the ParameterTypes [i+2] as would be more logical we would emit a ^^v for that case, which
// while currently acceptible isn't representative of what obj-c wants.
Signature += TypeConverter.ToNative (parms [i].ParameterType);
}
DelegateType = CreateDelegateType (rettype, ParameterTypes);
this.minfo = minfo;
}
public override IEnumerable<IRouteAttribute> GetRouteAttributes(MethodInfo actionMethod)
{
// Logic from ApiControllerActionSelector
if (actionMethod.IsSpecialName)
{
// not a normal method, e.g. a constructor or an event
yield break;
}
if (actionMethod.GetBaseDefinition().SafeGet(x => x.DeclaringType).IsAssignableFrom(typeof(ApiController)))
{
// is a method on Object, IHttpController, ApiController
yield break;
}
foreach (var c in Conventions)
{
if (actionMethod.Name.StartsWith(c.HttpMethod.Method, StringComparison.OrdinalIgnoreCase))
{
var requiresId = !string.IsNullOrEmpty(c.Url);
if (!_alreadyUsed.Contains(c))
{
// Check first parameter, if it requires ID
if (!requiresId || (actionMethod.GetParameters().Length > 0 && actionMethod.GetParameters()[0].Name.Equals("id", StringComparison.OrdinalIgnoreCase)))
{
yield return BuildRouteAttribute(c);
_alreadyUsed.Add(c);
}
}
}
}
}
void Classify(MethodInfo method, Dictionary<MethodInfo, MethodInfo> virtuals)
{
if(method.IsVirtual) {
virtuals[method.GetBaseDefinition()] = method;
return;
}
classifier.Classify(method);
}
private static MethodInfo GetBaseDefinition(MethodInfo method)
{
if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
{
method = method.GetGenericMethodDefinition();
}
return method.GetBaseDefinition();
}
protected virtual bool IsActionMethod(MethodInfo method)
{
Precondition.Require(method, () => Error.ArgumentNull("method"));
if (method.IsDefined(typeof(IgnoreActionAttribute), false))
return false;
return (!method.IsAbstract && !method.IsSpecialName && !method.ContainsGenericParameters &&
typeof(Controller).IsAssignableFrom(method.GetBaseDefinition().DeclaringType));
}
protected virtual bool IsActionMethod(MethodInfo method,
bool ignoreInfrastructureMethods)
{
if (method.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(AsyncController)))
return false;
if (ignoreInfrastructureMethods && IsCompletedSuffixedMethod(method))
return false;
return true;
}
protected virtual IMethodCallTranslator GetItem(MethodInfo key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
IMethodCallTranslator translator;
if (Registry.TryGetValue(key, out translator))
{
return translator;
}
if (key.IsGenericMethod && !key.IsGenericMethodDefinition)
{
if (Registry.TryGetValue(key.GetGenericMethodDefinition(), out translator))
{
return translator;
}
}
// Check if the generic form of the declaring type matches
translator = GetItemFromGenericType(key);
if (translator != null)
{
return translator;
}
// Check any interfaces that may have a matching method
translator = GetItemFromInterfaces(key);
if (translator != null)
{
return translator;
}
// Finally, check base method if this is a virtual method
var baseMethod = key.GetBaseDefinition();
if ((baseMethod != null) && (baseMethod != key))
{
return GetItem(baseMethod);
}
// No match found
return null;
}
private HandlerPipeline CreatePipeline(MethodInfo method, IEnumerable<ICallHandler> handlers)
{
HandlerPipelineKey key = HandlerPipelineKey.ForMethod(method);
if (pipelines.ContainsKey(key))
{
return pipelines[key];
}
if (method.GetBaseDefinition() == method)
{
pipelines[key] = new HandlerPipeline(handlers);
return pipelines[key];
}
var basePipeline = CreatePipeline(method.GetBaseDefinition(), handlers);
pipelines[key] = basePipeline;
return basePipeline;
}
public MethodInf(MethodInfo method, IFieldHandlerFactory fieldHandlerFactory)
{
MethodInfo = method;
_name = method.Name;
foreach (var itf in GetInterfacesForMethod(method.DeclaringType, method.GetBaseDefinition()))
{
_ifaceName = itf.Name;
break;
}
var syncReturnType = method.ReturnType.UnwrapTask();
if (syncReturnType != typeof(void))
_resultFieldHandler = fieldHandlerFactory.CreateFromType(syncReturnType, FieldHandlerOptions.None);
var parameterInfos = method.GetParameters();
_parameters = new ParameterInf[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
{
_parameters[i] = new ParameterInf(parameterInfos[i], fieldHandlerFactory);
}
}
static StackObject *GetBaseDefinition_8(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.MethodInfo instance_of_this_method = (System.Reflection.MethodInfo) typeof(System.Reflection.MethodInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetBaseDefinition();
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public MethodAddVirtual(Type modifyingType, MethodInfo virtual_method, MethodInfo custom_method, MethodHookType type = MethodHookType.RunAfter, MethodHookFlags flags = MethodHookFlags.None)
: base(virtual_method, custom_method, type, flags)
{
ModifyingType = modifyingType;
if (ModifyingType == null)
throw new ArgumentException("No target type specified!");
if (!virtual_method.DeclaringType.IsAssignableFrom(modifyingType))
throw new ArgumentException("Given Type [" + ModifyingType.FullName + "] is not a child of target [" + virtual_method.DeclaringType + "]!");
base.Validate_4_ParameterLayout();
if (modifyingType
.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
.Select(m => m.GetBaseDefinition())
.Contains(virtual_method.GetBaseDefinition()))
{
if (virtual_method.DeclaringType == modifyingType)
{
throw new ArgumentException("Can't add a new virtual override method [" + virtual_method.Name + "]. Type [" + modifyingType.FullName + "] appears to already have such one. May just use a hook?");
}
}
else
{
throw new NotImplementedException("This part hopefully isn't necessary ever :p");
/*
* MAKE SURE THAT WE HAVE THE REF TO ACTUAL BASE FUNCTION WE MODIFY ... required to to base.ourfunc();
*
var tMeth = modifyingType
.GetMethods();
var virtParamTypes = virtual_method.GetParameters().Select(p => p.ParameterType);
var similarMethods = modifyingType
.GetMethods()
.Where(f => f.Name == virtual_method.Name
&& f.ReturnType == virtual_method.ReturnType
&& f.IsStatic == virtual_method.IsStatic
&& f.GetParameters().Select(p => p.ParameterType).SequenceEqual(virtParamTypes)
);
if (similarMethods.Count() > 0)
throw new ArgumentException("Can't add a new virtual override method [" + virtual_method.Name + "]. Type [" + modifyingType.FullName + "] appears to already have such one. May just use a hook?");
*/
}
}
private static string GetTypeModifiers(System.Reflection.MethodInfo methodInfo)
{
if (methodInfo.IsAbstract)
{
return("abstract");
}
if (methodInfo.IsStatic)
{
return("static");
}
if (methodInfo.IsVirtual)
{
return("virtual");
}
if (methodInfo.GetBaseDefinition() != methodInfo)
{
return("override");
}
return("");
}
private unsafe static void RegisterMethod (MethodInfo minfo, Type type, IntPtr handle) {
ExportAttribute ea = (ExportAttribute) Attribute.GetCustomAttribute (minfo.GetBaseDefinition (), typeof (ExportAttribute));
if (ea == null || (minfo.IsVirtual && minfo.DeclaringType != type && minfo.DeclaringType.Assembly == NSObject.MonoMacAssembly))
return;
RegisterMethod (minfo, ea, type, handle);
}
public bool SupportsMethod(MethodInfo method)
{
return method != null && method.Name == "ToString" && method.GetBaseDefinition().DeclaringType == typeof(object);
}
public static MethodInfo GetBaseDefinition(this MethodInfo method)
{
Requires.NotNull(method, nameof(method));
return(method.GetBaseDefinition());
}
//======================================================================================
// For virtual non-new slot methods, returns the least derived method that occupies the slot.
// For everything else, return "this".
//======================================================================================
public static MethodInfo GetRuntimeBaseDefinition(this MethodInfo method)
{
return(method.GetBaseDefinition());
}
private bool IsOverriddenMethod(MethodInfo methodInfo)
{
return methodInfo != null && methodInfo.DeclaringType != methodInfo.GetBaseDefinition ().DeclaringType;
}
//https://msdn.microsoft.com/en-us/library/system.reflection.methodinfo.getbasedefinition(v=vs.110).aspx
internal static bool IsInterfaceImpl(MethodInfo mti, Type[] cgTypesInterfaces)
{
if (mti == null)
return false;
if (cgTypesInterfaces == null || cgTypesInterfaces.Length <= 0)
return false;
try
{
var bdef = mti.GetBaseDefinition();
if (bdef == null)
return false;
//If the current MethodInfo object represents an interface implementation,
//the GetBaseDefinition method returns the current MethodInfo object.
if (!bdef.Equals(mti))
return false;
foreach (var i in cgTypesInterfaces)
{
var iMethods = i.GetMethods();
foreach (var im in iMethods)
{
if (im.Name != mti.Name)
continue;
var imParams = im.GetParameters();
var mtiParams = mti.GetParameters();
if (imParams.Length != mtiParams.Length)
continue;
if (mti.NfReturnType() != im.NfReturnType())
return false;
if (imParams.Length == 0)
return true;
var imParamTypes = imParams.Select(x => x.NfParameterType()).ToList();
var mtiParamTypes = mtiParams.Select(x => x.NfParameterType()).ToList();
return imParamTypes.All(x => mtiParamTypes.Any(y => x == y));
}
}
}
catch
{
return false;
}
return false;
}
protected bool IsFinalizer(MethodInfo methodInfo)
{
return methodInfo.Name == "Finalize" && methodInfo.GetBaseDefinition().DeclaringType == typeof(object);
}
public static MethodInfo GetRuntimeBaseDefinition(this MethodInfo method)
{
RuntimeReflectionExtensions.CheckAndThrow(method);
return(method.GetBaseDefinition());
}
public static MethodInfo GetRuntimeBaseDefinition(this MethodInfo method)
{
CheckAndThrow(method);
return(method.GetBaseDefinition());
}
internal NativeMethodBuilder (MethodInfo minfo) : this (minfo, minfo.DeclaringType, (ExportAttribute) Attribute.GetCustomAttribute (minfo.GetBaseDefinition (), typeof (ExportAttribute))) {}
private static bool IsOverride(MethodInfo method)
{
if(method.GetBaseDefinition() != method)
{
return true;
}
return false;
}
public override System.Reflection.MethodInfo GetBaseDefinition()
{
return(_realMethod.GetBaseDefinition());
}
protected string TryTranslateMethodCall(string context, string[] args, MethodInfo method)
{
if (method == null) return null;
IJsMethodTranslator translator;
if (MethodTranslators.TryGetValue(method, out translator))
{
return translator.TranslateCall(context, args, method);
}
if (method.IsGenericMethod)
{
var genericMethod = method.GetGenericMethodDefinition();
if (MethodTranslators.TryGetValue(genericMethod, out translator))
{
return translator.TranslateCall(context, args, method);
}
}
foreach (var iface in method.DeclaringType.GetInterfaces())
{
if (Interfaces.Contains(iface))
{
var map = method.DeclaringType.GetInterfaceMap(iface);
var imIndex = Array.IndexOf(map.TargetMethods, method);
if (imIndex >= 0 && MethodTranslators.ContainsKey(map.InterfaceMethods[imIndex]))
return MethodTranslators[map.InterfaceMethods[imIndex]].TranslateCall(context, args, method);
}
}
if (method.DeclaringType.IsGenericType && !method.DeclaringType.IsGenericTypeDefinition)
{
var genericType = method.DeclaringType.GetGenericTypeDefinition();
var m2 = genericType.GetMethod(method.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
if (m2 != null)
{
var r2 = TryTranslateMethodCall(context, args, m2);
if (r2 != null) return r2;
}
}
if (method.DeclaringType == typeof(Array))
{
var m2 = typeof(Array).GetMethod(method.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
if (m2 != null)
{
var r2 = TryTranslateMethodCall(context, args, m2);
if (r2 != null) return r2;
}
}
var baseMethod = method.GetBaseDefinition();
if (baseMethod != null && baseMethod != method) return TryTranslateMethodCall(context, args, baseMethod);
else return null;
}
private static MethodInvoker SpitAndInstantiateClassFor(MethodInfo method){
TypeBuilder tb = MethodInvoker.module.DefineType("invoker"+MethodInvoker.count++, TypeAttributes.Public, typeof(MethodInvoker));
MethodBuilder mb = tb.DefineMethod("Invoke", MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.ReuseSlot,
typeof(Object), new Type[]{typeof(Object), typeof(Object[])});
#if !DEBUG
mb.SetCustomAttribute(new CustomAttributeBuilder(CompilerGlobals.debuggerStepThroughAttributeCtor, new Object[]{}));
mb.SetCustomAttribute(new CustomAttributeBuilder(CompilerGlobals.debuggerHiddenAttributeCtor, new Object[]{}));
#endif
ILGenerator il = mb.GetILGenerator();
if (!method.DeclaringType.IsPublic) method = method.GetBaseDefinition();
Type obT = method.DeclaringType;
if (!method.IsStatic){
il.Emit(OpCodes.Ldarg_1);
if (obT.IsValueType){
Convert.EmitUnbox(il, obT, Type.GetTypeCode(obT));
Convert.EmitLdloca(il, obT);
}else{
il.Emit(OpCodes.Castclass, obT);
}
}
ParameterInfo[] parameters = method.GetParameters();
LocalBuilder[] outTemps = null;
for (int i = 0, n = parameters.Length; i < n; i++){
il.Emit(OpCodes.Ldarg_2);
ConstantWrapper.TranslateToILInt(il, i);
Type pt = parameters[i].ParameterType;
if (pt.IsByRef){
pt = pt.GetElementType();
if (outTemps == null) outTemps = new LocalBuilder[n];
outTemps[i] = il.DeclareLocal(pt);
il.Emit(OpCodes.Ldelem_Ref);
if (pt.IsValueType)
Convert.EmitUnbox(il, pt, Type.GetTypeCode(pt));
il.Emit(OpCodes.Stloc, outTemps[i]);
il.Emit(OpCodes.Ldloca, outTemps[i]);
}else{
il.Emit(OpCodes.Ldelem_Ref);
if (pt.IsValueType)
Convert.EmitUnbox(il, pt, Type.GetTypeCode(pt));
}
}
if (!method.IsStatic && method.IsVirtual && !method.IsFinal && !obT.IsSealed)
il.Emit(OpCodes.Callvirt, method);
else
il.Emit(OpCodes.Call, method);
Type rt = method.ReturnType;
if (rt == Typeob.Void)
il.Emit(OpCodes.Ldnull);
else if (rt.IsValueType)
il.Emit(OpCodes.Box, rt);
if (outTemps != null){
for (int i = 0, n = parameters.Length; i < n; i++){
LocalBuilder loc = outTemps[i];
if (loc != null){
il.Emit(OpCodes.Ldarg_2);
ConstantWrapper.TranslateToILInt(il, i);
il.Emit(OpCodes.Ldloc, loc);
Type pt = parameters[i].ParameterType.GetElementType();
if (pt.IsValueType)
il.Emit(OpCodes.Box, pt);
il.Emit(OpCodes.Stelem_Ref);
}
}
}
il.Emit(OpCodes.Ret);
Type t = tb.CreateType();
return (MethodInvoker)Activator.CreateInstance(t);
}
private static bool IsValidActionMethod(MethodInfo methodInfo, bool stripInfrastructureMethods) {
if (methodInfo.IsSpecialName) {
// not a normal method, e.g. a constructor or an event
return false;
}
if (methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(AsyncController))) {
// is a method on Object, ControllerBase, Controller, or AsyncController
return false;
};
if (stripInfrastructureMethods) {
string methodName = methodInfo.Name;
if (methodName.StartsWith("End", StringComparison.OrdinalIgnoreCase) || methodName.EndsWith("Completed", StringComparison.OrdinalIgnoreCase)) {
// do not match EndFoo() or FooCompleted() methods, as these are infrastructure methods
return false;
}
}
return true;
}
private static MethodInfo GetMethodOnTypeThatImplementsInterfaceMethod(Type type, MethodInfo method)
{
var baseDefinition = method.GetBaseDefinition();
if (!baseDefinition.DeclaringType.IsInterface || !TypeImplementsInterface(type, baseDefinition.DeclaringType))
{
return null;
}
var interfaceMap = type.GetInterfaceMap(baseDefinition.DeclaringType);
return
(from methodTargetPair in interfaceMap.InterfaceMethods
.Zip(interfaceMap.TargetMethods, (interfaceMethod, targetMethod) => new { InterfaceMethod = interfaceMethod, TargetMethod = targetMethod })
where HasSameBaseMethod(EnsureNonGeneric(methodTargetPair.InterfaceMethod), EnsureNonGeneric(method))
select MakeGeneric(methodTargetPair.TargetMethod, method)).First();
}
public static MethodInfo GetBaseDefinition(this MethodInfo method)
{
ArgumentNullException.ThrowIfNull(method);
return(method.GetBaseDefinition());
}
private static bool IsValidActionMethod(MethodInfo methodInfo)
{
return !(methodInfo.IsSpecialName ||
methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(Controller)));
}
public static EventInfo GetEvent(MethodInfo eventAdderOrRemover)
{
return
(from e in eventAdderOrRemover.DeclaringType.GetEvents()
where object.Equals(e.GetAddMethod().GetBaseDefinition(), eventAdderOrRemover.GetBaseDefinition())
|| object.Equals(e.GetRemoveMethod().GetBaseDefinition(), eventAdderOrRemover.GetBaseDefinition())
select e).SingleOrDefault();
}
/// <summary>
/// This is an exact copy from ApiControllerActionSelector.
/// </summary>
private static bool IsValidActionMethod(MethodInfo methodInfo)
{
if (methodInfo.IsSpecialName)
{
// not a normal method, e.g. a constructor or an event
return false;
}
if (methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(TypeHelper.ApiControllerType))
{
// is a method on Object, IHttpController, ApiController
return false;
}
return true;
}
/// <summary>
/// Gets the specified method's ID Value. If the method has not been scanned already, a new ID Value is created.
/// </summary>
/// <param name="aMethod">The method to get the ID Value of.</param>
/// <returns>The method's ID Value.</returns>
public string GetMethodIDValue(MethodInfo aMethod)
{
string methodSignature = Utils.GetMethodSignature(aMethod);
string result = null;
if (MethodIDValues.ContainsKey(methodSignature))
{
result = MethodIDValues[methodSignature];
}
else
{
//Check if method is actually an override
// - If so, use the same method ID value as parent method
MethodInfo baseDefMethod = aMethod.GetBaseDefinition();
if (baseDefMethod != aMethod)
{
result = GetMethodIDValue(baseDefMethod);
}
else
{
result = (currentMethodIDValue++).ToString();
}
MethodIDValues.Add(methodSignature, result);
}
return result;
}
