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); }