private IEnumerable <MethodImplementationInfo> DoGetInterceptableMethods(Type implementationType)
{
var interceptableMethodsToInterfaceMap = new Dictionary <MethodInfo, MethodInfo>();
foreach (MethodInfo method in
implementationType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (MethodOverride.MethodCanBeIntercepted(method))
{
interceptableMethodsToInterfaceMap[method] = null;
}
}
foreach (Type itf in implementationType.GetInterfaces())
{
var mapping = implementationType.GetInterfaceMap(itf);
for (int i = 0; i < mapping.InterfaceMethods.Length; ++i)
{
if (interceptableMethodsToInterfaceMap.ContainsKey(mapping.TargetMethods[i]))
{
interceptableMethodsToInterfaceMap[mapping.TargetMethods[i]] = mapping.InterfaceMethods[i];
}
}
}
foreach (var kvp in interceptableMethodsToInterfaceMap)
{
yield return(new MethodImplementationInfo(kvp.Value, kvp.Key));
}
}
MethodDef?LookupOverride(MethodOverride o)
{
if (!methodOverrides.TryGetValue(o.MethodDeclaration, out var info))
{
return(null);
}
if (!comparer.Equals(info.MethodDeclaration.DeclaringType, o.MethodDeclaration.DeclaringType))
{
return(null);
}
return(info.TargetMethod);
}
public static AppFunc OwinApp(IDictionary <string, object> startupEnv = null)
{
var app =
new List <Func <AppFunc, AppFunc> >()
.Use(H5bp.IeEdgeChromeFrameHeader())
.Use(H5bp.RemovePoweredBy())
.Use(H5bp.CrossDomainRules())
.Use(JsonBodyParser.Middleware())
.Use(UrlEncoded.Middleware())
.Use(MethodOverride.Middleware());
var router = new RegexRouter(app);
var template = new RazorEngine.Templating.TemplateService();
router.Get("/", next =>
async env =>
{
await env.GetResponseBody()
.WriteStringAsync("hi");
});
template.Compile("Hi @Model.name", typeof(DynamicObject), "/hi");
router.Get(@"/hi/(?<name>((.)*))$", next =>
async env =>
{
var routeParameters = env.GetSimpleOwinRouteParameters();
string html = template.Run("/hi", new { name = routeParameters["name"] }.ToDynamicObject());
await env.GetResponseBody()
.WriteStringAsync(html);
});
router.Get("/hello", next =>
async env =>
{
await env.GetResponseBody()
.WriteStringAsync("Hello");
});
router.All("*", NotFound.Middleware());
return(app.ToOwinApp());
}
private static bool IsMatchingOverride(MethodOverride methodOverride, IMethodDefOrRef targetMethod)
{
SigComparer comparer = default;
var targetDeclTypeDef = targetMethod.DeclaringType.ResolveTypeDef();
var overrideDeclTypeDef = methodOverride.MethodDeclaration.DeclaringType.ResolveTypeDef();
if (!comparer.Equals(targetDeclTypeDef, overrideDeclTypeDef))
{
return(false);
}
var targetMethodSig = targetMethod.MethodSig;
var overrideMethodSig = methodOverride.MethodDeclaration.MethodSig;
targetMethodSig = ResolveGenericSignature(targetMethod, targetMethodSig);
overrideMethodSig = ResolveGenericSignature(methodOverride.MethodDeclaration, overrideMethodSig);
return(comparer.Equals(targetMethodSig, overrideMethodSig));
}
private static bool IsMatchingOverride(MethodOverride methodOverride, IMethodDefOrRef targetMethod)
{
SigComparer comparer = default;
var targetDeclTypeDef = targetMethod.DeclaringType.ResolveTypeDef();
var overrideDeclTypeDef = methodOverride.MethodDeclaration.DeclaringType.ResolveTypeDef();
if (!comparer.Equals(targetDeclTypeDef, overrideDeclTypeDef))
{
return(false);
}
var targetMethodSig = targetMethod.MethodSig;
var overrideMethodSig = methodOverride.MethodDeclaration.MethodSig;
if (methodOverride.MethodDeclaration.DeclaringType is TypeSpec spec && spec.TypeSig is GenericInstSig genericInstSig)
{
overrideMethodSig = GenericArgumentResolver.Resolve(overrideMethodSig, genericInstSig.GenericArguments);
}
return(comparer.Equals(targetMethodSig, overrideMethodSig));
}
void InitializeFrom(MethodOverrideOptions options) => methodOverride = options.Create();
public MethodOverrideOptions(MethodOverride mo)
{
this.MethodBody = mo.MethodBody;
this.MethodDeclaration = mo.MethodDeclaration;
}
void Add(MethodOverride mo)
{
// It's a struct so can't be null
Push(mo.MethodBody);
Push(mo.MethodDeclaration);
}