/// <inheritdoc /> public async Task InvokeAsync(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var methodInfo = context.ViewComponentDescriptor?.MethodInfo; if (methodInfo == null) { throw new InvalidOperationException(Resources.FormatPropertyOfTypeCannotBeNull( nameof(ViewComponentDescriptor.MethodInfo), nameof(ViewComponentDescriptor))); } var isAsync = typeof(Task).IsAssignableFrom(methodInfo.ReturnType); IViewComponentResult result; if (isAsync) { result = await InvokeAsyncCore(context); } else { // We support falling back to synchronous if there is no InvokeAsync method, in this case we'll still // execute the IViewResult asynchronously. result = InvokeSyncCore(context); } await result.ExecuteAsync(context); }
private static ViewComponentContext GetViewComponentContext(IView view, Stream stream) { var actionContext = new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var viewContext = new ViewContext( actionContext, view, viewData, new TempDataDictionary(actionContext.HttpContext, new SessionStateTempDataProvider()), TextWriter.Null, new HtmlHelperOptions()); var writer = new StreamWriter(stream) { AutoFlush = true }; var viewComponentDescriptor = new ViewComponentDescriptor() { TypeInfo = typeof(object).GetTypeInfo(), }; var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary<string, object>(), new HtmlTestEncoder(), viewContext, writer); return viewComponentContext; }
/// <inheritdoc /> public virtual object Create(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var componentType = context.ViewComponentDescriptor.TypeInfo; if (componentType.IsValueType || componentType.IsInterface || componentType.IsAbstract || (componentType.IsGenericType && componentType.IsGenericTypeDefinition)) { var message = Resources.FormatValueInterfaceAbstractOrOpenGenericTypesCannotBeActivated( componentType.FullName, GetType().FullName); throw new InvalidOperationException(message); } var viewComponent = _typeActivatorCache.CreateInstance<object>( context.ViewContext.HttpContext.RequestServices, context.ViewComponentDescriptor.TypeInfo.AsType()); return viewComponent; }
/// <summary> /// Encodes and writes the <see cref="Content"/>. /// </summary> /// <param name="context">The <see cref="ViewComponentContext"/>.</param> public void Execute(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } context.HtmlEncoder.Encode(context.Writer, Content); }
private void PrepareViewComponentContext(HttpTestContext testContext, ViewComponentContext viewComponentContext) { this.TestContext = testContext; this.Arguments = viewComponentContext.Arguments; this.HtmlEncoder = viewComponentContext.HtmlEncoder; this.ViewComponentDescriptor = viewComponentContext.ViewComponentDescriptor; this.ViewContext = viewComponentContext.ViewContext; TestHelper.SetActionContextToAccessor(this.ViewContext); }
public void Activate(ViewComponentContext viewComponentContext, object viewComponent) { var propertiesToActivate = propertyActivatorCache.GetOrAdd(viewComponent.GetType(), getPropertiesToActivate); for (var i = 0; i < propertiesToActivate.Length; i++) { var activateInfo = propertiesToActivate[i]; activateInfo.Activate(viewComponent, viewComponentContext); } }
public static ViewComponentContextMock FromViewComponentContext(HttpTestContext testContext, ViewComponentContext viewComponentContext) { CommonValidator.CheckForNullReference(testContext, nameof(HttpTestContext)); CommonValidator.CheckForNullReference(viewComponentContext, nameof(ViewComponentContext)); viewComponentContext.ViewComponentDescriptor = viewComponentContext.ViewComponentDescriptor ?? new ViewComponentDescriptor(); viewComponentContext.ViewContext = ViewContextMock.FromViewContext(testContext, viewComponentContext.ViewContext ?? new ViewContext()); viewComponentContext.Arguments = viewComponentContext.Arguments ?? new Dictionary<string, object>(); viewComponentContext.HtmlEncoder = viewComponentContext.HtmlEncoder ?? HtmlEncoder.Default; return new ViewComponentContextMock(testContext, viewComponentContext); }
public ObjectMethodExecutor GetViewComponentMethodExecutor(ViewComponentContext viewComponentContext) { var cache = CurrentCache; var viewComponentDescriptor = viewComponentContext.ViewComponentDescriptor; ObjectMethodExecutor executor; if (cache.Entries.TryGetValue(viewComponentDescriptor, out executor)) { return executor; } executor = ObjectMethodExecutor.Create(viewComponentDescriptor.MethodInfo, viewComponentDescriptor.TypeInfo); cache.Entries.TryAdd(viewComponentDescriptor, executor); return executor; }
/// <inheritdoc /> public virtual void Release(ViewComponentContext context, object viewComponent) { if (context == null) { throw new InvalidOperationException(nameof(context)); } if (viewComponent == null) { throw new InvalidOperationException(nameof(viewComponent)); } var disposable = viewComponent as IDisposable; if (disposable != null) { disposable.Dispose(); } }
/// <inheritdoc /> public virtual void Release(ViewComponentContext context, object viewComponent) { if (context == null) { throw new InvalidOperationException(nameof(context)); } if (viewComponent == null) { throw new InvalidOperationException(nameof(viewComponent)); } var disposable = viewComponent as IDisposable; if (disposable != null) { disposable.Dispose(); } }
public async Task InvokeAsync(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var executor = _viewComponentInvokerCache.GetViewComponentMethodExecutor(context); var returnType = executor.MethodReturnType; if (returnType == typeof(void) || returnType == typeof(Task)) { throw new InvalidOperationException(Resources.ViewComponent_MustReturnValue); } IViewComponentResult result; object?component = null; try { component = _viewComponentFactory.CreateViewComponent(context); if (executor.IsMethodAsync) { result = await InvokeAsyncCore(executor, component, context); } else { // We support falling back to synchronous if there is no InvokeAsync method, in this case we'll still // execute the IViewResult asynchronously. result = InvokeSyncCore(executor, component, context); } } finally { if (component != null) { await _viewComponentFactory.ReleaseViewComponentAsync(context, executor); } } await result.ExecuteAsync(context); }
public void Constructor_PerformsDefensiveCopies() { // Arrange var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var tempData = new TempDataDictionary(httpContext, new SessionStateTempDataProvider()); var viewContext = new ViewContext( actionContext, NullView.Instance, viewData, tempData, TextWriter.Null, new HtmlHelperOptions()); var viewComponentDescriptor = new ViewComponentDescriptor(); // Act var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary <string, object>(), new HtmlTestEncoder(), viewContext, TextWriter.Null); // Assert // New ViewContext but initial View and TextWriter copied over. Assert.NotSame(viewContext, viewComponentContext.ViewContext); Assert.Same(tempData, viewComponentContext.TempData); Assert.Same(viewContext.View, viewComponentContext.ViewContext.View); Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer); // Double-check the convenience properties. Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData); Assert.Same(viewComponentContext.ViewContext.TempData, viewComponentContext.TempData); Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer); // New VDD instance but initial ModelMetadata copied over. Assert.NotSame(viewData, viewComponentContext.ViewData); Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata); }
public void ReleaseViewComponent_CallsDispose_OnTheInstance() { // Arrange var context = new ViewComponentContext { }; var component = new ActivablePropertiesViewComponent(); var viewComponentActivator = new Mock<IViewComponentActivator>(); viewComponentActivator.Setup(vca => vca.Release(context, component)) .Callback<ViewComponentContext, object>((c, o) => (o as IDisposable)?.Dispose()); var factory = new DefaultViewComponentFactory(viewComponentActivator.Object); // Act factory.ReleaseViewComponent(context, component); // Assert Assert.Equal(true, component.Disposed); }
private async Task <IHtmlContent> InvokeCoreAsync(ViewComponentDescriptor descriptor, object arguments) { var argumentDictionary = GetArgumentDictionary(descriptor, arguments); var viewBuffer = new ViewBuffer(_viewBufferScope, descriptor.FullName, ViewBuffer.ViewComponentPageSize); using (var writer = new ViewBufferTextWriter(viewBuffer, _viewContext.Writer.Encoding)) { var context = new ViewComponentContext(descriptor, argumentDictionary, _htmlEncoder, _viewContext, writer); var invoker = _invokerFactory.CreateInstance(context); if (invoker == null) { throw new InvalidOperationException( Resources.FormatViewComponent_IViewComponentFactory_ReturnedNull(descriptor.FullName)); } await invoker.InvokeAsync(context); return(viewBuffer); } }
public void ReleaseViewComponent_CallsDispose_OnTheInstance() { // Arrange var context = new ViewComponentContext { }; var component = new ActivablePropertiesViewComponent(); var viewComponentActivator = new Mock <IViewComponentActivator>(); viewComponentActivator.Setup(vca => vca.Release(context, component)) .Callback <ViewComponentContext, object>((c, o) => (o as IDisposable)?.Dispose()); var factory = new DefaultViewComponentFactory(viewComponentActivator.Object); // Act factory.ReleaseViewComponent(context, component); // Assert Assert.True(component.Disposed); }
/// <inheritdoc /> public object Create(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var componentType = context.ViewComponentDescriptor.TypeInfo; if (componentType == null) { throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull( nameof(context.ViewComponentDescriptor.TypeInfo), nameof(context.ViewComponentDescriptor))); } var viewComponent = _typeActivatorCache.CreateInstance <object>( context.ViewContext.HttpContext.RequestServices, context.ViewComponentDescriptor.TypeInfo.AsType()); return(viewComponent); }
public void Constructor_PerformsDefensiveCopies() { // Arrange var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var viewContext = new ViewContext( actionContext, NullView.Instance, viewData, new TempDataDictionary(httpContext, new SessionStateTempDataProvider()), TextWriter.Null, new HtmlHelperOptions()); var viewComponentDescriptor = new ViewComponentDescriptor(); // Act var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary<string, object>(), new HtmlTestEncoder(), viewContext, TextWriter.Null); // Assert // New ViewContext but initial View and TextWriter copied over. Assert.NotSame(viewContext, viewComponentContext.ViewContext); Assert.Same(viewContext.View, viewComponentContext.ViewContext.View); Assert.Same(viewContext.Writer, viewComponentContext.ViewContext.Writer); // Double-check the convenience properties. Assert.Same(viewComponentContext.ViewContext.ViewData, viewComponentContext.ViewData); Assert.Same(viewComponentContext.ViewContext.Writer, viewComponentContext.Writer); // New VDD instance but initial ModelMetadata copied over. Assert.NotSame(viewData, viewComponentContext.ViewData); Assert.Same(viewData.ModelMetadata, viewComponentContext.ViewData.ModelMetadata); }
public async Task ReleaseViewComponentAsync_CallsDisposeAsync_OnAsyncDisposableComponents() { // Arrange var context = new ViewComponentContext { }; var component = new AsyncDisposableViewComponent(); var viewComponentActivator = new Mock <IViewComponentActivator>(); viewComponentActivator.Setup(vca => vca.ReleaseAsync(context, component)) .Callback <ViewComponentContext, object>((c, o) => (o as IAsyncDisposable)?.DisposeAsync()) .Returns(default(ValueTask)); var factory = new DefaultViewComponentFactory(viewComponentActivator.Object); // Act await factory.ReleaseViewComponentAsync(context, component); // Assert Assert.True(component.Disposed); }
public void CreateViewComponent_ActivatesProperties_OnTheInstance() { // Arrange var context = new ViewComponentContext { }; var component = new ActivablePropertiesViewComponent(); var activator = new Mock<IViewComponentActivator>(); activator.Setup(a => a.Create(context)) .Returns(component); var factory = new DefaultViewComponentFactory(activator.Object); // Act var result = factory.CreateViewComponent(context); // Assert var activablePropertiesComponent = Assert.IsType<ActivablePropertiesViewComponent>(result); Assert.Same(component, activablePropertiesComponent); Assert.Same(component.Context, activablePropertiesComponent.Context); }
public void CreateViewComponent_ActivatesProperties_OnTheInstance() { // Arrange var context = new ViewComponentContext { }; var component = new ActivablePropertiesViewComponent(); var activator = new Mock <IViewComponentActivator>(); activator.Setup(a => a.Create(context)) .Returns(component); var factory = new DefaultViewComponentFactory(activator.Object); // Act var result = factory.CreateViewComponent(context); // Assert var activablePropertiesComponent = Assert.IsType <ActivablePropertiesViewComponent>(result); Assert.Same(component, activablePropertiesComponent); Assert.Same(component.Context, activablePropertiesComponent.Context); }
private static IViewEngine ResolveViewEngine(ViewComponentContext context) { return(context.ViewContext.HttpContext.RequestServices.GetRequiredService <ICompositeViewEngine>()); }
/// <summary>Releases the view component.</summary> /// <param name="context">The <see cref="ViewComponentContext"/> associated with the viewComponent.</param> /// <param name="viewComponent">The view component to release.</param> public void Release(ViewComponentContext context, object viewComponent) { // No-op. }
private async Task <IViewComponentResult> InvokeAsyncCore(ObjectMethodExecutor executor, ViewComponentContext context) { var component = _viewComponentFactory.CreateViewComponent(context); using (_logger.ViewComponentScope(context)) { var arguments = ControllerActionExecutor.PrepareArguments(context.Arguments, executor); _diagnosticSource.BeforeViewComponent(context, component); _logger.ViewComponentExecuting(context, arguments); var startTimestamp = _logger.IsEnabled(LogLevel.Debug) ? Stopwatch.GetTimestamp() : 0; object resultAsObject = null; var taskGenericType = executor.TaskGenericType; if (taskGenericType == typeof(IViewComponentResult)) { resultAsObject = await(Task <IViewComponentResult>) executor.Execute(component, arguments); } else if (taskGenericType == typeof(string)) { resultAsObject = await(Task <string>) executor.Execute(component, arguments); } else if (taskGenericType == typeof(IHtmlContent)) { resultAsObject = await(Task <IHtmlContent>) executor.Execute(component, arguments); } else { resultAsObject = await executor.ExecuteAsync(component, arguments); } var viewComponentResult = CoerceToViewComponentResult(resultAsObject); _logger.ViewComponentExecuted(context, startTimestamp, viewComponentResult); _diagnosticSource.AfterViewComponent(context, viewComponentResult, component); _viewComponentFactory.ReleaseViewComponent(context, component); return(viewComponentResult); } }
private IViewComponentResult InvokeSyncCore(ObjectMethodExecutor executor, object component, ViewComponentContext context) { using (_logger.ViewComponentScope(context)) { var arguments = PrepareArguments(context.Arguments, executor); _diagnosticListener.BeforeViewComponent(context, component); _logger.ViewComponentExecuting(context, arguments); var stopwatch = ValueStopwatch.StartNew(); object?result; result = executor.Execute(component, arguments); var viewComponentResult = CoerceToViewComponentResult(result); _logger.ViewComponentExecuted(context, stopwatch.GetElapsedTime(), viewComponentResult); _diagnosticListener.AfterViewComponent(context, viewComponentResult, component); return(viewComponentResult); } }
/// <summary>Creates a view component.</summary> /// <param name="context"></param> /// <returns>A view component instance.</returns> public object Create(ViewComponentContext context) => this.container.GetInstance(context.ViewComponentDescriptor.TypeInfo.AsType());
/// <inheritdoc /> public virtual void Release(ViewComponentContext context, object viewComponent) { }
private async Task <IViewComponentResult> InvokeAsyncCore(ObjectMethodExecutor executor, object component, ViewComponentContext context) { using (_logger.ViewComponentScope(context)) { var arguments = PrepareArguments(context.Arguments, executor); _diagnosticListener.BeforeViewComponent(context, component); _logger.ViewComponentExecuting(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); _logger.ViewComponentExecuted(context, stopwatch.GetElapsedTime(), viewComponentResult); _diagnosticListener.AfterViewComponent(context, viewComponentResult, component); return(viewComponentResult); } }
/// <summary> /// Locates and renders a view specified by <see cref="ViewName"/>. If <see cref="ViewName"/> is <c>null</c>, /// then the view name searched for is<c>"Default"</c>. /// </summary> /// <param name="context">The <see cref="ViewComponentContext"/> for the current component execution.</param> /// <returns>A <see cref="Task"/> which will complete when view rendering is completed.</returns> public async Task ExecuteAsync(ViewComponentContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var viewEngine = ViewEngine ?? ResolveViewEngine(context); var viewContext = context.ViewContext; var isNullOrEmptyViewName = string.IsNullOrEmpty(ViewName); ViewEngineResult result = null; IEnumerable <string> originalLocations = null; if (!isNullOrEmptyViewName) { // If view name was passed in is already a path, the view engine will handle this. result = viewEngine.GetView(viewContext.ExecutingFilePath, ViewName, isMainPage: false); originalLocations = result.SearchedLocations; } if (result == null || !result.Success) { // This will produce a string like: // // Components/Cart/Default // // The view engine will combine this with other path info to search paths like: // // Views/Shared/Components/Cart/Default.cshtml // Views/Home/Components/Cart/Default.cshtml // Areas/Blog/Views/Shared/Components/Cart/Default.cshtml // // This supports a controller or area providing an override for component views. var viewName = isNullOrEmptyViewName ? DefaultViewName : ViewName; var qualifiedViewName = string.Format( CultureInfo.InvariantCulture, ViewPathFormat, context.ViewComponentDescriptor.ShortName, viewName); result = viewEngine.FindView(viewContext, qualifiedViewName, isMainPage: false); } var view = result.EnsureSuccessful(originalLocations).View; using (view as IDisposable) { if (_diagnosticListener == null) { _diagnosticListener = viewContext.HttpContext.RequestServices.GetRequiredService <DiagnosticListener>(); } _diagnosticListener.ViewComponentBeforeViewExecute(context, view); var childViewContext = new ViewContext( viewContext, view, ViewData ?? context.ViewData, context.Writer); await view.RenderAsync(childViewContext); _diagnosticListener.ViewComponentAfterViewExecute(context, view); } }
public void WithCustomViewComponentContextShouldSetItToAccessor() { MyApplication .StartsFrom<DefaultStartup>() .WithServices(services => { services.AddSingleton<IActionContextAccessor, ActionContextAccessor>(); }); var actionDescriptor = new ActionDescriptor { DisplayName = "Test" }; var context = new ViewComponentContext { ViewContext = new ViewContext { ActionDescriptor = actionDescriptor } }; MyViewComponent<AccessorComponent> .Instance() .WithViewComponentContext(context) .ShouldPassForThe<AccessorComponent>(viewComponent => { Assert.NotNull(viewComponent); Assert.NotNull(viewComponent.ActionContext); Assert.Equal("Test", viewComponent.ActionContext.ActionDescriptor.DisplayName); }); MyApplication.StartsFrom<DefaultStartup>(); }
private async Task <IViewComponentResult> InvokeAsyncCore(ObjectMethodExecutor executor, ViewComponentContext context) { var component = _viewComponentFactory.CreateViewComponent(context); using (_logger.ViewComponentScope(context)) { var arguments = PrepareArguments(context.Arguments, executor); _diagnosticSource.BeforeViewComponent(context, component); _logger.ViewComponentExecuting(context, arguments); var stopwatch = ValueStopwatch.StartNew(); object resultAsObject; var returnType = executor.MethodReturnType; if (returnType == typeof(Task <IViewComponentResult>)) { resultAsObject = await(Task <IViewComponentResult>) executor.Execute(component, arguments); } else if (returnType == typeof(Task <string>)) { resultAsObject = await(Task <string>) executor.Execute(component, arguments); } else if (returnType == typeof(Task <IHtmlContent>)) { resultAsObject = await(Task <IHtmlContent>) executor.Execute(component, arguments); } else { resultAsObject = await executor.ExecuteAsync(component, arguments); } var viewComponentResult = CoerceToViewComponentResult(resultAsObject); _logger.ViewComponentExecuted(context, stopwatch.GetElapsedTime(), viewComponentResult); _diagnosticSource.AfterViewComponent(context, viewComponentResult, component); _viewComponentFactory.ReleaseViewComponent(context, component); return(viewComponentResult); } }
/// <summary> /// Encodes and writes the <see cref="Content"/>. /// </summary> /// <param name="context">The <see cref="ViewComponentContext"/>.</param> /// <returns>A completed <see cref="Task"/>.</returns> public Task ExecuteAsync(ViewComponentContext context) { Execute(context); return TaskCache.CompletedTask; }
public void Execute(ViewComponentContext context) { }
private static ViewComponentContext GetViewComponentContext( IView view, ViewDataDictionary viewData, object diagnosticListener = null) { var diagnosticSource = new DiagnosticListener("Microsoft.AspNetCore"); if (diagnosticListener == null) { diagnosticListener = new TestDiagnosticListener(); } diagnosticSource.SubscribeWithAdapter(diagnosticListener); var serviceProvider = new Mock<IServiceProvider>(); serviceProvider.Setup(s => s.GetService(typeof(DiagnosticSource))).Returns(diagnosticSource); var httpContext = new DefaultHttpContext(); httpContext.RequestServices = serviceProvider.Object; var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var viewContext = new ViewContext( actionContext, view, viewData, new TempDataDictionary(httpContext, new SessionStateTempDataProvider()), TextWriter.Null, new HtmlHelperOptions()); var viewComponentDescriptor = new ViewComponentDescriptor() { ShortName = "Invoke", TypeInfo = typeof(object).GetTypeInfo(), MethodInfo = typeof(object).GetTypeInfo().DeclaredMethods.First() }; var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary<string, object>(), new HtmlTestEncoder(), viewContext, TextWriter.Null); return viewComponentContext; }
public void ViewDataModelSetter_DoesNotThrow_IfValueIncompatibleWithSourceDeclaredType( object model, Type expectedType) { // Arrange var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); var viewData = new ViewDataDictionary<int>(new EmptyModelMetadataProvider()); var viewContext = new ViewContext( actionContext, NullView.Instance, viewData, new TempDataDictionary(httpContext, new SessionStateTempDataProvider()), TextWriter.Null, new HtmlHelperOptions()); var viewComponentDescriptor = new ViewComponentDescriptor(); var viewComponentContext = new ViewComponentContext( viewComponentDescriptor, new Dictionary<string, object>(), new HtmlTestEncoder(), viewContext, TextWriter.Null); // Act (does not throw) // Non-ints can be assigned despite type restrictions in the source ViewDataDictionary. viewComponentContext.ViewData.Model = model; // Assert Assert.Equal(expectedType, viewComponentContext.ViewData.ModelMetadata.ModelType); }
private ViewComponentContextMock(HttpTestContext testContext, ViewComponentContext viewComponentContext) { this.PrepareViewComponentContext(testContext, viewComponentContext); }
private async Task<IViewComponentResult> InvokeAsyncCore(ViewComponentContext context) { var component = _viewComponentFactory.CreateViewComponent(context); using (_logger.ViewComponentScope(context)) { var method = context.ViewComponentDescriptor.MethodInfo; var arguments = ControllerActionExecutor.PrepareArguments(context.Arguments, method.GetParameters()); var methodExecutor = _viewComponentInvokerCache.GetViewComponentMethodExecutor(context); _diagnosticSource.BeforeViewComponent(context, component); _logger.ViewComponentExecuting(context, arguments); var startTimestamp = _logger.IsEnabled(LogLevel.Debug) ? Stopwatch.GetTimestamp() : 0; var result = await ControllerActionExecutor.ExecuteAsync(methodExecutor, component, arguments); var viewComponentResult = CoerceToViewComponentResult(result); _logger.ViewComponentExecuted(context, startTimestamp, viewComponentResult); _diagnosticSource.AfterViewComponent(context, viewComponentResult, component); _viewComponentFactory.ReleaseViewComponent(context, component); return viewComponentResult; } }
public Task ExecuteAsync(ViewComponentContext context) { Execute(context); return(Task.CompletedTask); }
public Task ExecuteAsync(ViewComponentContext context) { return Task.FromResult(0); }