protected InvokeResult InvokeListenerMethodOnListenerObject(object requestObject)
{
InvokeResult returnValue = new InvokeResult();
try
{
var safeMethod = new Spring.Reflection.Dynamic.SafeMethod(this._listenerMethod);
var invocationResult = safeMethod.Invoke(this._listenerObject, requestObject);
if (this._listenerMethod.ReturnType.IsAssignableFrom(typeof(Task)))
{
((Task)invocationResult).GetAwaiter().GetResult();
if (this._listenerMethod.ReturnType.IsGenericType)
{
returnValue.ReturnedValue = ((Task <dynamic>)invocationResult).Result;
}
else
{
returnValue.ReturnedValue = null;
}
}
else
{
returnValue.ReturnedValue = invocationResult;
}
}
catch (System.Exception ex)
{
returnValue.Exception = ex;
}
return(returnValue);
}
/// <summary>
/// Creates dynamic method instance for the specified <see cref="MethodInfo"/>.
/// </summary>
/// <param name="method">Method info to create dynamic method for.</param>
/// <returns>Dynamic method for the specified <see cref="MethodInfo"/>.</returns>
public static IDynamicMethod Create(MethodInfo method)
{
AssertUtils.ArgumentNotNull(method, "You cannot create a dynamic method for a null value.");
IDynamicMethod dynamicMethod = new SafeMethod(method);
return(dynamicMethod);
}
/// <summary>
/// Avoid beforeFieldInit
/// </summary>
static LocalResourceManager()
{
LocalResXResourceProviderFactoryType = typeof(IResourceProvider).Assembly.GetType("System.Web.Compilation.ResXResourceProviderFactory", true);
LocalResXResourceProviderType = typeof(IResourceProvider).Assembly.GetType("System.Web.Compilation.LocalResXResourceProvider", true);
GetResourceProviderDelegate fnGetResourceProvider = null;
ResourceProviderFactory rpf = null;
SafeMethod glra = null;
SecurityCritical.ExecutePrivileged(new PermissionSet(PermissionState.Unrestricted), delegate
{
fnGetResourceProvider = (GetResourceProviderDelegate)Delegate.CreateDelegate(typeof(GetResourceProviderDelegate), typeof(ResourceExpressionBuilder).GetMethod("GetLocalResourceProvider", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { typeof(TemplateControl) }, null));
rpf = (ResourceProviderFactory)Activator.CreateInstance( LocalResXResourceProviderFactoryType, true );
glra = new SafeMethod(LocalResXResourceProviderType.GetMethod("GetLocalResourceAssembly", BindingFlags.Instance | BindingFlags.NonPublic));
});
getLocalResourceProvider = fnGetResourceProvider;
LocalResXResourceProviderFactory = rpf;
fnGetLocalResourceAssembly = glra;
}
public object Invoke(IMethodInvocation info)
{
try
{
MethodInfo methodInfo = info.Method;
object returnValue = base.Invoke(methodInfo, info.Arguments, info.Proxy);
if (returnValue != InvokeImplementation)
{
return returnValue;
}
var method = new SafeMethod(methodInfo);
return method.Invoke(GetImplementation(), info.Arguments);
}
catch (TargetInvocationException ex)
{
exceptionInternalPreserveStackTrace.Invoke(ex.InnerException, new Object[] {});
throw ex.InnerException;
}
}
/// <summary>
/// Invokes the joinpoint using dynamic reflection.
/// </summary>
/// <remarks>
/// <p>
/// Subclasses can override this to use custom invocation.
/// </p>
/// </remarks>
/// <returns>
/// The return value of the invocation of the joinpoint.
/// </returns>
/// <exception cref="System.Exception">
/// If invoking the joinpoint resulted in an exception.
/// </exception>
/// <see cref="Spring.Aop.Framework.AbstractMethodInvocation.InvokeJoinpoint"/>
protected override object InvokeJoinpoint()
{
MethodInfo targetMethodInfo = ((this.proxyMethod == null)) ? method : this.proxyMethod;
IDynamicMethod targetMethod = new SafeMethod(targetMethodInfo);
try
{
AssertUtils.Understands(target, "target", targetMethodInfo);
return targetMethod.Invoke(target, arguments);
}
// Only happens if fallback to standard reflection.
catch (TargetInvocationException ex)
{
throw ReflectionUtils.UnwrapTargetInvocationException(ex);
}
}
/// <summary>
/// Creates dynamic method instance for the specified <see cref="MethodInfo"/>.
/// </summary>
/// <param name="method">Method info to create dynamic method for.</param>
/// <returns>Dynamic method for the specified <see cref="MethodInfo"/>.</returns>
public static IDynamicMethod Create(MethodInfo method)
{
AssertUtils.ArgumentNotNull(method, "You cannot create a dynamic method for a null value.");
IDynamicMethod dynamicMethod = new SafeMethod(method);
return dynamicMethod;
}
static WebApplicationContext()
{
ILog s_weblog = LogManager.GetLogger(typeof(WebApplicationContext));
// register for ContextRegistry.Cleared event - we need to discard our cache in this case
ContextRegistry.Cleared += new EventHandler(OnContextRegistryCleared);
#if !MONO_2_0
if (HttpRuntime.AppDomainAppVirtualPath != null) // check if we're within an ASP.NET AppDomain!
{
// ensure HttpRuntime has been fully initialized!
// this is a problem,.if ASP.NET Web Administration Application is used. This app does not fully set up the AppDomain...
HttpRuntime runtime =
(HttpRuntime)
typeof(HttpRuntime).GetField("_theRuntime", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
bool beforeFirstRequest = false;
lock (runtime)
{
beforeFirstRequest =
(bool)
typeof(HttpRuntime).GetField("_beforeFirstRequest", BindingFlags.Instance | BindingFlags.NonPublic).
GetValue(runtime);
}
s_weblog.Debug("BeforeFirstRequest:" + beforeFirstRequest);
if (beforeFirstRequest)
{
try
{
string firstRequestPath = HttpRuntime.AppDomainAppVirtualPath.TrimEnd('/') + "/dummy.context";
s_weblog.Info("Forcing first request " + firstRequestPath);
SafeMethod fnProcessRequestNow = new SafeMethod(typeof(HttpRuntime).GetMethod("ProcessRequestNow", BindingFlags.Static | BindingFlags.NonPublic));
SimpleWorkerRequest wr = new SimpleWorkerRequest(firstRequestPath, string.Empty, new StringWriter());
fnProcessRequestNow.Invoke(null, new object[] { wr });
// HttpRuntime.ProcessRequest(
// wr);
s_weblog.Info("Successfully processed first request!");
}
catch (Exception ex)
{
s_weblog.Error("Failed processing first request", ex);
throw;
}
}
}
#endif
}
private void Initialize(string methodName, object[] argValues, object context)
{
Type contextType = (context is Type ? context as Type : context.GetType());
// check the context type first
MethodInfo mi = GetBestMethod(contextType, methodName, BINDING_FLAGS, argValues);
// if not found, probe the Type's type
if (mi == null)
{
mi = GetBestMethod(typeof(Type), methodName, BINDING_FLAGS, argValues);
}
if (mi == null)
{
return;
}
else
{
ParameterInfo[] parameters = mi.GetParameters();
if (parameters.Length > 0)
{
ParameterInfo lastParameter = parameters[parameters.Length - 1];
cachedIsParamArray = lastParameter.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0;
if (cachedIsParamArray)
{
paramArrayType = lastParameter.ParameterType.GetElementType();
argumentCount = parameters.Length;
}
}
cachedInstanceMethod = new SafeMethod(mi);
cachedInstanceMethodHash = CalculateMethodHash(contextType, argValues);
}
}
