public static object[] PrepareArguments(
IDictionary<string, object> actionParameters,
ObjectMethodExecutor actionMethodExecutor)
{
var declaredParameterInfos = actionMethodExecutor.ActionParameters;
var count = declaredParameterInfos.Length;
if (count == 0)
{
return null;
}
var arguments = new object[count];
for (var index = 0; index < count; index++)
{
var parameterInfo = declaredParameterInfos[index];
object value;
if (!actionParameters.TryGetValue(parameterInfo.Name, out value))
{
value = actionMethodExecutor.GetDefaultValueForParameter(index);
}
arguments[index] = value;
}
return arguments;
}
public static Task<object> ExecuteAsync(
ObjectMethodExecutor actionMethodExecutor,
object instance,
object[] orderedActionArguments)
{
return actionMethodExecutor.ExecuteAsync(instance, orderedActionArguments);
}
public static Task<object> ExecuteAsync(
ObjectMethodExecutor actionMethodExecutor,
object instance,
IDictionary<string, object> actionArguments)
{
var orderedArguments = PrepareArguments(actionArguments, actionMethodExecutor.MethodInfo.GetParameters());
return ExecuteAsync(actionMethodExecutor, instance, orderedArguments);
}
private static async Task <object> ExecuteWithParameterAsync(ObjectMethodExecutor executor, object @class, object[] parameter)
{
if (executor.IsMethodAsync)
{
return(await executor.ExecuteAsync(@class, parameter));
}
return(executor.Execute(@class, parameter));
}
public override async ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object[] arguments)
{
await(Task) executor.Execute(controller, arguments);
return(new EmptyResult());
}
public override ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
executor.Execute(controller, arguments);
return(new ValueTask <IActionResult>(new EmptyResult()));
}
private Func <object[], Task <object> > CreateFallBackExecutor(
ObjectMethodExecutor fallbackMethodExcutor, Type fallBackType)
{
return(async parameters =>
{
var instance = EngineContext.Current.Resolve(fallBackType);
return fallbackMethodExcutor.ExecuteAsync(instance, parameters).GetAwaiter().GetResult();
});
}
private async Task <object> ExecuteAsync(ObjectMethodExecutor executor, object @class)
{
if (executor.IsMethodAsync)
{
return(await executor.ExecuteAsync(@class));
}
return(executor.Execute(@class));
}
private async Task <IViewComponentResult> InvokeAsyncCore(ObjectMethodExecutor executor, object component, ViewComponentContext context)
{
using (Log.ViewComponentScope(_logger, context))
{
var arguments = PrepareArguments(context.Arguments, executor);
_diagnosticListener.BeforeViewComponent(context, component);
Log.ViewComponentExecuting(_logger, context, arguments);
var stopwatch = ValueStopwatch.StartNew();
object resultAsObject;
var returnType = executor.MethodReturnType;
if (returnType == typeof(Task <IViewComponentResult>))
{
var task = executor.Execute(component, arguments);
if (task is null)
{
throw new InvalidOperationException(Resources.ViewComponent_MustReturnValue);
}
resultAsObject = await(Task <IViewComponentResult>) task;
}
else if (returnType == typeof(Task <string>))
{
var task = executor.Execute(component, arguments);
if (task is null)
{
throw new InvalidOperationException(Resources.ViewComponent_MustReturnValue);
}
resultAsObject = await(Task <string>) task;
}
else if (returnType == typeof(Task <IHtmlContent>))
{
var task = executor.Execute(component, arguments);
if (task is null)
{
throw new InvalidOperationException(Resources.ViewComponent_MustReturnValue);
}
resultAsObject = await(Task <IHtmlContent>) task;
}
else
{
resultAsObject = await executor.ExecuteAsync(component, arguments);
}
var viewComponentResult = CoerceToViewComponentResult(resultAsObject);
Log.ViewComponentExecuted(_logger, context, stopwatch.GetElapsedTime(), viewComponentResult);
_diagnosticListener.AfterViewComponent(context, viewComponentResult, component);
return(viewComponentResult);
}
}
public override ValueTask <IActionResult> Execute(
ActionContext actionContext,
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
executor.Execute(controller, arguments);
return(new(EmptyResultInstance));
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodResolver"/> class.
/// </summary>
/// <param name="methodInfo">The method information.</param>
public MethodResolver(MethodInfo methodInfo)
{
Guard.ArgumentNotNull(methodInfo, nameof(methodInfo));
_executor = ObjectMethodExecutor.Create(methodInfo, methodInfo.DeclaringType.GetTypeInfo());
_prameterTypes = methodInfo.GetParameters().Select(it => it.ParameterType).ToArray();
if (_prameterTypes.Length == 0 || _prameterTypes[0] != typeof(ResolverContext) || (methodInfo.ReturnType != typeof(ValueTask <object>) && (methodInfo.ReturnType != typeof(Task <object>))))
{
throw new GraphException($"The {methodInfo.DeclaringType.Name}.{methodInfo.Name} is not a valid resolver method.");
}
}
public (ControllerActionInvokerCacheEntry cacheEntry, IFilterMetadata[] filters) GetCachedResult(ControllerContext controllerContext)
{
var actionDescriptor = controllerContext.ActionDescriptor;
IFilterMetadata[] filters;
var cacheEntry = actionDescriptor.CacheEntry;
// We don't care about thread safety here
if (cacheEntry is null)
{
var filterFactoryResult = FilterFactory.GetAllFilters(_filterProviders, controllerContext);
filters = filterFactoryResult.Filters;
var parameterDefaultValues = ParameterDefaultValues
.GetParameterDefaultValues(actionDescriptor.MethodInfo);
var objectMethodExecutor = ObjectMethodExecutor.Create(
actionDescriptor.MethodInfo,
actionDescriptor.ControllerTypeInfo,
parameterDefaultValues);
var controllerFactory = _controllerFactoryProvider.CreateControllerFactory(actionDescriptor);
var controllerReleaser = _controllerFactoryProvider.CreateAsyncControllerReleaser(actionDescriptor);
var propertyBinderFactory = ControllerBinderDelegateProvider.CreateBinderDelegate(
_parameterBinder,
_modelBinderFactory,
_modelMetadataProvider,
actionDescriptor,
_mvcOptions);
var actionMethodExecutor = ActionMethodExecutor.GetExecutor(objectMethodExecutor);
var filterExecutor = actionDescriptor.FilterDelegate is not null
? ActionMethodExecutor.GetFilterExecutor(actionDescriptor)
: null;
cacheEntry = new ControllerActionInvokerCacheEntry(
filterFactoryResult.CacheableFilters,
controllerFactory,
controllerReleaser,
propertyBinderFactory,
objectMethodExecutor,
filterExecutor ?? actionMethodExecutor,
actionMethodExecutor);
actionDescriptor.CacheEntry = cacheEntry;
}
else
{
// Filter instances from statically defined filter descriptors + from filter providers
filters = FilterFactory.CreateUncachedFilters(_filterProviders, controllerContext, cacheEntry.CachedFilters);
}
return(cacheEntry, filters);
}
private async Task <IWebSocketActionResult> InvokeActionMethodAsync(ObjectMethodExecutor executor, object controller, IDictionary <string, object> parameters)
{
// Order the parameters used to invoke the action
var orderedParameters = ControllerActionExecutor.PrepareArguments(parameters, executor);
// Execute the action
var resultAsObject = executor.Execute(controller, orderedParameters);
// If the result is not of type IWebSocketActionResult, create a WebSocketObjectResult with the result
return(resultAsObject as IWebSocketActionResult ?? new WebSocketObjectResult(resultAsObject));
}
private ValueTask <object> ExecuteHubMethod(ObjectMethodExecutor methodExecutor, THub hub, object[] arguments, HubConnectionContext connection, IServiceProvider serviceProvider)
{
if (_invokeMiddleware != null)
{
var invocationContext = new HubInvocationContext(methodExecutor, connection.HubCallerContext, serviceProvider, hub, arguments);
return(_invokeMiddleware(invocationContext));
}
// If no Hub filters are registered
return(ExecuteMethod(methodExecutor, hub, arguments));
}
private async Task <object> ExecuteAsync(ObjectMethodExecutor executor, GrainReference grain, object[] parameters)
{
try
{
return(await executor.ExecuteAsync(grain.Grain, parameters));
}
catch (Exception ex)
{
throw new OrleansRequestException("Requesting Orleans failed ...", ex);
}
}
public override async ValueTask <IActionResult> Execute(
ActionContext actionContext,
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
var context = new ControllerEndpointFilterInvocationContext(_controllerActionDescriptor, actionContext, executor, mapper, controller, arguments);
var result = await _controllerActionDescriptor.FilterDelegate !(context);
return(ConvertToActionResult(mapper, result, executor.IsMethodAsync ? executor.AsyncResultType ! : executor.MethodReturnType));
}
/// <summary>
/// 执行方法，同时支持同步和异步方法
/// <para>采用微软的 <see cref="ObjectMethodExecutor" /> </para>
/// <para>https://github.com/dotnet/aspnetcore/blob/master/src/Shared/ObjectMethodExecutor/ObjectMethodExecutor.cs </para>
/// </summary>
/// <param name="this">方法信息</param>
/// <param name="obj">实例</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
public static async Task <object> ExecuteAsync(this MethodInfo @this, object obj, params object[] parameters)
{
var key = $"{@this.Module.Name}_{@this.ReflectedType.Name}_{@this.MetadataToken}";
var executor = _executors.GetOrAdd(key, x => ObjectMethodExecutor.Create(@this, @this.ReflectedType.GetTypeInfo()));
if (executor.IsMethodAsync)
{
return(await executor.ExecuteAsync(obj, parameters));
}
return(executor.Execute(obj, parameters));
}
public override ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
// Sync method returning arbitrary object
var returnValue = executor.Execute(controller, arguments);
var actionResult = ConvertToActionResult(mapper, returnValue, executor.MethodReturnType);
return(new ValueTask <IActionResult>(actionResult));
}
/// <summary>
/// 执行方法，仅支持同步方法
/// <para>采用微软的 <see cref="ObjectMethodExecutor" /> </para>
/// <para>https://github.com/dotnet/aspnetcore/blob/master/src/Shared/ObjectMethodExecutor/ObjectMethodExecutor.cs </para>
/// </summary>
/// <param name="this">方法信息</param>
/// <param name="obj">实例</param>
/// <param name="parameters">参数</param>
/// <returns></returns>
public static object Execute(this MethodInfo @this, object obj, params object[] parameters)
{
var key = $"{@this.Module.Name}_{@this.ReflectedType.Name}_{@this.MetadataToken}";
var executor = _executors.GetOrAdd(key, x => ObjectMethodExecutor.Create(@this, @this.ReflectedType.GetTypeInfo()));
if (!executor.IsMethodAsync)
{
return(executor.Execute(obj, parameters));
}
throw new Exception($"Not supported async method:{@this.Name}");
}
public override ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
var actionResult = (IActionResult)executor.Execute(controller, arguments) !;
EnsureActionResultNotNull(executor, actionResult);
return(new ValueTask <IActionResult>(actionResult));
}
public void CanExcuteMethodWithParameters()
{
var testClass = new MethodExecutorClass();
var methodInfo = testClass.GetType().GetMethod("Add");
var executor = ObjectMethodExecutor.Create(methodInfo, typeof(MethodExecutorClass).GetTypeInfo());
Assert.NotNull(executor);
var objResult = executor.Execute(testClass, 1, 2);
Assert.Equal(3, objResult);
}
public static ActionMethodExecutor GetExecutor(ObjectMethodExecutor executor)
{
for (var i = 0; i < Executors.Length; i++)
{
if (Executors[i].CanExecute(executor))
{
return(Executors[i]);
}
}
Debug.Fail("Should not get here");
throw new Exception();
}
public override async ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
// Async method returning awaitable-of-nonvoid
var returnValue = await executor.ExecuteAsync(controller, arguments);
var actionResult = ConvertToActionResult(mapper, returnValue, executor.AsyncResultType !);
return(actionResult);
}
public override async ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
// Async method returning awaitable-of-IActionResult (e.g., Task<ViewResult>)
// We have to use ExecuteAsync because we don't know the awaitable's type at compile time.
var actionResult = (IActionResult)await executor.ExecuteAsync(controller, arguments);
EnsureActionResultNotNull(executor, actionResult);
return(actionResult);
}
public async Task <object> Invoke(Type grainType, object grain, GrainRouteValues grainRouteValues, HttpContext context)
{
var executor = _cachedExecutors.GetOrAdd($"{grainType.FullName}.{grainRouteValues.GrainMethod}",
(key) =>
{
var mi = Internal.ReflectionUtil.GetMethodsIncludingBaseInterfaces(grainType)
.FirstOrDefault(x => string.Equals(x.Name, grainRouteValues.GrainMethod));
return(ObjectMethodExecutor.Create(mi, grainType.GetTypeInfo()));
});
var parameters = await GetParameters(executor, context.Request);
return(await executor.ExecuteAsync(grain, parameters));
}
public static async Task <MqConsumerExecutedResult> InvokeAsync(MqConsumerExecutor consumerExecutor, string msgJson)
{
if (consumerExecutor == null)
{
throw new ArgumentException("consumerExecutor不能为空");
}
if (string.IsNullOrWhiteSpace(msgJson))
{
throw new ArgumentException("msgJson不能为空");
}
var instance = GetInstance(consumerExecutor);
if (instance == null)
{
throw new ArgumentException("MqConsumerExecutor Instance不能为空");
}
var parameters = consumerExecutor.Parameters;
var executeParameters = new object[parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
object value = null;
if (parameter.ParameterType.IsValueType)
{
value = Activator.CreateInstance(parameter.ParameterType);
}
else
{
if (parameter.ParameterType.Name.IndexOf(nameof(MqMessage <object>), StringComparison.OrdinalIgnoreCase) > -1)
{
value = JsonConvert.DeserializeObject(msgJson, parameter.ParameterType);
}
}
executeParameters[i] = value;
}
var executor = ObjectMethodExecutor.Create(consumerExecutor.MethodInfo, consumerExecutor.TypeInfo);
var executedResult = await ExecuteWithParameterAsync(executor, instance, executeParameters);
var consumerExecutedResult = executedResult as MqConsumerExecutedResult;
return(consumerExecutedResult);
}
internal ControllerActionInvokerCacheEntry(
FilterItem[] cachedFilters,
Func <ControllerContext, object> controllerFactory,
Action <ControllerContext, object> controllerReleaser,
ControllerBinderDelegate controllerBinderDelegate,
ObjectMethodExecutor objectMethodExecutor,
ActionMethodExecutor actionMethodExecutor)
{
ControllerFactory = controllerFactory;
ControllerReleaser = controllerReleaser;
ControllerBinderDelegate = controllerBinderDelegate;
CachedFilters = cachedFilters;
ObjectMethodExecutor = objectMethodExecutor;
ActionMethodExecutor = actionMethodExecutor;
}
public void CanGetExcuteMethodDefaultValue()
{
var testClass = new MethodExecutorClass();
var methodInfo = testClass.GetType().GetMethod("WithDefaultValue");
var executor = ObjectMethodExecutor.Create(methodInfo, typeof(MethodExecutorClass).GetTypeInfo());
var objResult = executor.GetDefaultValueForParameter(0);
Assert.Equal("aaa", objResult);
var objResult2 = executor.GetDefaultValueForParameter(1);
Assert.Equal("bbb", objResult2);
}
public override async ValueTask <IActionResult> Execute(
IActionResultTypeMapper mapper,
ObjectMethodExecutor executor,
object controller,
object?[]?arguments)
{
// Async method returning Task<IActionResult>
// Avoid extra allocations by calling Execute rather than ExecuteAsync and casting to Task<IActionResult>.
var returnValue = executor.Execute(controller, arguments);
var actionResult = await(Task <IActionResult>) returnValue !;
EnsureActionResultNotNull(executor, actionResult);
return(actionResult);
}
public ControllerEndpointFilterInvocationContext(
ControllerActionDescriptor actionDescriptor,
ActionContext actionContext,
ObjectMethodExecutor executor,
IActionResultTypeMapper mapper,
object controller,
object?[]?arguments)
{
ActionDescriptor = actionDescriptor;
ActionContext = actionContext;
Mapper = mapper;
Executor = executor;
Controller = controller;
Arguments = arguments ?? Array.Empty <object?>();
}
private void ReConfiguration(IGovernanceProvider governanceProvider)
{
if (governanceProvider != null)
{
GovernanceOptions.CacheEnabled = governanceProvider.CacheEnabled;
GovernanceOptions.ExecutionTimeout = governanceProvider.ExecutionTimeout;
GovernanceOptions.FuseProtection = governanceProvider.FuseProtection;
GovernanceOptions.MaxConcurrent = governanceProvider.MaxConcurrent;
GovernanceOptions.ShuntStrategy = governanceProvider.ShuntStrategy;
GovernanceOptions.FuseSleepDuration = governanceProvider.FuseSleepDuration;
GovernanceOptions.FailoverCount = governanceProvider.FailoverCount;
FailoverCountIsDefaultValue = governanceProvider.FailoverCount == 0;
}
var governanceAttribute = governanceProvider as GovernanceAttribute;
if (governanceAttribute?.FallBackType != null)
{
Type fallBackType;
if (ReturnType == typeof(void))
{
fallBackType = EngineContext.Current.TypeFinder.FindClassesOfType <IFallbackInvoker>()
.FirstOrDefault(p => p == governanceAttribute.FallBackType);
if (fallBackType == null)
{
throw new LmsException($"未能找到{governanceAttribute.FallBackType.FullName}的实现类");
}
}
else
{
fallBackType = typeof(IFallbackInvoker <>);
fallBackType = fallBackType.MakeGenericType(ReturnType);
if (!EngineContext.Current.TypeFinder.FindClassesOfType(fallBackType)
.Any(p => p == governanceAttribute.FallBackType))
{
throw new LmsException($"未能找到{governanceAttribute.FallBackType.FullName}的实现类");
}
}
var invokeMethod = fallBackType.GetMethods().First(p => p.Name == "Invoke");
var fallbackMethodExcutor = ObjectMethodExecutor.Create(invokeMethod, fallBackType.GetTypeInfo(),
ParameterDefaultValues.GetParameterDefaultValues(invokeMethod));
FallBackExecutor = CreateFallBackExecutor(fallbackMethodExcutor, fallBackType);
}
GovernanceOptions.ProhibitExtranet = governanceAttribute?.ProhibitExtranet ?? false;
}
public HubMethodDescriptor(ObjectMethodExecutor methodExecutor, IEnumerable <IAuthorizeData> policies)
{
MethodExecutor = methodExecutor;
ParameterTypes = methodExecutor.MethodParameters.Select(GetParameterType).ToArray();
Policies = policies.ToArray();
NonAsyncReturnType = (MethodExecutor.IsMethodAsync)
? MethodExecutor.AsyncResultType
: MethodExecutor.MethodReturnType;
if (IsChannelType(NonAsyncReturnType, out var channelItemType))
{
IsChannel = true;
StreamReturnType = channelItemType;
}
}
public (ControllerActionInvokerCacheEntry cacheEntry, IFilterMetadata[] filters) GetCachedResult(ControllerContext controllerContext)
{
var cache = CurrentCache;
var actionDescriptor = controllerContext.ActionDescriptor;
IFilterMetadata[] filters;
if (!cache.Entries.TryGetValue(actionDescriptor, out var cacheEntry))
{
var filterFactoryResult = FilterFactory.GetAllFilters(_filterProviders, controllerContext);
filters = filterFactoryResult.Filters;
var parameterDefaultValues = ParameterDefaultValues
.GetParameterDefaultValues(actionDescriptor.MethodInfo);
var objectMethodExecutor = ObjectMethodExecutor.Create(
actionDescriptor.MethodInfo,
actionDescriptor.ControllerTypeInfo,
parameterDefaultValues);
var controllerFactory = _controllerFactoryProvider.CreateControllerFactory(actionDescriptor);
var controllerReleaser = _controllerFactoryProvider.CreateControllerReleaser(actionDescriptor);
var propertyBinderFactory = ControllerBinderDelegateProvider.CreateBinderDelegate(
_parameterBinder,
_modelBinderFactory,
_modelMetadataProvider,
actionDescriptor,
_mvcOptions);
var actionMethodExecutor = ActionMethodExecutor.GetExecutor(objectMethodExecutor);
cacheEntry = new ControllerActionInvokerCacheEntry(
filterFactoryResult.CacheableFilters,
controllerFactory,
controllerReleaser,
propertyBinderFactory,
objectMethodExecutor,
actionMethodExecutor);
cacheEntry = cache.Entries.GetOrAdd(actionDescriptor, cacheEntry);
}
else
{
// Filter instances from statically defined filter descriptors + from filter providers
filters = FilterFactory.CreateUncachedFilters(_filterProviders, controllerContext, cacheEntry.CachedFilters);
}
return(cacheEntry, filters);
}
